Per-Subagent Model Selection: Route the Grunt Work Down, Keep the Judgment Up Top

Claude Code recently gained one of those features that sounds like a footnote and turns out to change how you work: you can now assign a different model to each subagent. Your orchestrating session can run on a strong model while a fleet of helpers — formatters, test runners, doc writers, researchers — runs on cheaper, faster ones.

Done well, this cuts your token bill substantially and speeds up multi-agent runs, because the routine work stops queuing behind expensive reasoning. Done badly, it means your hardest problem gets handed to your weakest model and you spend the savings debugging. This guide is about doing it well: how per-subagent model selection works, a simple mental model for choosing tiers, and configs you can copy.

How per-subagent models work

Subagents live in Markdown files with YAML frontmatter — in .claude/agents/ inside a project, or ~/.claude/agents/ for all projects. (If subagents are new to you, start with our subagents guide and come back.) The frontmatter now accepts a model field alongside name, description, and tools:

---
name: test-runner
description: Runs the test suite and summarizes failures
tools: Bash, Read, Grep
model: haiku
---
Run the relevant tests for the change being discussed.
Report failures with file, line, and a one-line cause.
Do not attempt fixes unless explicitly asked.

You can name a tier like haiku or sonnet, or omit the field entirely — in which case the subagent inherits from the main session. That inheritance is the important default to understand: if you never set anything, every helper you spawn runs on your primary model, at your primary model's price.

A mental model: interns, engineers, architects

The clean way to think about tiers is to ask what happens when the agent is wrong.

• Intern work (cheapest tier): if a mistake is instantly visible and trivially re-runnable, use the cheapest model. Formatting, running test suites and reporting output, renaming across files, generating boilerplate, summarizing logs. The task is mechanical; the transcript is the check.
• Engineer work (middle tier): if a mistake would survive a casual glance but get caught by review or tests, use a mid-tier model. Writing unit tests, drafting documentation, first-pass code review, dependency-update triage, research summaries.
• Architect work (strongest tier): if a mistake would quietly ship — subtle logic, security review, tricky debugging, anything cross-cutting — pay for the strongest model. This includes the orchestrator itself, because routing and synthesis errors poison everything downstream.

Most people discover their agent roster is 70% intern work being billed at architect rates. That is the gap this feature closes.

A starter roster

Three agents cover most workflows. Adapt the prompts to taste:

# .claude/agents/formatter.md      -> model: haiku
# .claude/agents/test-runner.md    -> model: haiku
# .claude/agents/code-reviewer.md  -> model: sonnet (or your main model)

Keep your main session on the strongest model you can afford and let it delegate aggressively. The economics compound: a refactor that spawns five formatting-and-test cycles now runs four of those five cycles at a fraction of the cost, and usually faster — the smaller models respond quicker, so mechanical loops tighten.

The failure modes to avoid

• Downgrading the judge. Never give the cheap model the final say on quality. A haiku-tier test runner should report results; the decision about what a failure means belongs upstream.
• Cheap research, expensive conclusions. If a weaker model gathers the facts your strong model reasons over, errors launder themselves into confident answers. For research that feeds decisions, spend the tokens.
• Forgetting inheritance. An unset model field silently bills at your top rate. Audit your agents once: thirty seconds per file, real money per month.
• Tier-splitting a conversation. Subagents don't share context with your main session. That's a feature for parallel work, but it means the cheap agent can't "ask" the smart one for nuance mid-task — so keep intern tasks genuinely self-contained.

The part nobody warns you about

Here's the irony of getting this right: the better your model routing, the less reason you have to watch the terminal. A well-tiered fleet runs longer, cheaper, and more autonomously — which means the finish line moves from "whenever you happen to glance over" to "whenever the run actually ends," and those two moments can be twenty minutes apart. If you've already read our piece on not babysitting the terminal, you know where this is going: the point of cheap, parallel, well-routed subagents is reclaiming your attention, not relocating it.

Start here today

1. Run /agents, open each existing agent, and add an explicit model line — cheapest tier for anything mechanical.
2. Create one haiku-tier test-runner or formatter if you have none.
3. Watch your usage for a week and promote any agent whose mistakes cost you review time — demotions are free, bad output isn't.

Model selection per subagent is the rare optimization that improves cost, speed, and focus at once. Route the grunt work down, keep the judgment up top, and let the fleet run.