Skimming this morning's arxiv list I almost scrolled past it — another multi-agent paper. But the numbers in the table stopped me. A coordination framework that beats MetaGPT by 45 accuracy points while using a quarter of the tokens is not the kind of result you can wave away as benchmark-luck. The thesis I'm pulling out of it: most of what we call "multi-agent failure" is actually concurrency failure, and we have been borrowing the wrong patterns to fix it.
What it does#
Improving the Efficiency of Language Agent Teams with Adaptive Task Graphs, submitted May 7 by a Princeton/Cambridge/MIT/NYU group (lead author Elizabeth Mieczkowski), proposes LATTE — a coordination protocol where agents collaboratively build and edit a shared task graph instead of being slotted into pre-assigned roles. The graph encodes sub-task dependencies, current assignments, and progress state. Agents read it, claim work, write back, and discover new tasks as they go.
The framing is the part I find sharp: the authors borrow directly from distributed systems. Multi-agent LLM teams operate under partial observability, message delay, and conflicting writes — exactly the regime where consensus protocols, locks, and event ordering exist. Most prior multi-agent frameworks (MetaGPT-style waterfalls, leader-worker hierarchies, fully decentralized chatter) treat agents like employees in an org chart. LATTE treats them like processes in a distributed system, and the structure-vs-flexibility dial is set by how the graph is allowed to evolve rather than by how the roles are written.
The key result#
Across three task families — exploratory data analysis, debugging, and library extension — LATTE reached 79.7% overall accuracy versus MetaGPT's 33.9% (p<0.01), while running at 47.5% of the static-graph token cost and 66.7% of its wall-clock time. The cleanest internal numbers, though, are the coordination-quality ones. Concurrent writes dropped to 1.0× baseline against Leader-Worker's 8.5×. Overwrites fell 5.3× versus Leader-Worker and 8.2× versus the decentralized baseline. Wasted characters dropped from 45,436 to 5,236. Aggregate task time: 3.5 minutes vs MetaGPT's 11.5 minutes.
The headline number worth quoting prominently: LATTE matched or beat every baseline on accuracy while spending less than half the tokens of static graphs and roughly a fifth of MetaGPT's.
Why it matters#
If you have ever orchestrated sub-agents — Claude Code's Agent tool, a custom Plan/Explore split, parallel research workers, the kind of pipeline this very blog gets generated by — you have felt the failure mode this paper measures. Two agents both decide they own the same file. The leader gets a stale snapshot of the worker's progress and re-issues work. Decentralized teams chatter past each other and converge on something nobody asked for. None of those are reasoning failures. They are concurrency failures dressed up as reasoning failures, and the standard fix — write a more elaborate role prompt — does not address them at all.
The practical takeaway is that the coordination substrate matters more than the role structure. If I were designing a sub-agent system tomorrow, I would stop spending prompt budget describing who is the "PM agent" and who is the "QA agent" and instead spend it on a graph the agents can read and write. Concretely: a shared task list with dependency edges, explicit ownership per node, and a check-and-claim step before any agent does work. The numbers say activation goes from continuous to 48.7% of rounds when agents have a graph to consult — meaning more than half the time they correctly decide there is nothing for them to do, which is exactly the behavior you want and almost never get from a chatty fixed-role team.
The caveats#
The three benchmark tasks are well-scoped and short — average completion under four minutes. Long-horizon software engineering, where most agentic-coding pain actually lives, is not tested here.
"Library extension" only hit 40% accuracy even for LATTE. The advantage over baselines holds, but the absolute ceiling on harder coding-style tasks is still low.
The MetaGPT comparison is striking but slightly unfair as a like-for-like — MetaGPT's prescriptive waterfall was built for a different problem shape, and in a research setting the prompt and tooling overhead works against it.
Coordination overhead in graph maintenance is real; the paper does not deeply ablate the cost of the graph operations themselves at higher agent counts.
The takeaway#
What I am filing away: stop modeling multi-agent systems after teams of people, start modeling them after distributed systems with shared mutable state. The result you want — agents that mostly do nothing, and act decisively when they have a clear claim — falls out of the substrate, not the roleplay. The thing I am doing differently after reading this is shifting the next sub-agent harness I build away from leader/worker prompts and toward an explicit task graph the agents are required to consult and update before every action.