What Actually Breaks in Multi-Agent Handoffs

A single agent that does good work is not the same thing as a chain of agents that does good work. The failures I keep seeing in production are not failures of any individual model — they live in the seams, in the moment one agent hands its output to the next. Multi-agent handoffs break in predictable, repeatable ways, and the same discipline that catches what actually fails in production for AI-generated code applies here. The demo works because one agent held the whole problem in its head. The system fails because no agent does.

The Four Failure Modes

Lost context. Every handoff is a lossy boundary. The first agent reasons over the full problem — the intent, the constraints, the edge cases it decided not to touch. What it passes forward is a compressed summary. The receiving agent does not inherit the reasoning; it inherits the residue. Constraints that were obvious to the first agent are invisible to the second, so it makes locally reasonable decisions that violate the original intent. Nobody wrote a bug. The context simply evaporated at the seam.

Silent error propagation. A single agent will sometimes catch its own mistake mid-reasoning. A downstream agent will not, because it treats upstream output as settled fact. An error introduced at stage one is not questioned at stage two — it is built upon. By stage four it is load-bearing. This is the same dynamic as traditional code review missing the semantic gaps in AI-generated code: the output looks structurally correct, so it passes inspection and the flaw hides beneath a surface of apparent competence.

No shared source of truth. Most agent chains pass messages, not state. Each agent holds its own partial view, and there is no canonical record that all of them read from and write to. When two agents disagree about a fact — a schema, a price, a status — there is no authority to resolve it. The system does not fail loudly; it produces confidently inconsistent output, because each agent is internally coherent and the incoherence only exists between them.

Compounding hallucination. A model that hallucinates a plausible API, a plausible field name, or a plausible fact once is a manageable problem. A chain that hallucinates and then reasons over the hallucination as if it were real is not. Each stage adds a layer of confident invention on top of the last, and because the surface remains fluent and well-formed, the compounding is invisible until the whole output collapses on contact with reality.

Verify at the Boundary, Not Inside the Chain

The instinct is to fix this by improving the agents. Better models produce fewer errors, and that helps — but it does not remove the structural problem, because the failures live at the seams, not inside any one agent. The agents cannot police each other, because policing requires questioning input the receiving agent is built to trust. The mitigation has to be external to the chain: a verification gate between stages that checks each output against a ground-truth reference before the next agent consumes it. Give the chain a shared source of truth that every agent reads from and writes to, so state is canonical rather than passed hand to hand. And treat every handoff as a place where context is lost by default, and pass forward the constraints explicitly rather than trusting them to survive the summary.

This is the same lesson as the self-scan: AI writes fast, so you check it fast, at machine speed, at the boundary — you do not trust that it looks right. A chain of agents is a chain of boundaries, and each one needs a gate. Chapter 7 of The AI Agent Economy lays out why traditional review fails on machine-generated output and why the answer is automated verification designed for the specific error profile of AI systems — the same argument, applied to the seams between agents rather than the code inside one. The agents are not the risk. The handoffs are.