Orchestrator-Workers Pattern

An agentic workflow pattern where a central LLM dynamically breaks down a task, delegates subtasks to worker LLMs, and synthesizes their results. One of five agentic workflow patterns described in Building Effective Agents.

Structure

           Orchestrator LLM
          /    |    |    \
     Worker  Worker Worker Worker
          \    |    |    /
           Synthesized result

The orchestrator analyzes the input, determines what subtasks are needed, dispatches them to workers, and combines the outputs. The critical distinction from parallelization: subtasks are not predefined. The orchestrator decides them at runtime based on the specific input.

When to use

The pattern fits when:

• The number and nature of subtasks can’t be predicted in advance
• The task requires dynamic decomposition based on the input
• Workers can operate on subtasks independently once assigned

The canonical example: coding products that make complex changes across multiple files. Which files need editing and what changes each needs depends entirely on the task description.

Relationship to parallelization

Topologically similar — both fan out work to multiple LLMs. The difference is flexibility:

Aspect	Parallelization	Orchestrator-workers
Subtasks	Predefined	Dynamic
Orchestration	Programmatic	LLM-driven
Fan-out	Fixed	Variable

Parallelization is a workflow; orchestrator-workers is on the boundary between workflow and agent.

Production examples

• Coding agents — analyze task, determine files to edit, delegate each file change to a worker, merge results
• Research tasks — determine what information is needed, dispatch searches to workers, synthesize findings

Connections

• The Managed Agents Architecture is the infrastructure for this pattern at scale — the brain (orchestrator) calls many hands (workers) through execute(name, input) -> string
• Brain-Hands Decoupling formalizes the interface between orchestrator and workers
• CORAL extends this into autonomous multi-agent evolution — agents act as both orchestrators and workers, with shared persistent memory replacing explicit delegation
• Cross-Agent Knowledge Transfer describes what happens when workers can learn from each other’s results, which the basic pattern doesn’t include
• The user’s blog post From Solo Sessions to Agent Orchestras describes the human experience of scaling from a single agent to an orchestrated team — the human becomes the orchestrator