Claude Code subagents without the drift: one orchestrator, cheap lanes, verify on disk

Be careful running subagents

The failure mode isn't the subagent itself. It's a fan out with no model set on any of the workers. Every subagent you spawn with no explicit model field quietly inherits the model of the session that spawned it, and if that session is running your most expensive model, so is every worker.

Ten workers on the wrong tier for a task that only needed a cheap one burns a real share of your budget in one pass, and nothing warns you while it's happening. You find out after, checking usage, wondering where it went.

Drift shows up the same way scope creep does anywhere else. A worker spawned to do one narrow thing starts spawning its own sub-workers to handle something adjacent, and now nobody upstream can tell you what actually ran or why.

What's your best way to use subagents?

One orchestrator, cheap lanes underneath it, and a hard rule about who spawns what.

The orchestrator holds the premium model. It understands the goal, plans, decomposes the work, and makes the calls that need judgment: architecture decisions, tradeoffs, arbitrating between two conflicting results. It doesn't spend that reasoning on work a cheap model can do correctly.

Workers sit under it, and workers never orchestrate. A worker that starts spawning its own sub-workers has taken on a job it wasn't given, and the orchestrator loses the ability to judge what actually happened.

The rule that keeps the budget honest is simple. Set the model explicitly on every worker, every time, especially the cheap high volume ones. Searches, bulk file reads, routine edits, and summarization go on sonnet or haiku, named directly in the call.

Never leave a worker's model unset and assume it'll do the sensible thing. It won't. It inherits.

Reaching an external CLI: thin wrapper subagents

Here's the part that catches people. A Claude Code subagent is always a Claude model, and the model field only picks among your own tiers: sonnet, opus, haiku.

It cannot make a subagent become a different vendor's model.

To actually reach an external CLI, a coding tool, a research tool, from inside an orchestration script, you need a subagent whose entire job is one shell call to that CLI, returning its output verbatim. Keep the wrapper itself on your cheapest tier.

The real reasoning bills to the external plan. The wrapper only costs you the price of one small round trip.

This is also the only way to reach an external CLI from inside a Workflow script, since a workflow script has no shell or filesystem access of its own.

Here's the actual codex-lane wrapper from The Operator Kit for Claude Code, unedited:

---
name: codex-lane
description: Forward a reasoning-heavy or implementation task to the Codex CLI (gpt-5.6-sol) and return its output. The preferred non-Claude reasoning lane for hard debugging, architecture alternatives, algorithm design, and independent second implementations.
model: haiku
tools: Bash
---

You are a thin forwarding wrapper around the Codex CLI. You do no reasoning of your own.

Run exactly ONE Bash call, then return its stdout verbatim:

```
timeout 1800 codex exec --cd <ABS_DIR> --sandbox workspace-write --ignore-user-config \
  --model gpt-5.6-sol -c model_reasoning_effort=high "<the task>"
```

Rules:
- `<ABS_DIR>` is the absolute path the caller named. If the caller named no directory, do
  NOT guess. Return exactly: `codex-lane needs an absolute target directory`.
- `--ignore-user-config` skips the config default model. So `--model gpt-5.6-sol` and
  `-c model_reasoning_effort=<level>` must ALWAYS be passed explicitly. Never drop them.
- Use `--sandbox read-only` plus `--skip-git-repo-check` when the caller wants analysis,
  review, or diagnosis with no edits.
- Lower `model_reasoning_effort` to `low` or `medium` only when the caller asks for speed.
- Never call a different codex wrapper or helper script for this job. Run the Codex CLI
  directly, in the caller's working directory. A wrong working directory wastes context
  and edits the wrong tree.
- Do not read files, grep, edit anything, or add commentary. Return stdout only.

Notice what it doesn't do. It doesn't read files, doesn't grep, doesn't add commentary. One call, one return.

The kit ships four of these, one each for a reasoning CLI, a mechanical refactor CLI, a research CLI, and a data lane. The pattern's the same across all of them.

A Workflow snippet with the model set explicit

A Workflow script fans out subagents from code rather than one at a time. The kit's example reviews the diff on sonnet, one agent per dimension, then verifies each finding with a read-only Explore agent before it counts. Here's the shape, cut down from the kit file:

const reviewed = await pipeline(
  DIMENSIONS,
  (dim) =>
    agent(dim.prompt, {
      label: dim.name,
      phase: 'Review',
      model: 'sonnet',
      schema: FINDINGS_SCHEMA,
    }),
)

const verdicts = await parallel(
  allFindings.map((f) => () =>
    agent(`A reviewer flagged this in ${f.file}: "${f.issue}". Read the real file and confirm it.`, {
      label: `verify: ${f.file}`,
      phase: 'Verify',
      model: 'sonnet',
      agentType: 'Explore',
      schema: VERDICT_SCHEMA,
    }),
  ),
)

Every agent() call names model: 'sonnet' directly. Nothing here is left to inherit. The last step hands the confirmed list to codex-lane for a second opinion from a different vendor's model.

Never trust a subagent's self-report

A worker reporting "done, file updated" is a claim, not a fact. It reads like evidence because it's confident and specific, and that's exactly why it's worth checking anyway.

After any delegated edit, diff the repo or read the file yourself. After any delegated verification, re-run the check yourself.

This is why the snippet above runs a second pass per finding instead of trusting the first one. The orchestrator verifies on disk, and the worker's report is only the start of that check, not the end of it.

Get the kit

The four wrapper subagents, the delegation rules behind them, and the Workflow example ship in The Operator Kit for Claude Code, $49 one time. See the six skills in the kit and three hooks worth running for the rest of the setup.

Buy the kit, $49

For the full subagent configuration format, see Anthropic's subagents reference.

Independent product. Not affiliated with or endorsed by Anthropic.