Orchestration Patterns

How It Works

A coordinator splits a task into independent subtasks and dispatches them to worker agents simultaneously. Each worker processes its subtask independently. When all workers complete, results are collected and merged into a unified response.

Diagram

         ┌─ Worker 1 ─┐
Task ──► │  Worker 2  │ ──► Merge
         └─ Worker N ─┘

Best For

Tradeoffs

High throughput but no inter-agent communication during execution. Workers cannot share context or build on each other's results. Resource usage scales linearly with worker count.

Example

Analyze 20 GitHub repos in parallel — each worker clones and reviews one repo, then results merge into a comparison report.

How It Works

Agents are arranged in a chain. Agent 1 produces output that becomes Agent 2's input, and so on. Each agent specializes in one transformation step. The final agent produces the end result.

Diagram

Task ──► Agent 1 ──► Agent 2 ──► Agent 3 ──► Result
         research     draft       edit

Best For

Tradeoffs

Clear separation of concerns and predictable flow, but total latency is the sum of all stages. A failure at any stage blocks downstream agents.

Example

Content pipeline: Researcher agent gathers sources, Writer agent drafts the article, Editor agent polishes prose and checks facts.

How It Works

The supervisor receives a task, breaks it down, and routes subtasks to the most appropriate specialist agents. It reviews each specialist's output, may request revisions, and compiles the final deliverable.

Diagram

              ┌─ Coder ──────┐
Task ──► Supervisor ─┼─ Researcher ─┼──► Result
              └─ Tester ─────┘

Best For

Tradeoffs

Flexible and adaptive, but the supervisor is a single point of failure. Quality depends heavily on the supervisor's ability to decompose tasks and evaluate results.

Example

Build a feature: Supervisor assigns research to Researcher, implementation to Coder, and validation to Tester, then reviews and merges all outputs.

How It Works

Input is split into chunks. The map phase sends each chunk to a worker agent for parallel processing. The reduce phase takes all mapped outputs and synthesizes them into a single coherent result, resolving conflicts and extracting patterns.

Diagram

         ┌─ Map 1 ─┐
Input ──►│  Map 2  │──► Reduce ──► Result
         └─ Map N ─┘

Best For

Tradeoffs

Excellent for large inputs but the reduce step can become a bottleneck. Requires that the task be decomposable into independent chunks.

Example

Summarize a 200-page document: Map agents summarize 10-page chunks in parallel, then a Reduce agent synthesizes chunk summaries into a coherent executive summary.

How It Works

Proposer agents independently generate solutions to the same problem. A critic agent reviews all proposals, identifies strengths and weaknesses, and either selects the best one or synthesizes a superior solution from the best elements of each.

Diagram

┌─ Proposer A ─┐
│  Proposer B  │──► Critic ──► Best Solution
└─ Proposer C ─┘

Best For

Tradeoffs

Produces higher-quality outputs through adversarial evaluation, but uses 3-5x more tokens than a single agent. Not suitable for straightforward tasks.

Example

Architecture decision: Three agents propose different database designs (SQL, NoSQL, graph), then a Critic evaluates each against requirements and picks the winner.

How It Works

A top-level supervisor breaks a large objective into domains. Each domain is assigned to a mid-level supervisor who further decomposes it into tasks for worker agents. Results flow back up the tree, with each level aggregating and quality-checking.

Diagram

            Director
           ┌───┴───┐
       Manager A  Manager B
       ┌──┴──┐   ┌──┴──┐
      W1   W2   W3   W4

Best For

Tradeoffs

Scales to many agents and complex projects, but introduces coordination overhead and latency from multiple management layers. Harder to debug when things go wrong.

Example

Build a full-stack app: Director delegates frontend to Manager A (with UI and CSS workers) and backend to Manager B (with API and DB workers).

How It Works

The router agent receives a task, classifies its type or domain, and forwards it to the matching specialist. Each specialist handles only the task types it excels at. This ensures optimal agent selection without wasting tokens on mismatched capabilities.

Diagram

           ┌─ Code Agent
Task ──► Router ─┼─ Writing Agent
           └─ Research Agent

