Claude Code’s own documentation acknowledges the failure mode of a manager who won’t manage right, though not in one place. “Sometimes the lead starts implementing tasks itself instead of waiting for teammates,” reads Anthropic’s Agent Teams guide in its best-practices section; the fix is to type “Wait for your teammates to complete their tasks before proceeding.” Its troubleshooting section adds: “The lead can stop early too, deciding the team is finished before all tasks are actually complete.” The vendor is documenting a middle manager, in language anyone who has run a team will recognize. The industry’s default way to put several coding agents on one task borrows the human org chart wholesale — a lead, teammates with mailboxes, an opening round of introductions — and until this week nobody had measured whether any of it earns its keep, or whether the real switch is duller: not who’s in charge, but whether agents write to a shared file or message each other, a choice that alone swings the token bill by around 40%.
That measurement now exists. A preprint titled “When Agents Coordinate: Measuring Coordination in Multi-Agent AI Coding” , submitted 17 August 2026 by Giuseppe Destefanis and Tomaso Aste, ran 1,902 instrumented Claude Code sessions on Sonnet 4.6, varying team size, hierarchy and how agents pass information, scored against a fixed behavioral test suite. Its headline finding undercuts the org-chart model directly: “Naming one agent as coordinator creates no communication hub and provides no reliable improvement in success.”
The coordinator title changes nothing measurable
The coordinator condition was thin by design: one agent simply received a prompt stating it was the coordinator, and that was the only difference from any teammate — no extra authority, no synthesis step, no approval gate. Coordinator teams performed no more reliably than flat teams across the primary grid of one, two, four and eight agents. The study’s sharpest reversal ran the other way: at eight agents on a conflicting task split, flat teams solved 20 of 20 runs against coordinator teams’ 6 of 10. A 244-run sealed replication mostly held up the picture — the coordinator finding and the file-versus-messaging channel effect both reproduced — though that specific reversal didn’t.
It is not who is in charge that matters — it is whether agents write to a shared file or message each other, which swings the token bill by around 40%.
Whether agents share a file or message each other sets the bill
What did swing the results was the coordination channel itself. On spec-shaped work, where several agents each hold a piece of one specification, mandatory file coordination cut output tokens by about 42% at eight agents compared with message-heavy coordination. On pipeline-shaped work, where one agent’s output chains into the next, the same file discipline added 17% overhead, because the pipeline already carries the coordination and the file becomes redundant bookkeeping. Direct messaging, left unmanaged, grows close to quadratically with team size — much of it an opening round of introductions nobody asked for.
That is the dial a developer who has flipped on CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 almost never touches. They’ll spend an afternoon on spawn prompts and a lead’s job title, tuning the part the study found does nothing measurable, while running three to five parallel sessions on the vendor’s own shared task list at ~/.claude/tasks/{team-name}/ — a plain directory of pending, in-progress and completed files, with dependency unblocking and file locking so two teammates can’t grab the same task. On the study’s evidence, that directory, not the role above it, is doing the coordinating.
A manager that actually manages might be a different claim
The obvious objection comes from production experience, not the lab. Writing from Cognition on 22 April 2026, Walden Yan argues the coordinator isn’t decoration, it’s the whole design:
“The practical shape is map-reduce-and-manage: a manager splits work, children execute, the manager synthesizes and reports back.”
He dismisses unstructured swarms as “mostly a distraction.” That tension is worth sitting with, because the study’s coordinator and Cognition’s manager aren’t quite the same object. The paper’s coordinator differed from its peers by a single prompt sentence; Claude Code’s actual team lead assigns tasks, approves plans and bubbles permissions, duties its own documentation details. The study measured the label. It did not measure the mechanism — so the honest reading isn’t that management is worthless, only that this experiment can’t yet separate the two, which is exactly the gap Yan’s claim still occupies.
Read across from what the paper measured, the defensible conclusion is narrower than “hierarchy doesn’t matter”: a title with no duties attached buys nothing, while duties attached to no title — file locking, dependency tracking, a shared task list — bought most of what teams gained. That’s a smaller claim than either side wants, and it’s the one 1,902 runs actually support. Two synthetic Python tasks and three days of preprint life still argue for caution.
None of that makes the org chart worthless — it makes it the wrong place to look first. The lead who stops early, or starts doing the work itself, is a real failure mode worth a troubleshooting entry. But the bill for running an agent team gets set upstream, in a choice nobody frames as management at all: does this task’s shape want a shared file, or does it want a conversation.
