18 patterns in this category
Multi-agent AI systems most often fail not because any individual agent is weak, but because the coordination layer between agents — authority, handoffs, communication, and consensus — is left implicit and breaks silently under real workloads. A pipeline can pass every single-agent test and still fail once agents have to hand off state, agree on a conclusion, or recover from one agent’s mistake, because those are properties of the system as a whole, not of any one agent in it.
| Goal | Covers | Patterns |
|---|---|---|
| Coordination | The full breadth of coordination breakdowns — authority, roles, communication, consensus, and verification across a multi-agent system | 15 |
| Error Propagation | How a single agent’s error compounds exponentially through a sequential, unverified pipeline | 1 |
| Handoff Reliability | Why a structured handoff schema can lose an upstream agent’s confidence or methodology signal | 1 |
| Reasoning Quality | Why multiple agents agreeing on an answer doesn’t mean the answer is correct | 1 |
Total: 18 patterns
The four multi-agent-systems goals aren’t a pipeline with a natural order — the four goals are different lenses on the same underlying problem: what happens at the seams between agents. Coordination is the broad taxonomy; the other three goals are deep dives into specific seam failures that Coordination’s own patterns only cover at stub depth (Cascading Error, Task Handoff Failure, and Consensus Illusion/Premature Consensus respectively). To route by symptom: a multi-agent trace fails while every individual agent passes in isolation, or roles/authority are unclear → Coordination; a small upstream error somehow becomes a large final-output error in a sequential pipeline → Error Propagation; a downstream agent acts with full confidence on a value the upstream agent had actually flagged as uncertain → Handoff Reliability; multiple agents agree on an answer that later turns out to be wrong → Reasoning Quality.
Coordination is the broad taxonomy covering 15 distinct failure patterns across authority, roles, communication, and verification, each documented at a consistent but relatively concise depth. Error Propagation, Handoff Reliability, and Reasoning Quality each take one specific mechanism that Coordination’s patterns touch on briefly (Cascading Error, Task Handoff Failure, Consensus Illusion) and document it in full depth with worked examples, statistics, and citations.
No single fix, but a consistent architecture recurs across all 18 patterns: schema-validated handoffs, consensus checkpoints at agent transitions, and saga-pattern compensating actions for error isolation. What differs by goal is where in the pipeline the check needs to sit — at every inter-agent message for Coordination and Handoff Reliability, at each pipeline stage for Error Propagation, and at the point where agreement is treated as a decision signal for Reasoning Quality.
Start with Coordination — its 15 patterns cover the widest range of symptoms and will usually narrow down which specific mechanism is at play. If the symptom is specifically “a small error became a huge one” or “agents agreed but were all wrong,” jump directly to Error Propagation or Reasoning Quality respectively, since those goals document the exact amplification statistics and reproduction protocols.
Agents disagree on who has final say, and the system silently picks a winner instead of resolving the conflict. This is common in flat multi-agent orchestration (e.g., LangGraph or CrewAI-style peer topologies) where no agent is declared authoritative for a given decision domain.
An early agent's mistake gets treated as ground truth by every downstream agent, so a small error compounds into a badly wrong final answer as it propagates through the pipeline.
Agents appear to agree, but only because they were all seeded from the same flawed context or bias -- not because they independently verified the answer.
The manager/orchestrator agent (the coordinator role in LangGraph supervisor graphs or CrewAI's manager pattern) assigns subtasks to the wrong worker agents, or fails to correctly synthesize their outputs into a coherent final answer.
An upstream agent flags low confidence or ambiguity in its free-text reasoning, but the structured handoff schema passed to the downstream agent -- a common MCP/tool-call handoff pattern -- carries only the final value and status. The confidence/provenance signal is invisible to the downstream agent, which uses the value with full confidence.
A receiving agent misreads or misparses another agent's output, so its downstream action contradicts what the upstream agent actually produced.
Agents don't have a clear, non-overlapping definition of who owns which responsibility, so work gets duplicated in some areas and dropped entirely in others.
An agent hands off incomplete or incorrect state to the next agent in the pipeline -- a common failure in LangGraph/CrewAI-style handoffs -- so the downstream agent works from a gap it doesn't know exists.
A specialized worker agent optimizes its own subtask metric so hard that it ignores or overrides the global plan, so the overall task fails even though each agent's local output looks fine.
Multiple agents independently solve the same subtask -- often calling the same expensive tool or API -- because there's no shared task ledger to prevent redundant work.
Two or more agents disagree and nothing in the pipeline resolves the conflict, so contradictory answers reach the end user or downstream system.
Multiple independent agents reach the same wrong conclusion, and the system mistakes that agreement for a confidence signal -- escalating the decision to production because all agents making the identical mistake looks like verification, not error.
Agents converge on an answer and stop before gathering enough evidence, so the group agrees quickly but on a weakly supported conclusion.
Critic and reviser agents -- a common pattern in LangGraph reflection loops -- keep critiquing and revising each other's work endlessly, with no termination condition to stop once the debate stops making progress.
A judge/verifier agent -- a pattern common to LLM-as-judge and OpenAI Agents SDK guardrail setups -- approves worker-agent output that is actually wrong, because it's checking surface plausibility rather than verifying against ground truth.
Agents lose or drop key information passed between them, so a downstream agent acts without facts that an upstream agent already discovered.
Agents interacting live produce unintended behavior -- loops, oscillation, runaway cost -- that never shows up when each agent is tested in isolation.
A single agent's error compounds exponentially as it moves through a multi-agent pipeline -- common in LangGraph/CrewAI sequential chains -- because downstream agents treat upstream errors as ground truth, amplifying the original mistake 17x-20x by the time it reaches the final output.