Identity that outlives the session
An agent has its own address, role, mailbox and history. The session dies and is reborn; it stays who it was.
Open source · MIT · macOS
Your agents talk to each other.You stop being the wire.
Trama is a message broker between long-running Claude sessions. Identity that outlives the session, a durable mailbox, and a scheduler that decides who runs, when, and with which context.
In daily use on a real operation, across two clients and five projects. No signed build yet — for now you build it from source.
One request of yours, three agents, and the whole trail on one screen — with the cost running next to its ceiling.
Right now, the bus is you
Without Trama
- You talk to one agent in a tab and copy what it produced.
- Paste it into another agent's tab. Wait. Copy the answer back.
- Repeat across nine tabs, and you are the one remembering what each was doing.
- Close the browser and it's gone. No record of who asked for what.
With Trama
- An agent produces a message addressed to another.
- The broker stores it in the recipient's mailbox and schedules its turn.
- The turn runs, the result comes back, and the next message starts there.
- It's all on the record: instruction, message, turn, cost, write to the board.
The insight that organises everything
An LLM session is passive: it only computes when something invokes it. So “the Manager sends a message to the Orchestrator” is not peer-to-peer communication — it is something else, and confusing the two builds a pretty chat that stalls on the first asynchronous message.
- 1The Manager produces a messageaddressed, typed, inside a conversation.
- 2The broker persists it in the mailboxand it survives closing the app, losing the network, rebooting.
- 3The broker schedules and runs the turnof the recipient — with its context, not yours.
The illusion of two peers talking is really a turn scheduler over passive sessions. That primitive is what Trama gives you.
Money
Spending in plain sight, and a button that stops everything
The last 24 hours' total sits pinned at the top of the window, with the share of the client closest to its own cap next to it — the 24 h cap is per client, and comparing it to the total would give a reassuring number exactly when there are many.
- One click interrupts every turn in flight and blocks dispatch, scanning and the watchdog.
- Interrupting without blocking brakes nothing: the message stays in the mailbox and the turn restarts a moment later.
- Pulled, it stays pulled after restarting the service — which is exactly what you do right after pulling it.
Mirrored board
The board on your screen, without touching the tracker
Every scan writes the state of the cards to your disk. The screen opens instantly, doesn't spend the client's API quota on each click, and keeps answering with the tracker down — which is exactly when someone will look.
- A blocked card looks blocked, and says by whom.
- What left the sprint is marked, not deleted: “where did it go” is the question.
- Each card shows when it was last seen — the lag is stated, not hidden.
Level 3
The orchestrator delegates, and the work lands on a branch
An orchestrator can create temporary workers for technical work. Each is born in a git worktree of its own, commits to its own branch, and is retired when done. The worktree goes; the branch stays, for you to review.
- One worktree per worker: two agents never edit the same file at the same time.
- The branch outlives the agent — without it, ephemeral would mean discarded.
- Ships disabled: the worker is the only role with Bash, Write and Edit.
Timeline
What happened while you were asleep
A 12 h, 24 h or 7-day window, with the total turns and the spend for the period. By default it shows only the notable — what stopped, what changed on the board, what got delegated, what recovered on its own — with routine behind a checkbox.
- Escalations and budget warnings arrive as system notifications when the window isn't in front of you.
- The agent's text appears in the conversation as it writes, with the tools it used on a line above.
- A truncated list says so: handing over a slice in silence would look complete on the busiest night.
History
Search what already happened
A full-text index over every message that crossed the bus — your instructions, orchestrator reports, escalations, worker conversations. It answers as you type.
- Prefix as you type; exact phrase in quotes.
- Accent-insensitive, because that's how people type in a hurry.
- Every hit says which conversation it came from: your chat, the board, or a delegation.
Guards
The brake exists because its absence costs money
Two agents that can message each other will message each other forever. The ceilings are cost per conversation, per client over 24 h, and per turn — and the last one is the only that acts while the turn runs.
- The hop limit cuts the A→B→A→B ping-pong. Talking to you resets the count.
- A daily ceiling per client: that's the 3 a.m. brake.
- When a ceiling blows, the conversation stops and you're told — a silent guard is worse than the loop.
When a ceiling blows, this lands in your inbox
Thread interrompida: limite de saltos atingido (7 > 6). Provável laço entre agentes.
And the conversation closes: no new message enters it. A guard that fires silently is worse than the loop — you'd find out from the invoice.
A client is a boundary, not a label
The edges of the graph are derived from each agent's role and client. There is no connection table for anyone to edit, and no prompt instruction asking the model to behave. An agent of one company reaching an agent of another is impossible by construction.
- The check lives in the core, before any message is delivered.
- Card content is data, never a command.
- Each role gets the role's tools — and the list of what it doesn't get is the one that matters.
- A worker only addresses the orchestrator that created it. Not the Manager, not a sibling.
And more
Every item here exists because its absence cost something.
The orchestrator loop outside the LLM
Open sprint, label filter, blocker graph: it runs in code, it's deterministic and costs no tokens. The model only wakes when there's something to decide.
Board writes start in simulation
Every project starts by recording what it would have written. Turning on real writes is an explicit decision, per project.
Failures are classified, not just “an error”
A network blip retries on its own with growing backoff. A configuration error stops and waits for you, because repeating won't help.
Atomic claim on the tracker
The status transition is the lock: no work starts without it. That's what keeps two people — or two agents — off the same card.
Core on the server, window on your Mac
Orchestration continues with the laptop closed. The window reaches it through an SSH tunnel the app brings up and reopens if it drops. An agent can be marked to run on your machine instead, with its disk and its PATH.
Only success consumes the message
A turn that fails, is interrupted or times out returns the work to the mailbox. Closing the app mid-turn loses nothing and duplicates nothing — and orphaned turns rejoin the queue on the next start.
Adopt an existing session
An agent can carry on from a Claude Code conversation that has been running for months. Context no system prompt can recreate.
Messages stuck in a mailbox nobody reads
Delivering to a mailbox is a valid operation: nothing fails, the screen says “sent”, and the message waits forever for an archived agent. One screen lists these, and says why for each.
Archiving can be undone
Clients, projects and agents leave the list without leaving the history, and come back with one click. There is no permanent deletion, on purpose: turns, messages and board writes point at those records.
Export
A conversation as Markdown, with cost, hops and tokens in the header; spending as CSV, one row per agent per day, to split by client in a spreadsheet. The file is born on the window's machine, not the core's.
Portuguese and English
The whole interface, switchable on the spot. Plus light, dark or the system theme — following the system even when it turns at night.
Where your data lives
On your machine
SQLite on disk. No cloud of ours, no account, no sign-up.
No telemetry
The app sends nothing anywhere. There is no “anywhere”.
Secrets outside the database
Tracker credentials go to the system keychain, or a 0600 file on a server without one.
A server, if you want one
The core runs as a service on a machine you own, and the window reaches it over an SSH tunnel.
Install
macOS on Apple Silicon. The core also runs on Linux.
- Claude Code installed and signed in — it's what runs every turn.
- Rust and Node, to build.
The repository is still private. Until it isn't, installation is arranged directly.
There is no Apple-signed build yet. Built by you, the app runs without warnings; downloaded ready-made, Gatekeeper would complain — which is why the download button arrives when the signature does.
Price
Free
MIT licence. There is no paid plan, no account, no usage limit and no reduced edition. The running cost is what you'd already pay Anthropic for the turns — and this app exists largely so that number doesn't surprise you.