The pitch for multi-agent AI systems is compelling: instead of one AI model doing everything, you build a team. One agent plans. One executes. One verifies. Together, they should be smarter than any single model.
In practice, they fail constantly — and often in ways that are hard to predict or debug.
A 2025 paper from researchers at UC Berkeley, UIUC, Stanford, and Carnegie Mellon studied this directly. They analyzed five popular multi-agent frameworks across more than 150 tasks, with six expert human annotators reviewing what went wrong. What they found was not encouraging for the field.
The benchmark gap nobody talks about
Multi-agent systems consistently underperform their marketing. The researchers found that performance gains across popular benchmarks are “minimal compared to single-agent frameworks.”
You're adding infrastructure, cost, latency, and complexity — and in many cases not getting meaningfully better results than you would from one well-prompted model.
Why? The paper identified 14 distinct failure modes, organized into three categories.
Category 1: Specification and design failures
These are the failures that happen before the agents even start talking to each other — flaws in how the system was set up.
Agents disobey their role specification. You tell Agent A to only write code and Agent B to only review it. Under certain conditions, Agent A starts reviewing too. Or ignores its constraints entirely. Role adherence is fragile.
Step repetition. An agent keeps attempting the same action that already failed, without any mechanism to recognize it's stuck in a loop. This is more common than you'd think.
Loss of conversation history. As conversations grow longer, agents lose access to earlier context. Decisions made in step 3 get forgotten by step 30. The model's context window fills up and critical information falls out.
Unaware of stopping conditions. The agent doesn't know when it's done. It keeps running, generating cost and latency, because the system never gave it a clear signal to stop.
Category 2: Inter-agent misalignment
These are failures that happen between agents — coordination breaking down.
Task derailment. The conversation between agents drifts from the original goal. One agent introduces a subtask, another follows it, and by the time anyone checks, the system is solving a completely different problem than you started with.
Fail to ask for clarification. An agent encounters an ambiguous instruction and just picks an interpretation and runs with it, rather than asking the other agents (or the user) to clarify. This compounds quickly.
Information withholding. One agent has information that another agent needs, but doesn't pass it along. Not intentionally — just an artifact of how the agents were designed to communicate.
Reasoning-action mismatch. The agent reasons through a problem correctly, then does something that contradicts its own reasoning. The thinking and the action are disconnected.
Ignored other agent's input. Agent B gives Agent A feedback. Agent A acknowledges it but doesn't actually incorporate it. The loop exists on paper but doesn't do what you think it does.
Category 3: Task verification and termination failures
These are failures in the endgame — checking whether the work was actually done correctly.
No or incomplete verification. The verifier agent signs off on work that hasn't been properly checked. This is the most common failure mode in the paper — verification is hard to get right and easy to shortcut.
Incorrect verification. The verifier checks the wrong thing. The code passes the tests, but the tests don't actually validate what matters.
Premature termination. The system concludes it's done before it actually is. One agent says the task is complete, another agrees, and the system exits — leaving the job half-finished.
The uncomfortable conclusion
The researchers found that simply improving the base models won't fix these problems. They tested improved role specifications and better orchestration strategies — both helped, but neither eliminated the failure modes.
Most of these failures are system design problems, not model capability problems. You can use the best model in the world and still build a multi-agent system that loops forever, forgets its goal, or confidently signs off on broken work.
What this means practically
Multi-agent systems are genuinely useful for certain kinds of problems — especially long-horizon tasks where parallelism helps, or where you have distinct, well-defined roles that rarely overlap. But they require careful design and robust failure detection, not just wiring models together and hoping for coordination to emerge.
If you're building with multi-agent frameworks today, the failure modes above are your checklist. Every one of them has a corresponding design decision: how do you detect loops? How do you enforce context retention? How do you verify that verification is actually happening?
The paper's conclusion is blunt: these systems “require more sophisticated solutions” than what's currently being shipped. More capability in the base models is necessary but not sufficient. The coordination layer is where the real work is.