Skip to content
Agent Engineering Lab

FIELD NOTE · FN-001

The multi-agent papers nobody is citing

Three studies published since March 2025 put multi-agent failure rates between 41 and 86.7 percent, and error amplification up to 17.2x for agents that never check each other's work. The vendor decks have not caught up.

the paper nobody cites is the one holding up the roof
the paper nobody cites is the one holding up the roof

The pitch for multi-agent through 2024 and most of 2025 was simple: more agents, more capability. The pitch in 2026 should be different, because the data are in, and the data are not friendly to free-form coordination.

Three papers and one practitioner essay set the new floor. None of them killed multi-agent. All of them killed the version of multi-agent that ships well as a demo and badly as a production system.

The papers

MAST (Cemri, Pan, Yang et al., March 2025) is the first proper taxonomy of multi-agent failure modes. The authors measured seven open-source frameworks on standard benchmarks and reported failure rates between 41 and 86.7 percent. They cluster the failures into three buckets: system design issues, inter-agent misalignment, and task verification gaps. System design issues are the largest at 44.2 percent, inter-agent misalignment is second at 32.4 percent, and task verification accounts for the remaining 23.5 percent. The rates are not directly comparable across systems, because the frameworks were evaluated on different benchmarks. The taxonomy is the most useful thing in the paper. The failure rates are the headline. [1]

Towards a Science of Scaling Agent Systems (arXiv:2512.08296, December 2025) compares five architectures across 180 configurations and three model families. Independent agents, which produce output without checking one another, amplified errors by 17.2x. Centralized coordination contained the same effect to 4.4x. The figure is a trace-level amplification factor estimated from execution traces, so it measures the extra work coordination failure costs, not a multiplier on the MAST failure percentages. The mechanism is intuitive in hindsight. Output that nothing checks still reaches the final answer. [2]

Multi-Agent in Production 2026: What Actually Survived (Micheal Lanham) is the field survey that matters. Teams that shipped multi-agent in production had three architectural traits in common. A single orchestrator owned the plan. Message contracts read like API specs, with typed inputs and validated outputs. A verifier loop could fire a worker and force a retry. Nothing that looked like a Slack channel of debating agents survived contact with on-call rotations. [3]

The constructive read across all three: the architectures that worked in production look more like a CI pipeline than a faculty meeting.

Illustration of a hall-of-mirrors corridor in which a small mark on an inspection card is amplified through repeated reflections

A small mark, re-cited as evidence by every reflection, becomes its own argument.

Diagram comparing error amplification in single-agent, hierarchical with verifier, and free-form coordination architectures

Error amplification by architecture. MAST measured failure modes. The scaling study measured amplification ratios.

The bounded-agent test

Chapter 4 of the book frames the multi-agent decision around three questions. If a workload cannot answer “yes” to all three, do not reach for multi-agent.

  1. Decomposition is structural, not aspirational. The task has a clean partition that any reasonable engineer would draw the same way: retriever, reasoner, verifier; or planner, executor, critic. If two engineers draw the partition differently, you do not have a multi-agent system. You have an architectural disagreement dressed up as architecture.
  2. Each agent has an enforceable contract. Inputs are typed. Outputs are validated. A downstream agent will reject a malformed message without invoking the upstream agent’s reasoning. The MAST taxonomy calls the absence of this “inter-agent misalignment”, and it is roughly a third of the failures they measured, second only to system design issues.
  3. There is a verifier that can fire a worker. The verifier is the bound on error compounding. Centralized coordination held amplification to 4.4x where independent agents reached 17.2x. No published study has isolated an orchestrator-plus-verifier configuration, so treat the verifier as the mechanism the evidence points at rather than one it has measured. The verifier is the difference between a multi-agent system and an expensive single-agent system with extra latency.

These three questions are the architectural floor. They are not the ceiling. A system that answers yes to all three can still fail in ways the three questions do not catch, particularly around cost and latency. But a system that answers no to any of them will almost certainly fail in production for the reasons MAST and the scaling study documented.

Where this fails

The bounded-agent test breaks on tasks where decomposition is genuinely emergent. Open-ended research synthesis is the canonical example. You do not know which sub-tasks the work decomposes into until you have done some of the work. Forcing a partition up front and locking it behind contracts produces a worse answer than a single capable agent with broad context.

The test also breaks when teams use multi-agent to compensate for context window limits. With 200K-token contexts widely available and prompt caching shipping across the major providers, the context excuse is gone for most enterprise workloads. If the only reason for splitting a task across agents is “the context is full,” buy a better cache. Not more orchestration.

The third failure mode is the most common in 2026. Teams adopt multi-agent for organisational reasons. Two teams own the work, so the system has two agents. That is a Conway’s Law artifact, not an architecture decision. It will look fine until someone asks where the verifier is.

In code

The pattern is implemented in src/ch04_multiagent/ in the companion repo:

  • contracts.py — typed message contracts between agents, addressing the second question
  • orchestrator.py — single-orchestrator pattern with a verifier loop, addressing the third question
  • compare.py — single-agent versus multi-agent on the same task, with accuracy, cost, and latency reported side by side

Run python -m ch04_multiagent.compare to reproduce the comparison on the document-intelligence workload. The numbers move with model choice and seed. The shape is consistent with what MAST and the scaling study reported on much larger studies.

Free-form agent collaboration is the slowest known way to amplify a small error into a large one.

Sources

  1. Cemri M., Pan M., Yang S. (2025) Why Do Multi-Agent LLM Systems Fail?
  2. (2025) Towards a Science of Scaling Agent Systems
  3. Lanham M. (2026) Multi-Agent in Production in 2026: What Actually Survived

Cited by