Claude Code is the reference implementation of the pattern, and that is not an overstatement: Anthropic's engineering posts describe it directly as orchestrator-workers, not label it that way after the fact by analogy. The orchestrator's role and the rules of its behavior are set by a CLAUDE.md file at the project root, while the narrow workers sit separately, in the .claude/agents/ directory - one file per subagent, each with its own role and its own set of available tools. The model behind the environment is Claude; Anthropic does not disclose its architecture, and this reference states it only to the extent it is stated officially.
What matters in this environment is not the mere fact of splitting into an orchestrator and workers, but the contract a subagent is bound to follow. It gets a narrow, clean window, sees none of the orchestrator's history, and works only on its own subtask, returning not everything it read and did but a compact summary - on the order of one to two thousand tokens, with file:line references to specific places in the code rather than the full content of files. This discipline is the entire point of the pattern: the orchestrator does not choke on someone else's logs, saves tokens at every step, and, just as important, keeps room to think once the workers have returned, rather than while parsing their output.
The official materials gathered in this section are not an illustration but the primary source of the move itself. Building Effective AI Agents formulates the orchestrator-workers pattern as such, Multi-agent research system shows it at work in a real multi-agent system, Effective context engineering explains why context discipline matters more than the sheer amount of available information, and the material on the Claude Agent SDK and Agent Skills shows how these principles carry over into code and into reusable skills.
The practical part of this section is a meta-prompt that configures the project by itself, without manually assembling a config from scratch. The agent reads the listed Anthropic articles on its own, then assembles or updates CLAUDE.md with the orchestrator role, agent-selection rules and an explicit input-output contract, including stop conditions such as a cap on the number of passes. It then sets up explorer, planner, builder and reviewer subagents as separate files in .claude/agents/ and wires them into a pipeline where each next step gets the compressed result of the previous one, not its entire context.
Before this setup writes anything to disk, it is required to show the plan and wait for confirmation - that too is part of the contract, not an optional courtesy. In practice this means the project owner sees which subagents are being set up and with which roles before the files appear in the repository, and can adjust the composition of the pipeline to their own specifics before anything is locked into the config.
Read these Anthropic articles:
- anthropic.com/engineering/building-effective-agents
- anthropic.com/engineering/multi-agent-research-system
- anthropic.com/engineering/effective-context-engineering-for-ai-agents
Set up THIS project for "orchestrator + subagents":
1. Create/update CLAUDE.md: role - orchestrator; agent-selection
rules; subagent I/O contract (1-2k summary + file:line, not a
dump); stop conditions (max 2 passes).
2. Add .claude/agents/*.md subagents: explorer, planner,
builder, reviewer - narrow roles, their own tools.
3. Pipeline: explorer -> planner -> builder -> review.
4. Balance quality vs token economy: narrow context,
summaries instead of dumps, no extra passes.
Show the plan BEFORE writing and wait for "ok".