180 experiments across 5 architectures reveal that adding agents degrades performance by up to 70% on sequential tasks. The 45% threshold rule every agent builder needs to know.
There's a prevailing assumption in the AI agent ecosystem right now: if one agent is good, multiple agents must be better. More agents means more reasoning power. More specialization. More parallelism. Better results.
Google DeepMind and MIT just tested that assumption rigorously — 180 configurations, 5 architectures, 3 model families, 4 benchmarks — and the results should make every agent builder reconsider their architecture.
The headline finding: multi-agent systems improved performance by 81% on parallelizable tasks but degraded it by up to 70% on sequential ones. Adding agents didn't just fail to help — it actively made things worse.
This isn't a theoretical argument. It's the most comprehensive empirical study of agent scaling published to date, and it comes with a practical decision framework that tells you exactly when to add agents and when to stop.
What Did Google and MIT Actually Test?
The paper — "Towards a Science of Scaling Agent Systems" — evaluated five canonical multi-agent architectures across 180 total configurations. The five architectures were:
| Architecture | How It Works | Best For |
|---|---|---|
| Single-Agent (SAS) | One agent, sequential execution, unified memory | Sequential tasks, tool-light workloads |
| Independent | Parallel sub-tasks, no inter-agent communication | Simple parallelizable tasks |
| Centralized | Hub-and-spoke: orchestrator delegates and synthesizes | Complex parallelizable tasks |
| Decentralized | Peer-to-peer mesh, direct agent communication | Exploration tasks with partial observability |
| Hybrid | Hierarchical oversight + flexible peer coordination | Mixed workloads (in theory) |
Each architecture was tested with models from OpenAI, Google, and Anthropic across four domains: financial analysis, web navigation, game planning (Minecraft's crafting system), and business automation. Prompts, tools, and token budgets were held constant — only the coordination structure and model capabilities varied.
This matters because most multi-agent comparisons in the wild are apples-to-oranges. Different prompts, different tools, different budgets. This study isolated the variable that actually matters: how agents coordinate.
Why Do Multi-Agent Systems Fail on Sequential Tasks?
Multi-agent coordination degrades sequential task performance because splitting context across agents destroys the state continuity that sequential reasoning requires. On PlanCraft (a Minecraft crafting benchmark where each action changes inventory state), every multi-agent variant performed worse than a single agent:
- Independent agents: -70.0% (worst)
- Centralized: -50.4%
- Decentralized: -41.4%
- Hybrid: -39.0% (least bad, still terrible)
The root cause is what the researchers call "information fragmentation." When a single agent executes step 3 of a 10-step plan, it has the full context of steps 1 and 2 in its working memory. Split that across three agents, and each one is working with compressed summaries of what the others did — lossy translations of state that compound errors at every handoff.
The numbers tell the story: independent systems amplified errors 17.2x, while centralized architectures contained it to 4.4x. Architecture isn't just a design preference — it's a safety mechanism.
When Does Adding Agents Actually Help?
Multi-agent systems shine when the task naturally decomposes into independent subtasks that can run in parallel. On Finance-Agent (where agents simultaneously analyzed revenue trends, cost structures, and market comparisons), centralized coordination delivered an 80.9% improvement over single-agent performance. Decentralized scored +74.5%, hybrid +73.2%.
The key insight is the 45% threshold — a statistically significant finding (β = -0.408, p < 0.001) that creates a clean decision rule:
- Single-agent accuracy below 45%: The task is hard enough that coordination benefits can outweigh costs. Consider multi-agent.
- Single-agent accuracy above 45%: Coordination overhead will likely hurt more than help. Stay single-agent.
Think of it as the "baseline paradox." If your single agent already solves the task nearly half the time, adding more agents introduces coordination costs that eat into the remaining margin faster than they close it.
How Much Does Multi-Agent Coordination Actually Cost?
The token efficiency numbers are stark. Single agents achieve 67.7 successes per 1,000 tokens. Hybrid systems achieve 13.6 — roughly 5x less efficient.
| Architecture | Successes per 1,000 Tokens |
|---|---|
| Single-Agent | 67.7 |
| Independent | 42.4 |
| Decentralized | 23.9 |
| Centralized | 21.5 |
| Hybrid | 13.6 |
Hybrid systems require approximately 6x more reasoning turns than single agents. And the coordination overhead isn't linear — it ranges from 58% to 515% depending on the architecture and task complexity. Once you cross 3-4 agents under constrained token budgets, communication overhead dominates the token allocation, leaving each agent with insufficient capacity for actual reasoning.
This maps directly to what framework users observe in practice. LangGraph consumes roughly 2,000 tokens for a research-and-summarize task; CrewAI uses 3,500; AutoGen burns through 8,000 — a 4x spread for the same outcome. The coordination tax is real, measurable, and often invisible until you're looking at your API bill.
What Does This Mean for Production Agent Systems?
The paper's practical recommendation is refreshingly blunt: "Start with a single agent. Only switch to multi-agent systems when the task splits into independent pieces AND single-agent success stays below 45%."
Here's the decision framework distilled:
- Can a single agent handle it? If yes, stop. You're done.
- Is single-agent accuracy below 45%? If not, stay single-agent.
- Does the task decompose into independent subtasks? If not, stay single-agent. Sequential dependencies kill multi-agent performance.
- Do you have the token budget? Cap at 3-4 agents maximum. Beyond that, communication costs dominate.
- Which architecture? Parallelizable → centralized. Exploration → decentralized. Mixed → hybrid (but accept the 5x token cost).
This aligns with what practitioners are discovering independently. A Hacker News commenter who built a multi-agent system called Clink put it succinctly: "You can't just throw more agents at a problem and expect it to get better." The 17.2x error amplification finding was, in their words, "wild."
Enterprise data tells the same story from a different angle: 40% of agentic AI projects are forecast to be canceled by 2027. Multi-agent pilots fail within 6 months at a 40% rate. Expected productivity gains of 30-50% typically land at 10-15% — and "orchestration gaps" are the most cited reason.
Does This Research Have Limitations?
Yes, and they're worth noting. The most significant: the study used a fixed token budget of 4,800 tokens per configuration. Several critics on Hacker News pointed out that real-world deployments often use 50,000+ tokens, and coordination overhead might become proportionally smaller at larger budgets.
The researchers partially addressed this with an out-of-sample validation on GPT-5.2 (a model released after the study), achieving a mean absolute error of just 0.071 and confirming that 4 of 5 scaling principles generalized. But the token budget critique has merit — larger budgets might shift the 45% threshold or reduce the severity of sequential task degradation.
There's also the question of task selection. Four benchmarks, while more than most studies, can't capture every production scenario. The principles likely hold directionally, but the specific numbers (45%, 70% degradation, 17.2x amplification) should be treated as strong indicators, not universal constants.
Key Takeaways
- Multi-agent systems are not universally better. They improve parallelizable tasks by up to 81% but degrade sequential tasks by up to 70%. Architecture selection is task-dependent, not a one-size-fits-all decision.
- The 45% rule is your decision boundary. If a single agent already exceeds 45% accuracy on your task, adding agents will likely hurt. The coordination overhead outweighs the marginal improvement.
- Token costs scale non-linearly. Single agents are 5x more token-efficient than hybrid architectures. Cap multi-agent systems at 3-4 agents under constrained budgets — beyond that, communication overhead dominates.
- Architecture is a safety mechanism. Centralized systems contain error amplification to 4.4x; independent systems amplify errors 17.2x. If your task has high stakes, centralized coordination is worth the overhead.
- Start simple, scale only when proven necessary. The most expensive architecture decision isn't choosing the wrong framework — it's adding complexity before proving you need it.
The Bottom Line
The AI agent ecosystem has been chasing a "more is better" narrative that the data doesn't support. Google and MIT's research provides the first rigorous, quantitative framework for knowing when multi-agent systems help and when they actively hurt.
The irony is that the answer is remarkably simple. Most tasks don't need multiple agents. The ones that do need the right architecture, not just more agents. And the difference between getting that choice right and getting it wrong isn't a 5% improvement — it's the difference between an 81% boost and a 70% degradation.
Before you add that second agent to your pipeline, run a single-agent baseline. If it clears 45%, you probably just found your production architecture.
AI Agent Digest cuts through the noise in AI agent systems. Real analysis, real code, real opinions.
Top comments (0)