Research · July 10, 2026 · 7 min read

Why multi-agent systems fail — reading the MAST taxonomy

Add a second agent to a task and your bug reports change shape. The model didn't get dumber — but the system started failing in new ways. A large annotated study of multi-agent failures explains why: most of them aren't reasoning errors at all.

The counterintuitive finding

When a single agent fails, the usual suspect is the model: it hallucinated, it lost the thread, it couldn't do the math. So when teams move to multi-agent systems and failures pile up, the instinct is the same — swap in a bigger model, tune the prompts, add more reasoning steps.

The data says that instinct is mostly wrong. A taxonomy of multi-agent LLM failures — built from 1,600+ annotated execution traces across popular agent frameworks — found that the single largest family of failures isn't the model being incapable. It's agents talking past each other. Roughly 36.9% of failures trace to inter-agent misalignment: agents working from inconsistent copies of shared state.

In other words: the reasoning was fine. The agents just didn't agree on reality.

Three families of failure

The taxonomy (known as MAST — a Multi-Agent System failure taxonomy) sorts what actually goes wrong into three families. It's worth learning, because each family points at a different fix:

• Specification & system design. The setup was wrong before anyone reasoned: an under-specified role, a step that disobeys the task spec, an agent that forgets its instructions mid-run. Fixable with better prompting and structure.
• Inter-agent misalignment. The largest bucket. Agents reset the conversation, withhold information the next agent needed, ignore input they were handed, or take an action their own reasoning contradicts. Every one of these is a coordination failure — two or more agents holding different pictures of the same task.
• Task verification. Nobody checked the work. The system terminates early, or accepts a wrong answer because no step was responsible for catching it.

Notice that only the first family is really about a single agent's competence. The other two are about the system — and the biggest of the three is squarely about shared state.

Memory is the through-line

Look closely at inter-agent misalignment and a single root keeps surfacing: there is no source of truth the agents can reliably read and write against. It shows up in three everyday shapes:

• The invisible handoff. Your researcher discovers the auth flow moved to v2. Your writer never sees it and documents v1. Each agent started from zero.
• Stale truth. Two agents update the same fact. Which value is the system serving right now? If you can't answer, neither can your agents.
• Debugging in the dark. "Why did the agent do that?" turns into an afternoon of archaeology, because nothing recorded who wrote what, when, and from which run.

And it isn't free. Beyond the failures you can see, coordination waste shows up on the bill: a large share of compute in multi-agent systems — on the order of 40% — is spent re-establishing context that another agent already had. You pay for the same discovery three times because three agents each rediscover it.

You can't prompt your way out of a state problem

Here's the part teams miss. Inter-agent misalignment is not a prompting bug, so prompting doesn't fix it. Adding "please coordinate with the other agents" to a system prompt does not give agent B a guarantee that it will see agent A's most recent write. It gives it a suggestion. Under load, suggestions lose.

Coordination is an infrastructure property, not a wording choice. Either the system can promise "if A wrote it, B's next context contains it," or it can't. Most stacks can't — they hand each agent a private context window and hope the important facts propagate by luck.

The missing layer

The failures MAST catalogs are what you get when a team of agents shares work but not memory. The fix isn't a smarter agent; it's a shared substrate with a contract. That's what a coordination memory layer is: agents stream events (write), the layer turns them into versioned, conflict-resolved facts (consolidate), and any agent can ask for one budget-fit, provenance-tagged block of context (pack) — with a read-your-writes guarantee so B always sees A's latest write.

That last guarantee is the one that dissolves the biggest failure family. We wrote a plain-English guide to it: read-your-writes for agents.

The one-line version

Most multi-agent failures aren't the model reasoning badly — they're agents reasoning correctly over different copies of reality. You don't fix that with a bigger model or a better prompt. You fix it with a memory layer that makes shared state consistent by contract.

Lore is an open-source coordination memory layer for multi-agent AI. The repo is live on GitHub; see how it works on Features, or how it compares on Compare.