Why agent coordination breaks the moment agents leave one context window — and what we're building about it.
In May 2026, Jarred Sumner rewrote Bun's runtime — 535,496 lines of Zig — into more than a million lines of Rust in eleven days. He did it with 64 Claude agents running in parallel: roughly 50 dynamic workflows looping over 1,448 files, 6,502 commits, a peak throughput near 1,300 lines of code per minute, about $165,000 at API list pricing. It worked: Claude Code itself now ships running on the Rust rewrite. It is the largest publicly documented multi-agent software project to date.
Read the writeup closely, though, and a second story emerges. Almost every hard problem was a coordination problem, and almost every solution was a filesystem hack:
git stash before committing, another ran git stash pop, a third ran git reset --hard. The fix was instructing every agent never to run git stash or git reset. Coordination by pleading.Here's the thing the writeup doesn't say outright: a coordination plane existed the whole time. Jarred built it by hand, out of the wrong materials.
The 4×16 worktree shards are a task allocator, implemented as filesystem geometry. The git-command bans are access control, implemented as pleading — probabilistic, per-prompt, enforced by nothing. His manual reading of agent output to catch issues is the live status board, implemented as one man's attention. And the bill line-items the cost of doing it this way: alongside 5.9 billion uncached input tokens sit 72 billion cached-read tokens. Some of that is the mechanical cost of agent loops — but it is also what coordination-by-re-reading looks like on an invoice: a fleet with no queue to ask what's claimed, what's done, what changed while I was working?
Every agent fleet already pays for a coordination plane. The only question is whether it's made of disk layout, prompt discipline, and human vigilance — or made of actual primitives.
The hand-built version has a hard boundary: it only works while everything shares one checkout and one person's attention. Look at what today's coordination mechanisms actually are:
PLAN.md, TODO.md, the task list your orchestrator maintains — a file on a disk. A session in another worktree reads its own copy, can't lock it, can't check off an item the others will see.Every one of these primitives has the same hidden dependency: state that lives in one place nobody else can query. The moment a second session starts, all of them go soft at once. The plan file becomes a rumor. The task list is stale the second it's copied into a prompt. Prompt pleading doesn't cross a process boundary.
And more sessions is exactly where fleets are headed — the Bun rewrite maxed out one engineer's attention, and the next increment of throughput is more parallelism, not less.
The single-session assumption is fragile. The single-vendor assumption is already false. Nobody prices a fleet on one model: you spend frontier tokens where judgment is scarce and route mechanical transforms to whatever is cheap — an open-weight Qwen or DeepSeek on hardware you control, when cost or data locality demands it. And a growing share of the fleet was never a coding agent at all: the agent building your frontend, the one drafting your launch post, the one filling in your research doc.
These agents share no context window, and their vendors' orchestration stories each stop at their own walls — not by oversight but by incentive. An orchestrator that drives competitors' agents is a commodity pipe, and no lab intends to be the pipe. Each will build excellent coordination inside its walls. The layer that spans them can't be a file, and it can't be owned by a model vendor. It has to be neutral, reachable by every session, and speak a protocol every agent already speaks.
That protocol exists: MCP. What's missing is the plane.
Fair question — GitHub Issues, Linear, and Notion are persistent, human-legible, and all have MCP servers. But they were designed for creatures who check in twice a day, not agents that check in twice a second, and it shows in the semantics:
Human teams built trackers when they stopped sharing an office. Agent fleets are hitting the same wall at a thousand times the pace, and they need the machine-native version.
Strip the Bun rewrite down to what Jarred was doing by hand, and you get the spec:
One scoping note: Tandem allocates and gates work. Git remains the integration plane for code — merging what parallel agents produce is git's problem, and solved there. The coordination plane's job is allocation — so two agents rarely collide on the same work in the first place.
Tandem is a task queue and a live board that humans and agents share over MCP. It runs on your machine — one binary, one SQLite file — and self-hosts when a fleet outgrows it.
An agent connects with one tool call and asks the queue for approved work. Claims are atomic — the moment one agent takes a task, every other agent that asks sees it's taken. Two agents can't port the same file, and no prompt has to beg them not to. When the agent finishes — or its context dies trying — it posts a result that outlives the session: what was done, where. Work an agent proposes along the way enters as exactly that, proposed, and waits behind a human gate until someone promotes it to the queue. And you watch all of it on a board rather than a wall of terminals: legible at a glance whether the worker is Claude Code in the terminal next to you or a subagent three layers down.
We hold ourselves to this. Tandem's roadmap is a Tandem canvas, and the agents that build Tandem pull their tasks from it. The queue you'd be adopting is the queue this essay was planned in.
Tandem is early. It's dogfooded daily by its own builder, and it has not yet coordinated a Bun-scale fleet — we're building the plane before the fleet is fully airborne. You also don't need to believe in cross-vendor swarms to want it today: even a three-terminal, one-laptop fleet loses its coordination state every time a context window dies, and a queue that remembers is worth having at n=3.
The next fleet at Bun's scale will span more sessions, because that's where the throughput is, and more vendors, because that's where the specialized agents are. But you don't have to believe in that future to see the problem — the coordination that carried the last fleet was one disk, one repo, and one very good engineer reading output instead of sleeping, and it was already crashing at 64 agents. Past that line, coordination has to live outside any one session, speak a protocol every agent speaks, keep its state when contexts die, and keep a human's hand on the gate.
That is what Tandem is: the coordination plane for fleets that span sessions, vendors, and days.
Sources: Jarred Sumner's Bun-in-Rust writeup and coverage by Simon Willison, The Pragmatic Engineer, and The Register (July 2026).