· 5 min read
Coordination patterns are the architecture of multi-agent AI. Choosing the wrong pattern is like choosing the wrong data structure: everything still works, just badly. The pattern determines how agents communicate, in what order they execute, how conflicts are resolved, and ultimately how good the final output is.
There are four primary coordination patterns that cover the vast majority of real-world use cases: pipeline, fan-out/fan-in, hierarchical, and debate. Each has distinct strengths, clear weaknesses, and specific scenarios where it outperforms the others. The right choice depends on whether your task is sequential or parallel, whether agents need to interact with each other's output, and how much coordination overhead you can tolerate.
Most teams should start with pipeline or fan-out/fan-in. These are the simplest to implement, easiest to debug, and sufficient for 80% of multi-agent workflows. Hierarchical and debate patterns are powerful but introduce complexity that is only justified for specific types of problems.
Agents execute in sequence, each receiving the output of the previous agent as input. Agent A produces a draft, Agent B reviews and refines it, Agent C adds a final layer of analysis or formatting.
Best for: Content creation workflows, code generation with review, any task with natural stages. Draft-review-polish is the canonical pipeline.
Strengths: Simple to implement. Easy to debug because you can inspect output at each stage. Each agent has clear, focused responsibility. Adding a new stage is straightforward.
Weaknesses: Total latency is the sum of all stages. A failure at any stage blocks everything downstream. Later agents cannot go back and ask earlier agents to redo work without adding complexity.
Example: A market research pipeline where Agent 1 gathers data from provided sources, Agent 2 analyzes trends and patterns, and Agent 3 writes an executive summary. Each agent builds on the previous one's work.
Multiple agents work on the same input simultaneously, and a coordinator agent synthesizes their outputs into a unified result.
Best for: Analysis tasks requiring multiple perspectives. Code review with different lenses (security, performance, style). Research requiring coverage of multiple domains.
Strengths: Fast, because agents run in parallel. Naturally produces multi-perspective analysis. One agent's failure does not block others. The coordinator can weigh and reconcile different viewpoints.
Weaknesses: The coordinator is a single point of failure and must be well-prompted. Agents may produce redundant or contradictory analysis that is difficult to reconcile. More expensive because all agents run even if only some perspectives are relevant.
Example: A product launch analysis where one agent evaluates market timing, another assesses competitive positioning, a third analyzes pricing strategy, and the coordinator produces a go/no-go recommendation with supporting evidence from all three.
A manager agent breaks the task into subtasks, delegates each to a specialist agent, reviews their outputs, and may request revisions before producing the final result.
Best for: Complex, open-ended tasks where the subtask decomposition itself requires intelligence. Project planning, comprehensive audits, multi-section document generation.
Strengths: Handles complex tasks that cannot be pre-decomposed. The manager agent can adapt the plan based on intermediate results. Supports revision loops without redesigning the whole system.
Weaknesses: The manager agent is doing a lot of cognitive work and can become a bottleneck. More model calls means higher cost and latency. Debugging is harder because the manager's delegation decisions are themselves a source of errors.
Example: Generating a complete business plan where the manager identifies needed sections (market analysis, financial projections, operations plan, marketing strategy), delegates each to a specialist, reviews the drafts, identifies gaps, requests revisions, and assembles the final document.
Two or more agents argue opposing positions on a question, and a judge agent evaluates their arguments to reach a conclusion.
Best for: Decision-making under uncertainty. Evaluating tradeoffs. Stress-testing strategies. Any situation where you want to surface counterarguments.
Strengths: Naturally surfaces risks and counterarguments that other patterns miss. Produces more balanced analysis. The adversarial dynamic forces agents to be more rigorous in their reasoning.
Weaknesses: Higher cost (multiple rounds of back-and-forth). Can devolve into repetitive arguments without good judge prompting. Not suitable for tasks with clear right answers. The judge needs careful calibration to avoid systematic bias.
Example: Evaluating whether to build or buy a software component. Agent A argues for building in-house (control, customization, long-term cost), Agent B argues for buying (speed, maintenance burden, opportunity cost), and the Judge weighs both arguments against the specific context to make a recommendation.
| Dimension | Pipeline | Fan-Out/Fan-In | Hierarchical | Debate |
|---|---|---|---|---|
| Latency | High (sequential) | Low (parallel) | Variable | High (multiple rounds) |
| Cost | Moderate | Moderate-High | High | High |
| Complexity | Low | Low-Medium | High | Medium |
| Best task type | Sequential workflows | Multi-perspective analysis | Open-ended complex tasks | Decision-making |
| Error handling | Weak (cascading) | Good (isolated) | Good (manager can retry) | N/A |
| Scalability | Add stages easily | Add perspectives easily | Manager becomes bottleneck | Limited to 2-3 debaters |
Choose Pipeline when:
Choose Fan-Out/Fan-In when:
Choose Hierarchical when:
Choose Debate when:
Start with fan-out/fan-in for analysis tasks and pipeline for creation tasks. These two patterns cover the majority of real-world needs and are simple enough to implement in an afternoon. Master them before moving to hierarchical or debate patterns.
When you do reach for hierarchical coordination, keep the depth to two levels: one manager and its direct specialist agents. Deeper hierarchies (managers managing managers) introduce compounding latency and error rates that rarely justify the added structure.
The debate pattern is underused. Most teams default to having a single agent produce analysis, which means they never surface the counterarguments. Even a simple two-agent debate with a judge produces dramatically more balanced recommendations than a single agent, no matter how carefully prompted. If you make one change to your multi-agent setup this quarter, add a debate step to your highest-stakes decisions.
Finally, patterns can be composed. A common and effective architecture is fan-out to specialist analysts, pipeline their outputs through a synthesizer and reviewer, and use a debate pattern for the final recommendation. Start simple, measure quality, and add coordination complexity only where it produces measurable improvement.