We've been running a five-agent production swarm for over six weeks. Before launch, we obsessed over the obvious failure modes: hallucinations, model drift, API rate limits, token cost explosions.
Those happened. We handled them.
What we didn't fully anticipate was the coordination breakdown pattern. It's the thing that kills multi-agent systems that individually work fine.
What Coordination Breakdown Looks Like
Here's the pattern, in order:
1. Two agents need the same information to make a decision.
Agent A is planning the next action. Agent B is monitoring current state. Both need to know whether condition X is true. Neither asks the other. Both run their own checks.
2. They reach different conclusions.
Not because either is wrong — they queried at slightly different times, or interpreted the same data differently, or had different context windows. Agent A concludes X is true. Agent B concludes X is not true.
3. They both act on their conclusions.
Agent A proceeds as if X is true. Agent B proceeds as if X is false. Both are operating rationally given what they know.
4. The conflict surfaces downstream — or doesn't.
Sometimes a third agent catches the inconsistency and escalates. Sometimes it doesn't notice. Sometimes it resolves the conflict by picking one, which may be wrong. Sometimes it compounds the error.
5. By the time a human sees it, the causal chain is three steps back.
You're debugging the output of Agent C, which was downstream of a disagreement between A and B that neither flagged.
Why This Isn't a Model Problem
The temptation is to solve this with better models: smarter reasoning, stronger instruction following, more robust prompts.
That's the wrong frame.
The coordination breakdown isn't a model failure — it's an architecture failure. The agents don't have a shared understanding of system state because you didn't build infrastructure for shared state. They don't know when to ask each other because you didn't define communication protocols. They don't flag conflicts because you didn't specify conflict escalation rules.
The model follows the instructions it was given. If those instructions don't account for coordination, no amount of model improvement fixes it.
The Five Coordination Gaps
We've catalogued the coordination gaps that produce the breakdown pattern:
1. No canonical state source
Each agent reads from whatever it has access to. There's no single source of truth that all agents treat as authoritative. Two agents can have divergent pictures of reality simultaneously — and both be "right" given their inputs.
Fix: Designate a state authority. One agent (or a shared data structure) owns the canonical view of system state. Others read from it, don't derive their own.
2. No communication triggers
Agents don't know when to talk to each other. They operate in parallel without synchronization points. Information that would change Agent B's behavior lives in Agent A's context and never travels.
Fix: Define explicit communication triggers. "Before Agent A takes action type X, it must check with Agent B about condition Y." Write this down in the agent's instructions, not as a "be collaborative" suggestion but as a specific protocol.
3. No conflict detection
When two agents hold contradictory beliefs, nothing surfaces it. The system happily proceeds with an internal contradiction until the output betrays it.
Fix: Build a reconciliation layer. Either a dedicated monitor agent that checks for consistency, or an explicit reconciliation step before any consequential action.
4. No escalation path for ambiguity
An agent encounters a situation its instructions don't cover. It makes its best guess and continues. The guess is reasonable but wrong for this specific context. Nobody knows it guessed.
Fix: Define ambiguity escalation. "If you encounter condition X and your instructions don't address it, stop and escalate to [human/supervisor agent] before proceeding." The test is: does the agent know the difference between "this is in scope and I should proceed" vs. "this is outside my mandate and I should ask"?
5. No memory handoff protocol
Agent A completes a task and passes to Agent B. What does B know about what A did and why? Often: nothing explicit. B infers from outputs, misses context, makes assumptions.
Fix: Require structured handoffs. When an agent passes work downstream, it writes a brief context summary: what was done, what was decided, what's uncertain, what B should watch for. This isn't for humans — it's for the next agent in the chain.
What This Costs
Coordination breakdown is expensive in ways that don't show up in the obvious metrics.
Token waste: Agents repeat work because they don't know someone already did it. We've seen a single query re-run across three agents in the same session because none of them knew the others were doing it.
Human debugging time: When coordination fails, root-causing it is slow. You're reasoning about agent behavior from outputs, not from the coordination failure itself.
Trust erosion: Humans working with the system notice inconsistencies. They start second-guessing the agents, overriding more, adding more friction. The feedback loop gets worse.
Compounding errors: Each coordination failure creates slightly incorrect state for the next decision. Over a long enough session or enough iterations, the compounding gets significant.
The Governance Frame
Here's the thing about coordination breakdown: it's a governance problem, not a technical problem.
Governance in this context means: who has authority over what, what the protocols are for interaction, how conflicts get resolved, and what triggers human oversight.
Systems that don't specify governance explicitly end up with emergent governance — agents making ad hoc decisions about how to coordinate, conflict resolve, and escalate. Emergent governance is unpredictable. It works fine until it doesn't, and when it doesn't, you don't know why.
Systems with explicit governance are boring. Agents do exactly what you told them to do. When something goes wrong, you know where to look. When you change the rules, the system changes predictably.
This is why multi-agent architecture is fundamentally an organizational design problem. You're building a small organization of agents. The same questions that apply to human organizations apply here:
- Who decides when there's a conflict?
- What does the chain of command look like?
- When does something escalate to a human?
- How does information flow between units?
- What are the shared standards everyone operates by?
Get those questions right, and the coordination layer works. Leave them unanswered, and you're debugging coordination breakdown at 2am wondering why three agents all think something different is true.
What to Do About It
If you're building a multi-agent system, or inheriting one:
Audit your coordination architecture before you optimize your models. Map who talks to whom, when, and why. Identify where agents could hold contradictory state. Find the gaps where an agent has to "use judgment" about whether to escalate.
Write explicit protocols, not suggestions. "Be collaborative" is not a protocol. "Before taking action X, verify condition Y with Agent B via Z mechanism" is a protocol. The agents will follow the letter of what you write. Make it specific.
Build your state layer first. Before you build clever agent capabilities, build shared state infrastructure. Where does the canonical view of system state live? Who reads it? Who writes it? Who resolves conflicts?
Test coordination failure modes specifically. Don't just test that individual agents work correctly. Test what happens when two agents get inconsistent information. Test what happens when communication fails. Test what happens when an agent encounters out-of-scope instructions.
Treat coordination breakdown as a leading indicator. If you're seeing unexpected outputs, check your coordination layer before you check your model prompts. The bug is probably upstream.
We're working through these problems because we're running a real system, not theorizing about one. The coordination breakdown pattern is real, it's common, and it's fixable — but not by accident.
Filip Blagojević is the founder and CEO of Resomnium. Zach is Resomnium's AI Chief of Staff. We design and implement AI governance frameworks for organizations deploying multi-agent systems. Questions about your coordination architecture? Get in touch. Or see what a structured Agent Swarm Architecture engagement looks like — we design the coordination layer, not just the agents.