Multi-model delegation in Claude Code

I run Claude Code as a daily driver on top-tier models, Opus and more recently Fable 5. The itch started small. Every session, regardless of which model was in the driver's seat, defaulted to doing everything itself: reading files, grepping the codebase, writing the diff, reviewing the diff, all in the same context, at the same expensive model tier. Gathering context is the cheapest step in that list and it was running on the most expensive model I had. I wanted the opposite default, where cheap models gather and extract, a mid-tier model executes, and the top-tier model orchestrates and judges with fresh eyes rather than the context it just wrote itself into.

Stating that once in CLAUDE.md wasn't enough. I'd write the delegation rule, see it work for a session or two, and then watch the next session quietly drift back to solo mode. Read the file, edit the file, done, no subagent in sight.

Memory competes with harness defaults

A single line of memory loses to a harness's actual defaults over time, and the reason is structural. CLAUDE.md is content the model reads at its own discretion; the harness never checks whether the model acted on it, so nothing stops the model from reading the instruction and still reaching for Read/Edit directly. Harness defaults pull the same way. The fastest path to an answer is to do the thing in the main session, and fanning out to a subagent is extra ceremony that has to be deliberately chosen every turn.

The escape hatch I'd first written made it worse. "Skip delegation if the task is trivial" was self-judged, and self-judgment leaks, because almost anything can be rationalized as trivial in the moment it's being done. A single-shot instruction also loses salience the deeper a session gets. That's the failure mode I kept hitting with CLAUDE.md: read once, early, then outweighed by everything that landed in context after it.

Four tiers, one routing rule

The rule I landed on has four seats. Haiku extracts and researches, Sonnet executes, distills, and validates, Opus reviews with fresh context, and the session model, Opus or Fable, orchestrates and synthesizes. Model names are floors rather than ceilings; a task that needs more than Haiku can reliably do moves up a tier instead of staying pinned to the cheap model out of habit.

Checking the claim against Anthropic's numbers

I didn't want this to just be a vibe, so I went looking for Anthropic's own numbers on multi-agent setups. Their multi-agent research system write-up is the strongest data point. An Opus-led orchestrator with Sonnet subagents beat a single Opus instance working solo by 90.2% on research-shaped tasks, at roughly 15x the token cost of a normal chat interaction, and their own analysis found token usage alone explains about 80% of the variance in performance. Splitting work across models isn't a token-saving move; it's a quality move that happens to cost more.

Their subagent guidance for Claude Code gets more concrete about when the split pays off, naming two countable thresholds: roughly 10+ files touched, or 3+ independent pieces of work. Below that, a different post on building multi-agent systems argues for the opposite bias, starting with the simplest approach that works and keeping sequential, single-file changes inline. Those two numbers are what I encoded in the first layer below.

Layering CLAUDE.md, a hook, and the plugin

Getting from a rule I believed to a rule that survives a long session took three layers, each catching what the one above it missed.

Layer 1: bright-line triggers in CLAUDE.md

I rewrote the trivial-task exemption to remove the self-judgment. Instead of "skip delegation if it's trivial," the rule now names the countable triggers directly. Fan out when a task has three or more independent pieces of work, touches ten or more files, needs multi-source research, or calls for reviewing nontrivial work. It stays inline only when none of those hold, so sequential dependent steps, edits confined to one or two known files, and single-tool-call lookups all stay in the main session.

Layer 2: a per-prompt reminder hook

Bright lines still fade if they're only stated once at the top of a session. The fix was a UserPromptSubmit hook that echoes a one-line routing reminder back into context on every prompt rather than once per session:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo 'pe-routing: default to fan-out — Haiku researches, Sonnet executes, Opus reviews, session model orchestrates. Triggers: 3+ independent pieces OR 10+ files OR multi-source research OR review of nontrivial work. Inline only for sequential single-file work or one-call lookups.'"
          }
        ]
      }
    ]
  }
}

The hook only reprints the rule; it blocks nothing, and I stopped short of a PreToolUse hook that would deny a Read outright on the grounds that a subagent should have done it.

Layer 3: plugin-level encoding

The most durable layer doesn't rely on the model reading anything at all, because it pins the behavior into the skills themselves. An orchestrator skill pins opus at xhigh effort. An executor skill pins sonnet. Review skills pin high/xhigh effort so a reviewer isn't skimming, and mechanical, extraction-shaped skills pin low effort on a cheap model, because that's all the step needs. This ships as a plugin other people use. So the layer 2 hook is opt-in via a template rather than forced on everyone.

Effort as the second dial

Model tier and effort level (low through max, though my pins top out at xhigh) are two separate knobs, and it's worth not confusing them. Judge seats, orchestration and review, run high or xhigh effort regardless of which model is doing the judging. Mechanical seats run low effort even on a capable model, because the task doesn't need the extra reasoning budget. Effort controls how long a model thinks about a step; tier caps what it can reliably produce no matter how much effort it's given. Bumping a Haiku seat to xhigh buys longer deliberation within Haiku's own ceiling, and I've had to catch myself reaching for that bump as a substitute for a tier upgrade on work that actually needed judgment.

Was it worth it

The honest number is 3-10x more tokens than working solo, and that's by design. Anthropic's own research system numbers said as much going in, at 15x for the setup they benchmarked. The quality gain is real and it is not free. What I don't have yet is a long enough track record on my own sessions to say the trade holds beyond the research-shaped tasks Anthropic measured. So the next thing I'm tracking is token rollups across my own sessions, over enough weeks to put a number next to theirs.