Orchestrate

---
description: "Arm the current session for an orchestration-heavy task with seven standing imperatives (delegate and fan out, spec every spawn, fresh-context verify, run workers well, nested subagents, surface drift, calibrate to conditions); optionally export them as a brief for a worker. Use when: 'orchestrate', 'orchestration brief', 'prime this session', 'arm for orchestration', 'about to do heavy delegation', 'worker spawn prompt', 'delegation preamble'."
argument-hint: "[<task>|handoff [compact]|worker [compact]]"
user-invocable: true
disable-model-invocation: false
metadata:
  workflow-stage: session
  summary: Arm the session with proactive-orchestration imperatives
---

## Purpose

Invoking this skill **arms the current session** for an orchestration-heavy task: it loads the
expanded seven-imperative operational form into active working context, and it declares deliberate
intent to orchestrate the work about to start, so the triggers get evaluated actively rather than
sitting passively in background rules. That is the default: no paste, no rails, just preloaded
context.

The same imperatives also **export** as a self-contained, paste-ready brief for targets that LEAVE
the session and therefore inherit none of its context: a spawned subagent/teammate, a fresh session
you will `/clear` into, or a non-Claude-Code tool. Export is model- and tool-agnostic by
construction. Nothing in the pasted text depends on a specific model, env var, or repo file.

Pointers behind each imperative: `context/sources.md`; observed failure modes:
`context/gotchas.md`. Read gotchas before authoring a nested tree or trusting a worker's return.

## Actions

| Action | What it does |
|---|---|
| *(default. Optional `<task>`)* | **Prime THIS session.** The standing instructions below are now active for the upcoming task; respond with a terse acknowledgment and, if `<task>` is given, one line orienting to it. Do NOT re-emit the imperatives. Loading them IS the priming. |
| `handoff [compact]` | **Export** the imperatives as a paste-ready dashed-rail brief framed for a fresh session. `compact` = headlines only. |
| `worker [compact]` | **Export** framed for a spawned worker (prepends the did-not-inherit-context line). `compact` = headlines only. |

## Orchestration imperatives. Standing instructions

At each decision boundary in this task, evaluate these and ACT on a match without waiting to be
told:

