Multi-agent systems fail at the seams, not the model
The largest study of multi-agent failures found the model almost never causes them. The leverage is cheap plumbing at the seams.
Contents
When a multi-agent AI system breaks, the instinct is to blame the model. The largest study of these failures says that is almost never where it broke. The failure is in the connections: how the work is split, how agents hand off, and whether anyone checks the result. The seams, not the model.
#Where multi-agent systems actually break
The evidence comes from MAST, the Multi-Agent System Failure Taxonomy from a Berkeley-led team (arXiv:2503.13657). They annotated more than 1,600 execution traces across 7 popular multi-agent frameworks and clustered every failure into 14 modes across three categories. The split, read from their failure distribution, is the whole story:
- System design issues: roughly 44 percent
- Inter-agent misalignment: roughly 32 percent
- Task verification: roughly 24 percent
Model capability is not a category. The paper is explicit that it focuses on failures where "improvements in system design, agent coordination, and verification" are the lever, and it shows the same underlying model performing better inside a better-designed system. The bottleneck is the org chart, not the brain.
#Seam one: system design
Most failures start before the agents even run, in how the system was specified. In the MAST data, the biggest single modes here are step repetition (15.7 percent), not recognizing when the task is actually complete (12.4 percent), and simply disobeying the task specification (11.8 percent). These are not intelligence failures. They are missing an ownership map and a termination condition. When the study's authors improved agent role specifications alone, with the same model and prompt, ChatDev's success rate rose by 9.4 percent.
#Seam two: the handoff
The second cluster is coordination: agents proceeding on conflicting assumptions and dropping context between each other. The largest mode is a mismatch between an agent's reasoning and its action (13.2 percent), where what an agent decided and what it did diverge in a way the next agent cannot see.
Cognition, the team behind Devin, reached the same conclusion from the building side. Their rule: "Share context, and share full agent traces, not just individual messages." In their words, parallel subagents "cannot not see what the other was doing," so their work ends up inconsistent, built on conflicting decisions nobody wrote down. Their recommended default is a single-threaded linear agent, so the context stays continuous. This is the same seam MAST measures, described by people who ship it.
#Seam three: verification
The third cluster is the quietest and the most dangerous: nobody confirms the work is actually done. MAST breaks this into incorrect verification (9.1 percent) and no or incomplete verification (8.2 percent). A system with a verifier that only checks whether the code compiles will happily pass a program that is wrong. We have written about this failure on its own as the false finish: the confident report of completion with nothing behind it. When the MAST team added one real, high-level verification step to ChatDev, task success rose 15.6 percent.
#The wrong fix is more agents
The loud instinct after reading all this is to add coordination machinery: more agents, more roles, a richer topology. The data points the other way. Anthropic's guidance for building agents is to "add complexity only when it demonstrably improves outcomes" and to start with the simplest solution. Cognition is blunter, defaulting to a single linear agent and warning that multi-agent collaboration mostly yields fragile systems today. The 50-agent org for a 2-person company is not sophistication. It is more seams to leak at.
#The smallest set of connections that holds
You do not need a bigger model or a bigger topology. You need five cheap things at the seams: one ownership map so every task has an owner, clean handoffs that carry the full context and not a summary, a shared trace so agents are not guessing at each other's decisions, an explicit termination condition, and one real verifier on the output. That is the operations work that turns a demo of cooperating agents into a system you can put in front of a customer. The model was never the problem. The plumbing was.
Keep reading
- · 8 min
An agent that watches your agent: a drift tripwire, not a security guard
Claude Code has an undocumented observer agent that watches a worker in real time. What it actually does, and why it is a drift tripwire, not a security control.
- · 6 min
AI Agents That Improve Themselves: What the Evidence Actually Supports
A viral paper says self-evolving agents are blocked by missing infrastructure, not algorithms. We verified it, then checked 40 years of self-improving systems. One rule survives.
- · 5 min
Claude Fable 5 Moves to Usage Credits Tomorrow. Here Is the Part That Actually Matters to Builders.
The internet is full of leaked-prompt threads and architecture guesses about Anthropic's most capable model. Almost none of it is verifiable. The part a builder can actually use is four small API changes and one behavior worth watching, plus a working skill that handles all of them.