In the orchestrator-workers pattern, one model plans and other model calls carry out the plan.
How it works#
- Plan. The orchestrator receives the task and breaks it into a list of sub-tasks.
- Work. Each worker receives one sub-task and carries it out. Workers often run in parallel.
- Synthesize. The orchestrator takes all the worker results and writes the final answer.
Example: a competitive analysis of five companies. The orchestrator splits it into five sub-tasks, one per company. Five workers run in parallel, each researching one company. The orchestrator reads the five results and writes the final comparison.
How it differs from chaining#
| Prompt chaining | Orchestrator-workers | |
|---|---|---|
| Who decides the steps | Your code, ahead of time | The orchestrator model, at runtime |
| Flexibility | Low: the same steps every time | High: the plan fits each task |
| Predictability | High | Lower: the plan depends on what the orchestrator decides |
Your code still runs the pipeline: plan, work, synthesize. Only the list of sub-tasks comes from the model.
Three failure modes#
| Failure | What happens |
|---|---|
| Wrong plan | The orchestrator splits the task badly, and every worker inherits the mistake. |
| Silent worker failure | A worker returns a weak or empty result, and the orchestrator synthesizes from it anyway. |
| Lossy synthesis | The final answer drops details that were in the worker outputs. |
The fix: check every handoff#
- Check the plan before you dispatch any workers. Is each sub-task clear? Is anything missing or duplicated?
- Check each worker result before it goes to synthesis. Retry or flag a weak result instead of passing it on.
Short line#
In orchestrator-workers, one model breaks the task into sub-tasks at runtime, workers run them, and the orchestrator combines the results. It is more flexible than chaining but less predictable, so check the plan before dispatch and each worker result before synthesis.
Key takeaways#
- The orchestrator plans, workers execute, and the orchestrator synthesizes.
- In chaining your code decides the steps. Here the orchestrator decides them at runtime.
- More flexible, less predictable.
- Failure modes: a wrong plan, silent worker failures, and synthesis that loses details.
- Validate at each handoff: the plan before dispatch, each result before synthesis.