15 patterns for this issue
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 lose or drop key information passed between them, so a downstream agent acts without facts that an upstream agent already discovered.
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.
Two or more agents disagree and nothing in the pipeline resolves the conflict, so contradictory answers reach the end user or downstream system.
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.
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.
Agents interacting live produce unintended behavior -- loops, oscillation, runaway cost -- that never shows up when each agent is tested in isolation.
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 receiving agent misreads or misparses another agent's output, so its downstream action contradicts what the upstream agent actually produced.
Agents converge on an answer and stop before gathering enough evidence, so the group agrees quickly but on a weakly supported conclusion.
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 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.
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.
Multi-agent AI systems fail to coordinate because the system-design layer — who owns which decision, how messages are validated at handoffs, and how disagreement gets resolved — is left implicit, so agents fall back on ad hoc behavior that breaks silently under real workloads. All 15 coordination patterns here trace back to the same taxonomy (MAST — Cemri et al., arXiv:2503.13657) of multi-agent system failures spanning specification gaps, inter-agent misalignment, and task-verification weaknesses. The shared consequence is that a multi-agent pipeline can pass every single-agent test and still fail once agents actually have to coordinate.
All 15 coordination patterns point to the same underlying gap: multi-agent systems are usually built by getting each agent to work, then wiring the agents together, with no equivalent investment in the wiring itself. The documented mitigation is consistent across every pattern regardless of cluster: validate handoffs against an explicit schema before forwarding, checkpoint world-model state at agent-to-agent transitions so divergence is caught early rather than discovered downstream, and structure the workflow as a saga with compensating actions so a single agent’s error doesn’t corrupt global state. None of the documented mitigations are agent-capability fixes — the mitigations are coordination-layer infrastructure that has to exist independently of how good any individual agent is.
Coordination failures cover the breadth of ways agents fail to work together — authority, roles, communication, consensus. Error Propagation (GitHub) covers one specific mechanism in depth: how a single upstream error compounds exponentially through a sequential pipeline, with measured amplification factors. Cascading Error in coordination is the same conceptual failure at stub depth; Error Propagation’s pattern documents it with worked examples and statistics.
Because the failure lives in the interaction, not in any single agent — see Emergent Behavior (GitHub). Agents that behave correctly in isolation can still produce a broken system when their outputs, timing, or assumptions interact in ways no single-agent test exercises.
Not by itself. Verifier-Agent Weakness (GitHub) documents that a judge agent can fail to catch worker-agent errors for the same reason the workers made the errors — shared blind spots, insufficient independence, or no access to ground truth the workers lacked. A verifier adds value only when it has a genuinely independent check, not just another model instance reviewing the same evidence.
They’re related but distinct. Role Ambiguity (GitHub) is about agents not knowing who is responsible for which subtask (leading to duplicate or missing work). Authority Confusion (GitHub) is about agents each producing an output and the system having no rule for which one wins when they conflict. A system can have clear roles but still lack authority rules, or vice versa.
| Pattern | Mechanism |
|---|---|
| Authority Confusion (GitHub) | System has no rule for which agent’s output wins when outputs conflict |
| Cascading Error (GitHub) | An early agent’s error propagates and is amplified by every downstream agent in the pipeline |
| Communication Loss (GitHub) | Key information present in one agent’s trace never reaches another agent that needs it |
| Consensus Illusion (GitHub) | Agents agree because they share the same flawed context or bias, not because the answer is correct |
| Contradictory Outputs (GitHub) | Agents produce conflicting recommendations and no arbitration mechanism exists |
| Coordinator Failure (GitHub) | A manager agent assigns subtasks poorly or fails to synthesize worker outputs into a coherent result |
| Duplicate Work (GitHub) | Multiple agents independently solve the same subtask, wasting effort or producing conflicting versions |
| Emergent Behavior (GitHub) | Agent interaction produces a failure mode not observed when any agent is tested in isolation |
| Infinite Debate (GitHub) | Agents critique and revise each other’s output endlessly without a termination condition |
| Message Misinterpretation (GitHub) | One agent misreads another agent’s output, and downstream action contradicts the upstream result |
| Premature Consensus (GitHub) | Agents converge on an answer before the evidence needed to support that answer has actually been checked |
| Role Ambiguity (GitHub) | Agents don’t know who owns which responsibility, causing duplicate or missing work |
| Task Handoff Failure (GitHub) | One agent passes incomplete or incorrect state to the next agent in the workflow |
| Verifier-Agent Weakness (GitHub) | A judge/verifier agent approves a trace that a worker agent got wrong |
| Worker Tunnel Vision (GitHub) | A specialized agent optimizes its own local subtask goal at the expense of overall task success |
Total: 15 patterns