Skip to content

AI, decoded

Why do multi-agent systems fail, and how do you make them reliable?

Multi-agent systems fail in the gaps between agents, not inside any one of them. Small per-agent errors compound: a handoff drops context, one agent's wrong output becomes another's trusted input, and a minor fault cascades into a systemic failure no single agent would have produced alone. You make them reliable by treating the system as the unit — tracing every step, validating what passes between agents, setting guardrails on autonomy, and threat-modeling how faults propagate before they reach production. Lyzr CEO Siva Surendira told Chain of Thought that a feedback and conflict-resolution loop between agents ran up $300 in LLM calls without fixing the problem before Lyzr stopped it.

· Updated · Chain of Thought

Level 5: Production agents · 5.1 Multi-agent systems

Multi-Agent SystemsAI Evaluation & ReliabilityAI Security

  • 5 episodes
  • 4 guest clips
  • 8 glossary terms
Three agents in a chain, A to B to C, with a fault that grows at each handoff and ends in a failure of the whole system: multi-agent systems break in the handoffs.

In detail

Failure lives between the agents

Each agent in a system can work in isolation and the system can still fail, because the weak points are the connections. An agent hands off with missing context. One agent’s hallucination becomes the next agent’s input, which it treats as fact. A small error early in a chain gets amplified at every downstream step. The failure is emergent — it belongs to the system, not to any one component.

Researchers at UC Berkeley put numbers on this in Why Do Multi-Agent LLM Systems Fail?. They start from the observation that multi-agent systems often post only minimal gains over single agents on popular benchmarks, then annotate more than 1,600 execution traces from seven popular frameworks. The resulting taxonomy has 14 failure modes in three groups: problems in how the system is designed, misalignment between agents, and weak verification of the task’s result.

Cascading and systemic risk

Because outputs feed inputs, multi-agent systems turn small faults into large ones. A single mislabeled result, a tool that returns stale data, a compromised agent — any of these can propagate through the whole network. The same property makes them a security surface: an attacker who influences one agent can steer the others. Reliability and security are the same problem viewed from two sides.

Cost compounds too

The gaps cost money as well as accuracy. Anthropic reported that in its own data, agents use about 4 times as many tokens as chat interactions and multi-agent systems about 15 times as many, so they pay off only on tasks valuable enough to cover that. The same post notes that work where every agent needs the same context, or where agents depend heavily on each other, fits multiple agents poorly. A loop between agents that never converges, like the one Lyzr stopped at $300, is the expensive version of that mismatch.

Making them reliable

Treat the system as the unit of analysis. Trace every step so you can see where a failure entered and how it spread; what is AI observability covers what to record. Validate what passes between agents instead of trusting it. Put guardrails on how much autonomy each agent has. And threat-model the cascade paths in advance — ask how a fault in agent A reaches the user — so you catch systemic failures in design rather than in production.

Why multi-agent systems fail: the fault grows between the agents Top row, unchecked: agent A hands off to agent B, B to C, and C to the user. A small fault grows at every handoff: the handoff drops context, a wrong output becomes trusted input, and the fault is amplified until the user sees a systemic failure. Bottom row, treated as one system: each agent has guardrails on its autonomy, what passes between agents is validated, and every step is traced, so a fault can be caught between agents instead of passing on as trusted input. The design question: how does a fault in agent A reach the user? The failure lives between the agents Each agent can work alone and the system can still fail. Make the system the unit. UNCHECKED · THE FAULT GROWS AT EVERY HANDOFF agent A agent B agent C systemic failure handoff dropscontext wrong output becomestrusted input amplified at everydownstream step TREATED AS ONE SYSTEM · CHECKED BETWEEN AGENTS agent A agent B agent C the user validate what passes between agents guardrails on each agent’s autonomy trace every step Ask how a fault in agent A reaches the user, in design, not in production. The same cascade is a security surface: an attacker who influences one agent can steer the others. MongoDB’s Mikiko Chandrasekhar, ep 33: without observation, evaluation and guardrails, the agentic system won’t survive.
Multi-agent failures are emergent: they belong to the handoffs, so the system, not any one agent, is the unit you trace, validate and threat-model. Download the image

Hear it from the guest

“If you don't have a way of observing what these agents are doing, if you don't have a way of evaluating them, and if you don't have a way of putting guardrails around their behavior, you just don't have an agentic system that's gonna really survive.”
Mikiko Chandrasekhar, MongoDB EP 33 · around 0:00 · read the transcript
“Make sure that you have criteria for how to evaluate the performance of those agents. And then you look at that team or that coalition or what have you holistically.”
“You won't believe such loop cost us $300 Just the amount of LLM calls it had to take and it had to complete the whole loop. Did it still fix? Answer is no.”
“No one's gonna go trace by trace by trace and try to look for where things are going wrong. It's just not gonna happen.”

Quotes lightly edited to remove filler words.

Go deeper

From the conversation

This explainer is drawn from these episodes — each carries its full transcript.

Concepts in this explainer

Multi-agent systemAgent SwarmOrchestrator AgentSubagentLarge Language ModelAccuracyAI HallucinationAI Observability