0.0. That is the approximate net improvement in accuracy for a significant number of multi-agent “swarms” once you subtract the massive overhead of coordination and the increase in latency. We have spent the last year pretending that if one LLM is prone to hallucination, five LLMs talking to each other will somehow synthesize the truth. In reality, we are often just creating a larger surface area for things to go wrong.
The industry has fallen in love with the idea of the “agentic workflow,” where a manager agent delegates tasks to a coder agent, who then sends the work to a reviewer agent. It sounds like a professional organization. It looks great in a demo video. But as Anthropic’s recent research points out, these systems introduce a specific kind of instability. When you chain agents together, you aren’t just summing their capabilities; you are multiplying their error rates.
Most of these setups are just glorified loops (which is basically just a fancy way of saying prompt chaining). We are treating LLMs like employees in a corporate hierarchy, forgetting that they don’t have shared intuition or a common sense of “done.” They have prompts. If the manager agent gives a slightly ambiguous instruction, the coder agent interprets it wildly, and the reviewer agent—trying to be helpful—hallucinates a reason why the mistake is actually a feature.
It is a corporate committee meeting that lasts four hours and results in a decision to have another meeting.
The friction here isn’t just conceptual; it’s financial and temporal. Every time an agent “reflects” or “critiques” another agent, you are burning tokens and adding seconds to the TTFT. For a developer, this is a nightmare. You move from a predictable API call to a stochastic process that might take thirty seconds or three minutes depending on how many times the “reviewer” decides the code isn’t quite right.
There is also the issue of the “agentic loop” becoming a death spiral. We’ve all seen it: two agents arguing over a syntax error until they hit the maximum token limit, neither one capable of stepping outside the loop to realize they are both wrong. This happens because we are trying to solve a reasoning problem with a coordination strategy.
Why are we so obsessed with MAS? Probably because it feels like we are building “software” again, with modules and roles, rather than just begging a black box to be smarter. But adding more boxes doesn’t make the box smarter; it just makes the system more fragile.
It’s an expensive way to fail.
The real danger is the propagation of a single bad premise. In a monolithic prompt, a model can sometimes self-correct as it generates text. In a multi-agent system, once a “specialist” agent commits a fact to the shared state, every subsequent agent treats that fact as a ground truth. The error is baked in.
We are essentially building a game of telephone where the participants are all extremely confident liars. If the first agent in the chain decides that the user wants a feature that doesn’t exist, the rest of the swarm will spend the next ten turns optimizing a hallucination. (I suspect most “agent” frameworks ignore this because admitting it would mean admitting that the framework is useless).
The industry is currently blinded by the novelty of “autonomy.” We want the AI to “just handle it,” but autonomy without a reliable world model is just randomness with a fancy name. We don’t need more agents; we need models that can maintain a coherent plan over a long horizon without needing a “manager” to poke them every three paragraphs.
By Q4, the hype around “agent swarms” will collapse, replaced by a return to monolithic models equipped with far more deterministic, hard-coded tool-use logic. We will realize that a single, powerful model guided by a strict state machine is infinitely more useful than a committee of five mediocre agents pretending to be a startup.
