orchestrator

Orchestrator

The main thread is the only orchestrator — it alone holds the Agent tool. Subagents do the work; they do not spawn their own subagents (Claude Code discourages nested delegation, and it bloats context). This skill makes the main thread good at delegating: it decides what to hand off, to which agent, on which model tier, and how to keep its own context lean so a long task does not drown in tool output.

Trigger phrases: orchestrate this, delegate this, break this down, coordinate subagents, fan this out, this is a big/multi-step task.

The core loop

1. Scope inline first. Cheap discovery the main thread should just do: list the files, find the entry points, read the one file you already know. Don't delegate a single-fact lookup.
2. Decompose. Split the task into independent units of work. Independent units run in parallel; dependent ones pipeline.
3. Delegate the heavy work. Each unit goes to a subagent with a tight prompt and a clear return contract ("return a file:line table", "return the verdict + why", "return a 5-line summary").
4. Synthesize. The main thread holds the conclusions, decides the next step, and edits when the work is trivial and single-file.

Delegate vs do inline

Delegate to a subagent	Do inline (main thread)
Broad/fan-out search across many files or naming conventions	A read of a file you already know
Reading many files to answer one question	A single-fact grep where you know the symbol
Independent work that can run in parallel	A trivial single-file edit
Review / audit of a diff or subsystem	Final synthesis + the decision
Anything that returns a lot of bytes you only need the conclusion of	Anything where delegation overhead > the work

Rule of thumb: if the answer means reading across several files and you only need the conclusion, delegate it and keep the conclusion, not the file dumps. Once delegated, don't also run it yourself — wait for the result.

Which agent for which job

• toolu:deep-explore — structural/architecture exploration via ast-grep (runs on Sonnet). First choice for "where/how is X done across the code".
• Explore — broad read-only fan-out search when you need the conclusion, not file dumps.
• Plan — design an implementation strategy for a non-trivial change.
• general-purpose — multi-step research/execution that doesn't fit a specific agent.
• caveman:cavecrew-investigator / -builder / -reviewer — when the caveman plugin is installed: compressed-output locate / bounded 1–2 file edit / diff review. Output is ~60% smaller, so main context lasts longer.

Carry the session mandates into every subagent prompt (comemory recall/save, ast-grep first). Delegation never exempts the work.

Parallelize independent work

Launch independent subagents in one message with multiple tool calls so they run concurrently — not one-at-a-time. Dependent steps wait; independent steps don't. A four-way independent search done serially wastes three-quarters of the wall-clock.

Keep main context lean

The expensive, recurring cost in a long session is input tokens re-sent every turn (see the token-efficiency report). Two rules follow:

• Return conclusions, not bytes. A subagent may read 50k tokens but should return a 1–2k-token distilled answer. The detailed context stays isolated in the subagent and never re-enters — or re-caches into — the main thread.
• Prefer compact return formats (tables, file:line lists) over prose dumps.

Model tiers

Match the model to the job (the convention deep-explore follows):

• Haiku — mechanical / lookup / formatting.
• Sonnet — read-only exploration and standard edits (the bulk of delegated work).
• Frontier (inherit) — only agents that must do deep reasoning or synthesis.

Routing the bulk of work to Sonnet keeps the expensive frontier model for the lead thread's hard reasoning — large cost cut at near-full quality.

Fan-out budget guardrail

Subagents multiply token spend (multi-agent runs can cost ~15× a single thread; unmanaged fan-out has produced four- and five-figure single-session bills). Before a large fan-out: cap the number of parallel agents to what the task needs, give each a tight scope, and prefer one well-scoped sweep over a runaway loop. If you bound coverage (top-N, sampling), say so — don't let "covered everything" hide a silent cap.