Picture an owner with one AI agent that reads supplier invoices. It works well enough that the next proposal is a team: a second agent to check the first, a third to chase missing purchase orders, a fourth to write the weekly summary. A UC Berkeley team that read 1,642 execution traces from seven multi-agent systems found something else. Those systems failed between 41% and 86.7% of the time, and most failures were not the model getting a fact wrong. They were an agent repeating a step, acting against its own plan, not knowing when to stop, or ignoring the task it was given; in about a quarter of cases, nobody checked the result.[1] Two 2026 studies put a price on it: more agents mean more tokens, and at an equal thinking budget one agent usually does as well.
What the Berkeley team measured.
A multi-agent system, in the paper's sense, is a program where several AI agents with separate roles pass work between each other to finish a task: a coder and a tester, a planner and a solver, a supervisor and a phone agent. The study took seven open-source frameworks of that kind (ChatDev, MetaGPT, HyperAgent, AppWorld, AG2's MathChat, Magentic-One and OpenManus), ran them on the tasks each was built for, and kept the full record of every run, which the paper calls a trace: every message, tool call and decision, start to finish. The frameworks ran mostly on "two main model families (GPT-4 series and Claude series)".[1]
The tasks were the frameworks' own benchmarks: writing small programs, fixing real GitHub issues, grade-school and olympiad math, general knowledge questions, assistant tasks that need the web, and tasks inside simulated apps. Across them, the authors report "41% to 86.7% failure rate on 7 state-of-the-art (SOTA) open-source MAS".[1] The figure per system is in a chart we could not read as text, and the paper warns that the systems ran on different benchmarks, so the rates are not a league table. The point is the floor: the best of seven failed four tasks in ten.
The method is what makes the study worth an operator's time. Six expert annotators read 150 traces from five of the frameworks line by line, with no prior checklist, and built the failure categories from what they saw. Three then independently labelled a 15-trace subset and agreed at a Cohen's kappa of 0.88, which is high. The result is MAST, the Multi-Agent System Failure Taxonomy: 14 failure modes in three categories. To scale past 150, the team built an automated annotator on OpenAI's o1 model with worked examples; it agreed with the humans at a kappa of 0.77, and 0.79 on two unseen systems, and labelled the full 1,642.[1]
The 14 ways the systems failed.
Fig 1 lays out the taxonomy with each mode's share of all failures observed. The three categories are the paper's. The category totals are our sums of its per-mode percentages.
Read the top five, about two thirds of what went wrong (our sum: 62.2%). Step repetition is an agent doing the same thing again because nothing told it the step was done. Unaware of termination conditions is the same fault at the end: the system does not know it has finished, or that it should give up. Disobey task specification is an agent solving a neighbouring task instead of the one it was given. Reasoning-action mismatch is an agent that writes out the right plan and then does something else. Incorrect verification is a checker that approves a wrong answer. None of these is the model not knowing the answer. The authors say so: "MAS failure is not merely a function of challenges in the underlying model".[1]
The two vendor essays describe the same faults from the inside. Cognition's example is a Flappy Bird clone split between two subagents; the first "actually mistook your subtask and started building a background that looks like Super Mario Bros.", and a final agent must merge two things that do not fit.[6] In MAST terms, a disobeyed task specification and then a verification problem. The essay's second principle, "Actions carry implicit decisions, and conflicting decisions carry bad results", is inter-agent misalignment in plain language. Anthropic, which shipped a multi-agent system, reports the orchestrator side: with vague instructions, "one subagent explored the 2021 automotive chip crisis while 2 others duplicated work".[5]
For the owner with the invoice reader, a second agent is a second place where the brief can be misread, a second loop that can run without a stop rule, and a handoff where the first agent's decision gets lost. The taxonomy is the list of places to check.
What the fixes were worth.
The team then tried to fix two of the systems. On each they tested two kinds of change: better prompts (clearer role descriptions, an explicit verification section) and a change of topology, meaning who talks to whom and who may end the job.[1]
| system · task | baseline | improved prompts | new topology |
|---|---|---|---|
| AG2 MathChat · GSM-Plus, GPT-4 | 84.75 | 89.75 | 85.50 (not significant, p = 0.4) |
| AG2 MathChat · GSM-Plus, GPT-4o | 84.25 | 89.00 | 88.83 (p = 0.03 for both changes) |
| ChatDev · ProgramDev-v0, 32 tasks | 25.0 | 34.4 | 40.6 |
| ChatDev · HumanEval | 89.6 | 90.3 | 91.5 |
The AG2 figures are accuracy in percent over 200 problems, averaged across six repetitions; the ChatDev figures are accuracy in percent with no repetitions reported.[1] Three things stand out. The AG2 topology gave three roles, a problem solver, a coder and a verifier, where "only the Verifier can terminate the conversation": a stop rule, owned by the checker. For ChatDev, a one-way pipeline became a loop with a maximum number of iterations, so a failed check could send work back instead of shipping it. The authors conclude that "topology-based changes are more effective than prompt-based changes for both systems", with the caveat that the GPT-4 gain was not significant. And the largest improvement, 15.6 points on ChatDev's own program set, still leaves that system failing about six tasks in ten: the interventions "do not constitute substantial improvements" and "task completion rates still remain low".[1]
Note what stayed flat: HumanEval, the standard coding test, moved from 89.6 to 91.5. On a task the model already does well, the architecture around it barely matters.
Count the tokens before the agents.
The Berkeley paper says where multi-agent systems break, not what they cost or whether one good agent would have done the job. Three other sources do, with different methods and different conflicts of interest.
The Google and MIT configurations. "Towards a Science of Scaling Agent Systems", a preprint from Google Research, Google DeepMind and MIT, ran 260 configurations across six benchmarks (web research, entry-level financial analysis, planning inside Minecraft, a 16-tool business workflow, real GitHub issues and command-line tasks), five architectures and nine models from the GPT-5, Gemini and Claude Sonnet families.[3] The architectures: a single agent; independent agents that work alone and get merged; a centralized system where three sub-agents report to one orchestrator; a decentralized system where three agents debate; and a hybrid of the last two. The coordination overhead per architecture is in fig 2.
The quality result cuts both ways. Against the single agent, the centralized system gained 80.8% on the financial-analysis tasks ("mean 0.631 vs. SAS 0.349"), while independent agents lost 70.0% on the Minecraft planning tasks, which are sequential: each step depends on the last. Web research gained up to 9.2% with debate.[3] The authors' most useful sentence for a buyer is a threshold: "tasks where single-agent performance already exceeds 45% accuracy experience negative returns from additional agents". The better the one agent already is, the less a team adds, and the more it costs. Their limitations add that "the communication overhead we measured grows superlinearly with agent count".
The Stanford equal-budget test. Dat Tran and Douwe Kiela asked a narrower question: if a single agent and a team get the same number of thinking tokens, who wins?[4] They ran five team designs (sequential, parallel subtasks, parallel roles, debate and ensemble) on two multi-hop question sets, with Qwen3, a DeepSeek distillation and Gemini 2.5, at budgets from 100 to 10,000 tokens. Fig 3 shows the averages.
Their summary: "SAS consistently match or outperform MAS on multi-hop reasoning tasks when reasoning tokens are held constant", and the gains others have reported "are better explained by unaccounted computation and context effects rather than inherent architectural benefits".[4] They name the exception: teams become competitive "when a single agent's effective context utilization is degraded, or when more compute is expended". A second agent earns its place when the first one's working memory is full, or when you will pay for more thinking and want it in parallel.
The vendor that shipped one. Anthropic's engineering post describes its research feature, a lead agent that spawns subagents to search in parallel. On the company's internal evaluation, Claude Opus 4 leading Claude Sonnet 4 subagents "outperformed single-agent Claude Opus 4 by 90.2%".[5] A vendor's number on a vendor's test, and the same post supplies the condition. On the BrowseComp benchmark, "token usage by itself explains 80% of the variance" in performance; agents "typically use about 4× more tokens than chat interactions" and "multi-agent systems use about 15× more tokens than chats". The authors draw the line: "For economic viability, multi-agent systems require tasks where the value of the task is high enough" to pay for it. They name what does not fit: "some domains that require all agents to share the same context", and "most coding tasks involve fewer truly parallelizable tasks than research". Cognition, whose product is a single coding agent, lands in the same place: "it is evident that in 2025, running multiple agents in collaboration only results in fragile systems", because "The decision-making ends up being too dispersed and context isn't able to be shared thoroughly enough between the agents."[6]
Read the numbers carefully.
The failure rates describe research frameworks on 2024-era models. The seven systems are open-source projects run on GPT-4-series, Claude 3.7 Sonnet, Qwen2.5-Coder and CodeLlama models (the paper says "two main model families" in one place and four in another), each on its own benchmark; a commercial product on a current model may fail less. The taxonomy is the part that transfers, and even there the authors say "we do not claim it covers every potential failure pattern".[1] Most of the 1,642 labels came from the o1-based annotator at a kappa of 0.77 against humans: good agreement, not human agreement. The category totals in fig 1 are our sums, and a trace can carry several failures.
The overhead study counts turns, and its budget statements do not reconcile. Kim et al.'s 58% to 515% is coordination overhead computed from turn counts (Table 5: 7.2 turns for one agent, 44.3 for the hybrid). The paper reads that as "1.6–6.2× token budgets relative to single-agent at matched performance", while the same table's caption says every system was matched to a mean of 4,800 reasoning tokens per trial. We could not reconcile the two from the text, so treat the token multiple as the authors' approximation.[3] Their task-complexity score is "calibrated against observed MAS performance patterns across all configurations", so it partly reads the answer back into the predictor. Default teams were three agents (the scaling runs went to nine), prompts were not tuned per model, and the model fit is R² = 0.373, or 0.413 with their task-grounded capability metric: a real pattern, modest precision. One figure, a 0.21 success rate for the hybrid on the business workflow, did not reconcile with another section's figure for the same case, so we left it out.
The equal-budget test is narrow by design. Text-only questions, no tools, no writing actions, and the models were not forced to spend their budget ("We do not enforce the models to actually use up all of those budgets").[4] The authors report "significant artifacts in API-based budget control (particularly in Gemini 2.5)" that can inflate a team's apparent gains. It says nothing about parallel web research or multi-step business tasks.
The vendor numbers are vendor numbers. Anthropic's 90.2% is an internal eval with no public task list, and the post's own analysis attributes most research performance to tokens spent. Cognition's essay is a design argument with a constructed example, from a company whose product is the alternative.
Which jobs earn a second agent.
Put the sources together and a rule of thumb falls out. It is our reading; the table says which source each row leans on.
| shape of the job | one agent or several | why, and who says so |
|---|---|---|
| parallel reads: 30 suppliers, 12 quotes, facts from many pages | several, read-only, merged by one | Anthropic's gain; Kim et al.'s +80.8% on decomposable analysis.[3][5] |
| more material than one context window holds | several, by necessity | Anthropic: "information that exceeds single context windows"; Tran and Kiela: teams compete when one agent's context is degraded.[4][5] |
| sequential steps, each depending on the last | one | Kim et al.'s −70.0% was sequential planning with independent agents.[3] A handoff mid-chain loses history (FM-1.4).[1] |
| shared context: one codebase, one document, one customer thread | one | Anthropic: "not a good fit"; Cognition: "Share context, and share full agent traces, not just individual messages".[5][6] |
| write actions: posting an invoice, sending a reply, changing a record | one, checked by a non-author | Our reading of MAST's verification category (23.5%) and Cognition's "Actions carry implicit decisions".[1][6] |
| a task the single agent already passes most of the time | one | Kim et al.: negative returns past 45%; ChatDev's HumanEval barely moved under any fix.[1][3] |
For the invoice reader: the research subagents (chase purchase orders across supplier portals, find the matching delivery notes) fit, because they read in parallel and hand back facts. Posting the invoice stays with one agent, checked by something that did not do the posting. The weekly summary is a report, not a team member: one agent reading the week's log.
What to do on Monday.
These steps are ours, not the authors' advice. They assume you already run one agent on something real, as our note on build order recommends.
- Measure the one agent before you add a second.
Run it on 30 real cases and record how often it gets the task right and how many tokens it spends per case. If it already passes most of the time, the Google and MIT threshold says a team is more likely to cost than to help.[3] If it fails often, look for the failures in fig 1 first: a stop rule is cheaper than an orchestrator.
→ a baseline, in accuracy and in tokens - Write the stop rule and the brief, for every agent.
Four of the five largest failure modes are an agent not following its brief, its own plan, or a stop rule (15.7%, 13.2%, 12.4% and 11.8% in fig 1).[1] Each agent gets a written task, a definition of done, and a maximum number of steps. A one-sentence brief barely moves an agent; a spec does. Decide up front what it may ask rather than guess: failing to ask is another 6.8%.
→ FM-1.1, 1.3, 1.5, 2.2 and 2.6 addressed before any topology - Give the checker the right to say "done", and make it someone else.
The Berkeley team's best intervention was a verifier that alone could end the job, and a loop with a cutoff that sends failed work back.[1] Verification faults were 23.5% of what they saw. The checker is not the agent that did the work, and it checks the artifact: two attempts agreeing is not a check.
→ the task-verification category covered: incorrect, missing and premature verification (FM-3.1 to 3.3) - Price the second agent before you build it.
Use the measured range: +58% coordination overhead for independent agents, +263% to +285% for debate or an orchestrator, +515% for a hybrid (turn counts, which the authors read as 1.6 to 6.2 times the tokens), about 15 times a chat for a full research system.[3][5] Multiply your per-case token cost by that and by monthly volume, and write the number next to the gain you expect. The effort setting on the single agent is usually the cheaper lever.
→ a budget line, not a diagram - Split by reads, never by writes.
Subagents get read-only, parallel, independent lookups and hand back facts with sources. One agent holds the shared context and performs every write. If the job is a chain, keep it one agent with the whole history, not a summary: Cognition's first principle and Tran and Kiela's context argument agree.[4][6]
→ no conflicting decisions to merge, no lost history - Keep every trace and label the failures.
MAST exists because someone kept 1,642 full traces and read them.[1] Anthropic says full production tracing let it "diagnose why agents failed and fix issues systematically".[5] Log every run end to end; when one fails, label it with one of the 14 modes. After a month you will know whether your problem is a brief, a stop rule or a checker, or an agent repeating itself.
→ a failure log you can act on, in the paper's vocabulary
What this note does not claim.
It does not claim multi-agent systems do not work. Anthropic ships one; Kim et al. found +80.8% on one benchmark. The claim is narrower: on the systems studied, most failures were design faults with names, the fixes tried were worth 5 to 15 points, and the token bill is large and often unaccounted for.
It does not claim the failure rates apply to your system. They are rates for seven research frameworks on 2024-era models, each on its own benchmark, not directly comparable even with each other.[1]
It does not claim one agent always wins at equal budget. The Stanford result covers text-only multi-hop questions; at 100 tokens the teams were ahead.[4] Nobody in these sources ran a matched-budget test on tool-heavy business tasks.
It does not claim the numbers are independently reproduced. One peer-reviewed paper, two preprints, two vendor posts; the 45% threshold, the overhead percentages and the 90.2% are each one group's runs. And the reads-and-writes rule is ours: the parallel-reads half is in the sources; "writes stay with one agent, checked by another" is our inference from the verification category and Cognition's principle.
If someone has drawn you a multi-agent diagram and you want to know which boxes should be one box, send it with a sentence on the task (no credentials or customer data) through the contact form. We will write back, free, with the split we would make and the token range to budget. Agent workflows with a baseline, a checker and a budget line are part of our workflow automation services.