The GoF design patterns book gave object-oriented programming a shared vocabulary. Multi-agent systems do not have one yet, and the resulting confusion shows up in every architecture review. Here is a starter set of eight collaboration patterns we see again and again, with their trade-offs.
Why patterns, not frameworks
Frameworks pick a structure and lock you in. Patterns describe a problem and a class of solutions. The same way Singleton was a pattern before it was a class, agent collaboration is full of recurring shapes that deserve names.
The eight patterns
1. Reviewer-Author
One agent writes; another reviews. Iterations until the reviewer signs off or a budget exhausts.
- Solves: quality control without a human in the loop.
- Cost: 2x base + iteration overhead.
- Pick when: writing-heavy tasks (code, content, contracts).
2. Planner-Executor
A planner decomposes; executors run leaves. See orchestration patterns.
- Solves: large tasks that exceed one agent's working memory.
- Cost: planner is the bottleneck.
- Pick when: the task naturally decomposes.
3. Scribe-and-Actor
A scribe agent records every step the actor takes; the actor stays focused on the task. The scribe produces the audit trail and the summary.
- Solves: explainability and audit without bloating the actor's context.
- Cost: scribe runs in parallel; small overhead.
- Pick when: regulated workflows where decisions need post-hoc explanation.
4. Gossip
Peer agents share state opportunistically. No central authority; eventual consistency.
- Solves: distributed knowledge spread without a coordination bottleneck.
- Cost: unpredictable convergence.
- Pick when: monitoring fleets, distributed research.
5. Contract-Net
A coordinator broadcasts a task; capable agents bid; coordinator picks the winner.
- Solves: load distribution across heterogeneous agents.
- Cost: bid round adds latency.
- Pick when: dynamic fleets where capabilities and availability shift.
6. Devil's Advocate
A specialised agent always argues against the proposed action. Forces the primary to defend or refine.
- Solves: confident-but-wrong outputs.
- Cost: expensive on every action; selective use.
- Pick when: high-stakes decisions, fewer per day.
7. Mentor-Apprentice
A more capable model (Opus) supervises a cheaper one (Haiku). Mentor steps in only when the apprentice's confidence drops.
- Solves: cost optimization with quality fallback. See model routing.
- Cost: measured per call; usually saves 60–80%.
- Pick when: high-volume agents with variable difficulty.
8. Pipeline-with-Backpressure
Stages communicate via a buffered queue; downstream slowness slows upstream production.
- Solves: runaway agent loops where one stage outpaces another.
- Cost: added queue infrastructure.
- Pick when: long-running data-processing agents.
Combining patterns
Most production systems combine three or more. A typical stack:
Planner-Executor
↓ at each leaf:
Reviewer-Author
↓ during execution:
Scribe-and-Actor
The scribe's record feeds the audit trail; the reviewer ensures quality; the planner-executor handles scale.
What is missing from the GoF analogy
GoF patterns are language-agnostic. Agent patterns are not — they depend on the model's ability to follow role instructions. Three caveats:
- Pattern fidelity drops at lower model tiers. Haiku does not always honour "you are the reviewer" instruction.
- Cost is structural — patterns multiply token usage in ways that GoF did not.
- Failure modes are stochastic — a pattern that works 99% of the time still fails 1%.
Code-skeleton signatures
Across libraries (LangGraph, OpenAI Swarm, Claude Agent SDK), the patterns map to roughly the same primitives:
| Pattern | Primitive |
|---|---|
| Reviewer-Author | conditional edge with retry |
| Planner-Executor | supervisor node + worker pool |
| Scribe-and-Actor | parallel branches |
| Gossip | shared message bus |
| Contract-Net | broadcast + selector |
| Devil's Advocate | adversarial node before action |
| Mentor-Apprentice | conditional escalation |
| Pipeline-with-Backpressure | bounded queue between nodes |
Anti-patterns to avoid
Three configurations that look attractive and fail in production:
- Many-to-many gossip without convergence rules — non-termination guaranteed.
- Reviewer that cannot reject — pattern collapses to single-author with extra cost.
- Devil's advocate on every step — UX kill; users give up.
Where this is heading
Two trends to watch by 2027: a canonical pattern catalogue blessed by the major SDK vendors, and visual editors that compose patterns. Until then, the eight above are the working vocabulary.