Best For

Tradeoffs

Efficient routing reduces cost and improves quality, but accuracy depends on the classifier. Misrouted tasks can produce poor results. Adding new task types requires updating the router.

Example

Customer support: Router classifies tickets as billing, technical, or account issues, then routes each to the specialist agent with the right tools and knowledge.

How It Works

The generator agent produces an initial output. A critic agent (or the generator in self-critique mode) evaluates the output against quality criteria and provides specific feedback. The generator revises based on feedback. This loop repeats until the output meets the quality bar or a max iteration count is reached.

Diagram

Task ──► Generator ──► Critic ──┐
              ▲                  │
              └── Revise ◄───────┘

Best For

Tradeoffs

Produces noticeably higher quality output, but each iteration adds latency and token cost. Requires well-defined quality criteria to avoid infinite loops.

Example

Code generation: Generator writes a function, Critic reviews for bugs and edge cases, Generator revises until all tests pass and code review criteria are met.

How It Works

N agents receive the same task and work on it independently with no communication. Each produces a complete solution. A mediator agent then reviews all solutions, scores them against criteria, and either selects the strongest one or synthesizes a superior answer by combining the best elements from each.

Diagram

         ┌─ Agent 1 ─┐
Task ──► │  Agent 2  │ ──► Mediator ──► Best Solution
         └─ Agent N ─┘

Best For

Tradeoffs

Dramatically improves output quality through redundancy, but multiplies token cost by the number of agents. The mediator must be capable enough to judge solution quality accurately.

Example

Code review: Three agents independently review a pull request for bugs, security issues, and performance. A mediator synthesizes findings into a single review with deduplicated, prioritized feedback.

How It Works

A shared data store (the blackboard) holds the current problem state and partial solutions. Specialist agents monitor the blackboard and activate when they detect something they can contribute to. Each agent reads the current state, adds its partial solution, and writes back. A controller checks completion criteria after each update.

Diagram

Agent A ──►┌─────────────┐◄── Agent C
            │ Blackboard  │
Agent B ──►│  (shared     │◄── Agent D
            │   state)    │
            └──────┬──────┘
                   ▼
                Result

Best For

Tradeoffs

Highly flexible and supports emergent problem solving, but requires careful state management. Agents may conflict or overwrite each other's contributions. Harder to predict execution order and debug.

Example

Research synthesis: A blackboard holds a research question. An evidence-gathering agent adds sources, an analysis agent identifies patterns, a critique agent flags contradictions, and a writing agent drafts conclusions - all reading and writing to the shared board.

How It Works

The primary agent generates output as normal. Before the output is delivered, a guardrail agent intercepts and evaluates it against safety rules, quality standards, or business constraints. If the output passes, it goes through. If it fails, the guardrail either blocks it, requests a revision, or modifies it directly.

Diagram

Task ──► Primary Agent ──► Guardrail ──► Output
                            │
                      [block/revise]
                            │
                            ▼
                        Rejected

Best For

Tradeoffs

Adds a reliable safety layer with minimal complexity, but introduces latency for every output. The guardrail agent must be fast and accurate - false positives block good output, false negatives defeat the purpose.

Example

Code generation: A coding agent writes functions while a guardrail agent checks every output for SQL injection, hardcoded secrets, and unsafe dependencies before the code reaches the user.

How It Works

One agent receives a task and has access to a registry of tools (via MCP, function calling, or plugin systems). It plans a sequence of tool calls, executes them, observes results, and iterates until the task is complete. The agent decides which tools to use, in what order, and how to combine their outputs.

Diagram

            ┌─ MCP Server
            ├─ API
Agent ──────┼─ File System
            ├─ Database
            └─ Browser
               ▼
            Result

Best For

Tradeoffs

Simple architecture with no coordination overhead, but limited by the agent's ability to plan and use tools correctly. Performance ceiling is bounded by a single model's reasoning capacity.

Example

Developer workflow: Claude Code reads files, runs tests, searches codebases, executes shell commands, and calls APIs - all through tool use from a single agent managing the entire task.