In multi-agent systems, the coordinator sits at the center. Every piece of information, every delegation, every result flows through it. Sub-agents never talk to each other directly. This isn’t bureaucracy — it’s the architecture that makes error handling, conflict resolution, and quality control possible.
The pattern
The coordinator handles five responsibilities:
- Task decomposition — analyze the request, break it into subtasks
- Delegation — assign subtasks to the right specialist agents
- Result aggregation — collect outputs from all agents
- Conflict resolution — reconcile when agents disagree
- Synthesis — produce a unified final output
Sub-agents communicate only with the coordinator. The code analysis agent does not directly call the test generation agent. The billing agent does not directly retry the shipping agent. All inter-agent communication routes through the coordinator.
Why not a mesh?
A mesh architecture (agents calling agents directly) eliminates the coordinator “bottleneck” but introduces distributed complexity. When the NLP agent fails mid-pipeline in a mesh, who retries it? Who tracks overall progress? Who ensures output consistency? In hub-and-spoke, the answer is always the coordinator. In a mesh, these responsibilities are scattered across agents that weren’t designed for them.
The “what not how” boundary
The coordinator defines what each agent should achieve (goals, scope, quality standards). Agents decide how to achieve it (specific techniques, analysis depth). The security agent knows best which vulnerability patterns to check — the coordinator ensures it reports findings in a structured format. This gives the coordinator visibility (structured reports) while preserving agent autonomy (domain expertise).
Smart delegation
A coordinator that always delegates to all agents for every request is a fixed pipeline, not an intelligent orchestrator. Data shows 70% of customer support tickets need only one specialist agent. Delegating all three agents for every ticket means 70% of delegations are wasteful.
The coordinator should analyze each request and delegate only to the agents that are needed. Simple order status → shipping agent only. Refund + address change → billing + account agents. This is what differentiates an intelligent coordinator from a fan-out broadcaster.
Partial failure handling
When one agent fails (timeout, error), the coordinator preserves successful results and handles the failure independently. The billing agent’s results don’t get discarded because the shipping agent timed out. The coordinator presents available results, acknowledges the failure, and takes recovery action (retry, escalate, or skip with annotation).
Coordinator as bottleneck
The coordinator can become a bottleneck — in one system, it accounted for 80% of total query time. The fix isn’t removing it (that reintroduces all the problems it solves). The fix is optimizing it: pipeline coordinator stages so aggregation starts while agents are still running, use streaming to process early results, and overlap coordinator work with agent execution.
One-liner: All inter-agent communication routes through the coordinator — it decomposes, delegates smartly (only needed agents), resolves conflicts, handles partial failures, and synthesizes results. Optimize the coordinator, don’t remove it.