The Six Coordination Patterns
Orchestrator, Pipeline, Graph, Blackboard, Swarm, and Human-in-the-Loop. Almost every multi-agent system is one of these shapes — or a composition of them. Each card links to its full pattern entry.
- Pipeline
- Orchestrator
- Graph
- Blackboard
- Swarm
+ Human-in-the-Loop composes on any of them
Orchestrator / Agent-as-Tool
How it works
- One central LLM plans; every specialist is exposed as a typed tool call.
- The orchestrator picks a tool, invokes it, and receives a return value.
- After every call control returns to the center — specialists never talk to each other.
Who holds the flow together? Who delegates to whom?
Specialists are exposed as typed callables — tools — and the orchestrator sees only the signature, not the prompt or model. That boundary is what makes specialists hot-swappable across implementations and frameworks, including remote A2A agents.
Pipeline / Workflow (DAG)
How it works
- Developers wire every stage and edge in code before the run.
- Each stage transforms the state and hands it to the next exactly once.
- The graph is identical on every run; only the model output inside the nodes varies.
Which order is fixed? What can run in parallel?
Control flow is fully wired in code: which nodes run, in what order, with what fan-out. The graph is identical every run; only the model-generated content inside nodes is non-deterministic.
Graph (Fan-out / Fan-in)
How it works
- Nodes and edges are registered up front — the set stays closed.
- At conditional edges an LLM picks the next path from the registered set.
- Cycles are allowed, but a recursion limit bounds every loop.
Are there conditional branches, and points where results converge?
Pipeline plus two relaxations — conditional edges chosen by an LLM, and cycles bounded by a recursion limit. The node set is still closed and the state schema is still validated; only the path through them is runtime.
Blackboard (Shared State)
How it works
- Agents never address each other — they read and write a shared board.
- Whoever's precondition matches the current state activates itself.
- Adding an agent is a subscription, not a rewiring of the topology.
Where does the shared working state live? How does the knowledge of all agents grow?
Communication runs through a shared state surface, not addressed messages. Adding an agent is a subscription, not a rewire — the other agents do not learn of its existence. The only pattern with an open agent set at runtime.
Swarm (Self-Organizing Handoffs)
How it works
- Each agent declares the peers it may hand off to.
- A handoff transfers control completely — there is no return path.
- The route materializes at runtime; the graph is a trace, not a plan.
Can the agents decide for themselves who takes over next?
The graph is a runtime artefact. Each agent declares which peers it may hand off to; the path through the network materialises as the run progresses. Appropriate for problems where no static plan can be drawn in advance.
Human-in-the-Loop
How it works
- The run pauses at a defined node and its state is persisted.
- A human answers a structured question — approve, edit, or reject.
- The run resumes exactly where it stopped — on top of any other pattern.
Where must a human intervene, and with what question?
Suspend the run at a designated node, persist state, ask a human a structured question, resume when the answer arrives. Innovation is in the time dimension — HITL composes with every other pattern instead of competing with them.
The trade-offs at a glance
| Pattern | Controls flow | Parallelism | Cycles | Determinism |
|---|---|---|---|---|
| Orchestrator | Orchestrator LLM | Yes (fan-out workers) | No | Medium |
| Pipeline | Developer | Yes | No | High (static edges) |
| Graph | Developer + LLM | Yes (fan-out) | Yes | Medium (LLM-chosen edges) |
| Blackboard | All agents | Yes (async writers) | Yes | Medium |
| Swarm | Agents (handoffs) | Yes (concurrent peers) | Yes | Low |
| HITL | Human + system | No | No | High (system); human-bounded |