Skip to content

Why multi-agent systems fail: 14 failure modes and what they share

13 Nov 2026

·

5 minute read

Splitting a task across several specialised agents feels like the obvious next step once a single agent struggles. The research on multi-agent system failures suggests the step is often sideways rather than forward, and that the reasons are structural rather than a matter of better prompting.

This post covers what was actually measured, what the failures have in common, and the narrower set of cases where a second agent earns its place.

The gains are frequently smaller than the architecture diagram implies

The paper Why Do Multi-Agent LLM Systems Fail? opens with an uncomfortable observation: "Despite enthusiasm for Multi-Agent LLM Systems (MAS), their performance gains on popular benchmarks are often minimal."

That is worth sitting with before designing a system of five cooperating agents. The enthusiasm is real, the architectural appeal is genuine, and the measured benefit on standard benchmarks frequently is not there.

Fourteen failure modes, three categories

Rather than theorise, the authors annotated real executions. They developed their taxonomy, MAST, "through rigorous analysis of 150 traces, guided closely by expert human annotators", reporting inter-annotator agreement of kappa 0.88, and released a dataset of over 1,600 annotated traces drawn from seven different multi-agent frameworks (Why Do Multi-Agent LLM Systems Fail?, arXiv:2503.13657).

The fourteen modes group into three categories, and the grouping is the useful part:

  • System design, meaning the failure was baked in by how the system was specified before it ever ran.
  • Inter-agent misalignment, where agents individually behave sensibly and collectively do not.
  • Task verification, where nothing checked whether the work was actually finished and correct.

Notice that only the middle category is about agents talking to each other. Two thirds of the taxonomy describes problems that existed before the agents started cooperating, and that a second agent therefore cannot fix.

The common thread is that nobody owns the outcome

Reading the categories together, the pattern is an accountability gap rather than a capability gap.

In a single-agent system, one component holds the task and the obligation to finish it. Split that across a planner, a researcher and a writer, and each one can complete its own step correctly while the overall job remains undone. The planner produced a plan. The researcher answered the plan it was given. The writer wrote up what it received. Every agent succeeded and the user did not get what they asked for.

Task verification shows up as its own category for exactly this reason. Somebody has to check the finished result against the original request, and in a multi-agent design that role frequently belongs to nobody in particular.

Better prompts are not the fix

The temptation on reading a failure taxonomy is to treat each mode as a prompting bug and patch it. The authors push back, writing that the identified failures "require more sophisticated solutions" and pointing to improvement headroom in better system design.

That phrasing is deliberate. These are architectural problems, surfacing as conversational ones. A misaligned handoff between two agents can be papered over with a more explicit instruction, and the next handoff will fail differently, because the structure that produced it has not changed.

When a second agent actually earns its place

The case for multiple agents is strongest when context isolation is the point rather than specialisation.

Anthropic's guidance on building effective agents describes delegating focused work to sub-agents that return condensed summaries, which is a context argument: the sub-agent burns through a large amount of material and hands back a small amount. The same guidance is blunt about the cost of autonomy generally, noting that "the autonomous nature of agents means higher costs, and the potential for compounding errors", and recommending "stopping conditions (such as a maximum number of iterations) to maintain control".

Compounding errors is the relevant risk here. Each handoff between agents is another place for a small misreading to become the premise of everything downstream, and chains amplify rather than correct.

Three cases where the second agent is usually worth it:

  1. The sub-task consumes a lot of context and produces a little, such as reading forty documents to answer one question.
  2. The sub-task needs genuinely different permissions, so isolating it also narrows what can go wrong.
  3. The sub-task runs on a cheaper model without loss, making the split a cost decision rather than a capability one.

Outside those, a single agent with good tools is usually both simpler and better, and it keeps the accountability for the outcome in one place.

Before you add an agent

Work out which category your current failure belongs to. If it is system design or task verification, splitting the work will reproduce the same failure across more components and make it harder to see.

An evaluation set built from your own failure cases is how you find out which category you are in, and it is also how you discover whether the multi-agent version is actually better, as opposed to differently shaped. Run the same cases against both.

If you do go multi-agent, the inter-agent messages become the surface worth watching, which is the argument for the oversight patterns covered in guardian agents and runtime oversight.

If you are deciding whether to split an agent that is already struggling, tell us about the project.

AI tools

Ask ChatGPTAsk Claude

Start with the problem that matters