1. DELEGATE / FAN OUT. Start with one agent; delegate only when work would flood context, fans
   across genuinely independent paths, or needs a tool-restricted specialist. Decompose by what
   CONTEXT each piece needs, not by head-count or work-type. Sequential or shared-context steps stay
   in one agent, and one feature is never split across agents. Our operating figure for a fan-out
   is 3–10× one agent's tokens (returns cost context too), and it is a floor: budget a
   research-shaped fan-out above it. Spend it on value + parallelism, not convenience. Pointer: for
   multi-agent token cost, see <https://code.claude.com/docs/en/costs#agent-team-token-costs>; no
   docs page covers research fan-out sizing as of 2026-10-01 (correlate with
   <https://www.anthropic.com/engineering/multi-agent-research-system>). As of: 2026-10-01.
   Recheck trigger: that section moves or starts stating its own multiplier, or a docs page starts
   covering fan-out sizing.
   "Would flood context" is a measurement, not a hunch, when the instrument exists: with the
   `context-guard` plugin enabled, resolve this session's zone word per its reader contract
   before a fan-out decision
   (the contract owns the snapshot path, staleness rule, and bands. Read them there; this
   imperative consumes only the word, no band values). Never estimate your own remaining window,
   that guess is the failure the seam replaces. A degraded or `unknown` zone shifts the balance
   toward delegating context-heavy legs and shrinking what returns; a healthy zone is license to
   keep sequential, shared-context work inline.
2. SPEC EVERY SPAWN. Every brief states why the work is wanted, what done looks like, when to
   stop and ask, and a deliberately chosen model tier, on top of the brief elements the
   multi-agent post lists. Pointer: [Give the reason, not only the request](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5#give-the-reason-not-only-the-request);
   correlate with <https://www.anthropic.com/engineering/multi-agent-research-system> for the
   brief elements, which no docs page covers as of 2026-10-01. Recheck trigger: a docs page
   starts covering brief contents. Absent a consumer-level subagent-model override,
   an unspecified model silently inherits the parent session's, often its most expensive, model.
   Holding only an objective, a worker resolves each ambiguity toward the sentence you wrote rather
   than the outcome you wanted, and returns something well-formed and wrong.
3. FRESH-CONTEXT VERIFY, after an edit batch or a finding set, hand it to a SEPARATE verifier;
   never self-audit in the context that produced it. Give the verifier concrete pass/fail criteria
   ("run the full suite, report all failures"), scope it to correctness/requirements (not style),
   and judge the final STATE, not the process, an uncriteriaed verifier just rubber-stamps. When
   the verdict is high-stakes, prefer a different-vendor advisor when one is set up and able to
   judge this artifact, its blind spots are uncorrelated with yours, with the fresh-context
   same-vendor verifier as the fallback. Scope it to what ships: a process record about the work
   (ledger, checklist, status log) is not the work and gets no verifier, however many of them a
   batch touched, and a record OF a verification is never itself verified, that loop feeds itself.
4. RUN WORKERS WELL. Dispatch without blocking, and keep a worker across subtasks where the
   runtime allows; watch each worker and step in when it drifts. Pointer:
   [Parallel subagents](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5#parallel-subagents).
   As of: 2026-10-01. Recheck trigger: that section changes its dispatch or reuse guidance. A worker that
   must wait on an external result polls it in the foreground with a bounded loop, or returns what
   it has and lets the parent re-dispatch. A background command or watch the worker started is not
   a wait: the runtime may stop it when the worker returns, a watch expires at its deadline, and no
   sentinel file appears unless something the worker launched writes it. The runtime may also leave
   it running: a hung background shell has been observed to keep a worker that already reported
   listed as active (`context/sources.md`, "A worker's own background work is not a wait"). So
   retiring a finished worker includes checking for its still-running background tasks and
   surfacing each one; stopping one is gated like any kill (`/session-flow:reconcile` step 3).
5. NESTED SUBAGENTS, a worker may spawn its own workers when a delegated task itself subdivides
   AND the depth is non-load-bearing. This is a shipped feature, not experimental, but reliability
   degrades with depth and platforms cap it, so never author a tree that needs a specific or deep
   nesting level.
6. SURFACE DRIFT, the moment you notice a stale reference, broken citation, or convention
   conflict adjacent to your task, flag it in one line; don't fix it silently, don't deep-dive.
7. CALIBRATE TO CONDITIONS. Size the whole orchestration (whether to delegate at all, fan-out
   width, nesting depth) to the conditions in play, never a fixed recipe: the active model's
   capability (a stronger model reaches further single-agent; a weaker one needs more decomposition
   and tighter specs), whether a capable advisor/verifier is on hand, current context pressure
   (delegate to protect a filling window; stay inline when it is roomy), and concurrent-session load
   / rate-limit headroom (thin headroom caps how many workers you run at once). **When rate-limit
   headroom is unobservable**, the `rate-limit-guard` tee is absent, stale, or missing
   `rate_limits`, which is the expected state in cloud / remote sessions with no statusline
   producer (see rate-limit-guard's reader-contract, "Cloud / remote sessions"). Treat
   headroom as **thin by default**: pick a small conservative concurrent-worker cap, prefer short
   waves over a wide tree, and do not invent window percentages. Scale further down on this
   session's own rate-limit errors or on live sibling-automation 429s already visible to the
   session (for example review-lane infra comments classifying `api_error_status: 429`); scale
   back up only after those reactive signals stop, never on a guessed recovery. Sizing is
   small/medium/large, a small ask stays single-agent, a medium one fans out a few, only a large
   genuinely-independent surface earns a wide or nested tree. Single-agent is the floor, not the
   fallback. Per-worker tier is part of sizing and scales with fan-out width: past a wide fan-out
   the cheaper tier becomes the DEFAULT the whole fleet inherits, volume multiplies every notch
   of over-provisioning, and the standing exception is an explicitly hard stage (verify,
   judge/adjudicate, judgment-heavy synthesis), which keeps the parent tier. Tier is not only the
   model: match the reasoning depth (effort) to the subtask too, not the parent session,
   high-volume mechanical work (search, extraction, per-item transforms, formatting) runs cheaper
   on both. Work that changes code, verifies a change, or is likely to hit edge cases is excluded
   from the lower effort: pick its level from model-config's effort table
   (<https://code.claude.com/docs/en/model-config#choose-an-effort-level>, as of 2026-10-02;
   recheck when that section is renamed or moved or its table columns change), never below
   medium. A premium fan-out outside the hard stages is a per-stage decision to justify
   explicitly, never a default to inherit.

Discipline: trigger-evaluation is mandatory; the ACTION stays calibrated (delegate on value +
parallelism, not convenience). Treat every worker's return as unverified synthesis: check its
evidence before accepting it, verify load-bearing claims against a primary source before acting,
and merge a many-item fan-out into one table (item, verdict, evidence). Cite sources you actually fetched;
never label a claim "known" / "from memory" / "obvious".

**Priming addendum (current session only).** As the main session, not a spawned non-fork worker,
you may also reach orchestration surfaces a non-fork worker cannot: agent teams (driven from the
lead session; the docs do not state whether a fork of the lead can drive one) and dynamic workflows
(withheld from non-fork workers). This session's reasoning effort is `${CLAUDE_EFFORT}`, if that value reads as a literal
placeholder, this body was read directly rather than skill-loaded, so the substitution never ran:
resolve the session's effort yourself before using it. Feed the value
into imperative 7's tier calibration: we treat it as the effort every spawn runs at unless its
agent definition sets its own, so its gap from what a subtask needs IS the over-provisioning
imperative 7 exists to stop. Never read ultracode from this value. Pointer: for the subagent
`effort` field, see <https://code.claude.com/docs/en/sub-agents#supported-frontmatter-fields>; for
how ultracode relates to effort, see
<https://code.claude.com/docs/en/model-config#adjust-effort-level>. As of: 2026-10-01. Recheck
trigger: either section moves or changes how a subagent's effort or ultracode is set. Where a
`SendMessage` tool resolves in this session, run imperative 4's worker reuse and mid-flight
intervention through it, addressed by the worker's agent ID. Never re-invoke the dispatch tool to
continue a worker: that starts a second, independent worker. Read a refused message as a worker
the user stopped. Pointers, as-of date and the empirical probe: `context/sources.md`, "SendMessage
worker continuation".
To choose between a workflow and subagents, and the model and effort each spawn gets, run
`/multi-agent:assess` and `/multi-agent:route` when they resolve in this session; otherwise read
<https://code.claude.com/docs/en/sub-agents#choose-a-model> (as of 2026-10-02; recheck when that
section changes how a subagent's model is chosen; record: `context/sources.md`, "Priming addendum:
model and effort routing").
Export modes omit this addendum, a
pasted target reaches none of those surfaces, and the substitution would travel as dead text.

## Tiered delegation, the shape of a deep tree

Imperative 5 says a worker may spawn workers and imperative 7 says size the tree to conditions.
This section is the shape those two imply once a task is large enough to need more than one layer.
It is guidance for the main session; the export brief omits it, because a pasted worker sits inside
a tree rather than authoring one.

**A rough anchor for small/medium/large.** Imperative 7's sizing is non-numeric, which leaves it
rationalizable either way. Not thresholds to enforce, the judgment still runs on context
boundaries, not head-count, but our anchor follows the platform's workflow size settings: fewer
than 5 agents is small, 5 to 9 medium, 10 or more large, and a run large enough to trip the
platform's large-workflow warning is a size to justify out loud. An order-of-magnitude
disagreement with this anchor is one to name, not skip. Before a workflow run, read the size
guideline in force for this session: the platform's default differs by plan, and the guideline
the session sets is the one Claude receives, whatever this anchor says.

- **Pointer**: for the workflow size guideline and its defaults, see
  <https://code.claude.com/docs/en/workflows#set-a-size-guideline>; for the large-workflow
  warning, see <https://code.claude.com/docs/en/workflows#cost>.
- **As of**: 2026-10-01
- **Recheck trigger**: that page changes a size-guideline agent count, a default guideline, or the
  threshold its large-workflow warning fires at.

**The top of the tree owns the loop, not the work.** Its context is the scarcest in the run,
everything that enters it stays for the rest of the session. So it holds the objective, the
stopping condition, and the decision about what to spawn next, and it delegates the rest. It keeps
the task list in a file (the plan or checklist the work already has, else one it creates), ticks
each item as its return is verified, and reads that file rather than the scrollback. It keeps going
when a step needs no input, with status notes in the same message as the next action, and stops to
ask only when blocked on the user or before a destructive, hard-to-undo, or outward action. A top
tier that reads findings, weighs them, and asks a follow-up question has converted a fan-out into a
conversation, and the context it was protecting fills anyway.

**Chatter belongs low.** Two workers resolving an ambiguity between themselves costs nothing at the
top. The same exchange routed through the parent costs the parent's window twice and permanently.
Push coordination to the lowest tier that can resolve it, and let each tier return a compressed
verdict rather than its reasoning.

**Spec what crosses a boundary, not just what to do.** Every spawn already needs an objective and
an output format (imperative 2). In a multi-tier tree the output format IS the context-economy
lever: name the identifiers, the verdict, and where the bulky payload was parked, so the tier above
can act without re-reading the work. A return that narrates cannot be summarized after the fact,
it has already been paid for. Our magnitude for "compressed": a worker that explored across tens
of thousands of tokens still aims to return roughly 1,000 to 2,000. Treat it as the shape a return
should aim for, never a budget to spend up to.

- **Pointer**: for a subagent returning a summary in place of its verbose output, see
  <https://code.claude.com/docs/en/sub-agents#isolate-high-volume-operations>
  (correlate with <https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents>).
  No docs page states a return size as of the as-of date.
- **As of**: 2026-09-01
- **Recheck trigger**: a docs page starts stating a subagent return size, or that section moves.

**Workers are ephemeral, and the deeper the tier the shorter the life.** A worker that finishes and
stays alive keeps costing the tier above, notifications, status, re-acknowledgement, for zero
additional output. Retire on completion. When the next grouping needs doing, spawn fresh rather than
reusing a worker whose context now carries the last job. (The exception is imperative 4's long-lived
worker across *related* subtasks, where cache reuse is the point; that is a deliberate trade, not
the default.)

**Treat a clean return as unverified, especially a suspiciously clean one.** An under-specified
worker rarely stalls and asks; it substitutes the nearest plausible interpretation and reports
success. In a fan-out, most workers given a brief missing a resource will locate it and close the
gap, and one will silently audit a different, similar artifact and return a confident,
well-formed, wrong-target result that nothing in its return distinguishes from the others. This
is why imperative 3's fresh-context verify is not optional at depth, and why a return payload
benefits from naming its sources. Provenance is the field that makes a wrong-target answer
detectable from above.

**Never author a tree that needs a specific depth.** The platform's nesting default is
configurable and has changed more than once within weeks, so any number written here is stale by
the time it is read. Agent-tool subagents carry a depth cap and a concurrency cap
(`CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH`, `CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS`); workflow agents
and agent-team teammates carry their own, and workflow concurrency has its own override, so "read
the current values" includes the workflows page whenever the run will use the Workflow tool. Read the current values rather than assuming
them, and design the tree so it degrades to a shallower one instead of failing. Never design a
tree that needs a fork to spawn a fork: that is a shape constraint, not a tunable. Whether a
below-limit fork can parent non-fork children is unconfirmed, so do not treat a fork as a
forbidden intermediate tier either. The version history behind the caps lives in
`context/sources.md`.

- **Pointer**: for the depth cap, see
  <https://code.claude.com/docs/en/sub-agents#let-subagents-spawn-their-own-subagents>; for the
  concurrency cap, see <https://code.claude.com/docs/en/sub-agents#concurrent-subagent-limit>; for
  workflow limits, see <https://code.claude.com/docs/en/workflows#behavior-and-limits>; for forks,
  see <https://code.claude.com/docs/en/sub-agents#how-forks-differ-from-other-subagents>.
- **As of**: 2026-08-15; 2026-10-01 for the workflow concurrency override.
- **Recheck trigger**: a changelog entry touches subagent limits, or `context/sources.md` is
  re-verified.

**Confirm nesting from behavior, not from one page.** The ceiling moves faster than the prose
docs track it, and the docs page and the changelog can lag each other by a release, so a tree
authored from either alone can be wrong in both directions. The cheap check is behavioral: have a
worker of the SAME definition you plan to use as the intermediate tier attempt a trivial nested
spawn and report the outcome. The gate is definition-specific, so another agent type proves
nothing, and holding `Agent` is necessary but not sufficient. Read a refusal: a depth rejection
names depth; a permission refusal (classified pre-launch) does not. Pointers: `context/sources.md`.

## Export modes (handoff / worker). Paste-ready brief

Only for a target that LEAVES the session. Emit the seven imperatives above between two full-width
`─` (U+2500) dashed rails. Top rail, brief, bottom rail, nothing else between them; the
`/clear`/paste instruction or any commentary sits above the top rail or below the bottom rail,
never between (NOT a code fence, the user copies the text between the rails, not fence markers).

Live shape: bare `─` rails, no fence. Shown inside a fence here for display only.

```text
──────────────────────────────────────────────────────────
ORCHESTRATION BRIEF — standing instructions for the whole task, regardless of which model or tool runs you.

At each decision boundary, evaluate these and ACT on a match without waiting to be told:
[the seven numbered imperatives above, verbatim]

Discipline: [the Discipline line above, verbatim]
──────────────────────────────────────────────────────────
```

- `handoff`, the opening line above already fits a fresh session; emit as-is.
- `worker`, insert as the FIRST line between the rails: `You are a spawned worker and did NOT
  inherit the parent session's context or the repo's conditional rules, these instructions are
  your only copy.`
- `compact`. Emit only the seven numbered HEADLINES (`1. DELEGATE / FAN OUT`, `2. SPEC EVERY
  SPAWN`, …) plus the closing Discipline line; drop every sub-clause.

## What this skill does NOT do

- **Default does not emit paste-text.** Priming the current session is a terse acknowledgment,
  the work happens because the imperatives loaded into context, not because anything was printed.
  Use `handoff` / `worker` only when the target LEAVES the session.
- **Not a surface-selection guide.** Which parallel-execution surface to pick (subagents vs nested
  vs teams vs workflows) is a judgment the main session makes against current official docs; the
  export brief deliberately omits agent teams + dynamic workflows because a pasted target cannot
  reach either.
- **Does not delegate, verify, nest, or spawn anything itself**. It arms the session or emits
  instruction text.