Skip to main content

Which Model Does Which Job: Routing Work Across an Agent Team

An agent team spends most of its money on jobs that never needed the top model. This framework routes exploration and QA to fast cheap models, implementation to the middle tier, and planning and review to the top, and covers the defaults, tool limits and context costs that quietly undo the routing.

CatalEx Engineering · Published October 2, 2026 · 09:00 UTC

An engineer opens a coding session on the strongest model available, because the task is a tricky refactor and they want the best plan. The session plans well. Then it fans out: five subagents to find every call site, two to update tests, one to run the suite and report failures, one to review the result. Nobody told any of them which model to use. All nine ran on the strongest, most expensive model, including the five that were doing what amounts to a careful grep.

The work came out fine. The bill came out several times larger than it needed to be, and the run took longer, because large models are slower per token too. Nothing was misconfigured in an obvious way. The default did exactly what it says it does.

This post is a framework for deciding which model does which job in an agent team: the session you talk to, and the subagents it starts. It has five parts, each answering one question. The short version is a routing table, but the parts after the table are where the money actually leaks: defaults that inherit, reviewers with write access, and context that gets re-read on every turn.

We use Anthropic's tiers as the running example (Haiku, Sonnet, Opus) because that is what we run. The framework does not depend on the vendor. Every provider sells a fast cheap tier, a balanced middle and an expensive top, and the same questions apply.

How the money moves in an agent team​

Before routing anything, it helps to see where the tokens go.

An agent team in a tool like Claude Code is one orchestrator (the session you are typing into) and some number of subagents. Per the Claude Code subagent docs, each subagent "runs in its own context window with a custom system prompt, specific tool access, and independent permissions," and starts fresh: it does not see your conversation, the files already read, or the skills already loaded. Whatever it needs, it gets from the prompt it is handed and the tools it is allowed to call.

Three costs follow from that design:

  1. Every turn re-sends the whole context. A model call is stateless. On turn 40 of a session, the model reads turns 1 to 39 again. Prompt caching makes the repeated part cheaper (Anthropic prices cache reads at 0.1 times the base input price, with the default cache living five minutes), but cheaper is not free. A session holding 400,000 tokens of context that takes 200 more turns reads 80 million cached tokens, which costs as much as 8 million uncached ones.
  2. The model's price multiplies all of it. The same context on the top tier costs several times what it costs on the middle tier, and more again than on the small one. Routing is a multiplier on everything else.
  3. Fan-out multiplies the count. Anthropic's account of its multi-agent research system (June 2025) measured agents using about 4 times the tokens of a chat, and multi-agent systems about 15 times. The same post reports that an Opus lead with Sonnet subagents outperformed a single Opus agent by 90.2% on their internal research eval. Multiple agents can buy real quality. They are never cheap.

The red box is the one that surprises people. In Claude Code, the docs say it plainly: "By default, a subagent you define runs on the same model as the conversation that starts it." The built-in Explore, Plan and general-purpose subagents follow the parent conversation's model too. If your session runs on the top tier, so does every subagent you did not pin, and many teams run their session on the top tier.

The framework​

Five parts. Each answers one question about a job before you hand it to a model.

PartThe questionWhat you decide
1. Job shapeWhat kind of work is this: find, build, check, decide?The default tier
2. Cost of a wrong answerIf this job is wrong, what breaks and who notices?Whether to move up a tier
3. Explicit modelIs the model written down at the point of dispatch?The model on every subagent call
4. Tools match the roleCan this agent change the thing it is judging?The tool allowlist
5. Context budgetWhat does this agent read, and how often?Prompt shape, file references, session length

Part 1: job shape sets the default tier​

Agent work falls into a few shapes. Each has a natural tier, and the reasoning is about how checkable the output is.

JobWhat it doesDefault tierWhy
ExploreFind files, call sites, configs; summarise what existsSmall (Haiku)Many tool calls, little judgement, and the output is checkable: a path exists or it does not
QARun a scripted scenario, record what happened, compare with expectedSmall or middleFollowing explicit steps and reporting facts; volume is high
ImplementWrite and change code against a plan and testsMiddle (Sonnet)Bounded by the plan and checked by tests, so errors surface quickly
PlanDecide the approach, split the work, name the risksTop (Opus)A wrong plan wastes every step after it
ReviewJudge correctness, intent and design of a changeTop for correctness, small or middle for narrow rule checksThe last check before merge; misses are expensive and silent

Anthropic's own model selection guide frames the choice the same way: start efficiency-first with the small model for "high-volume, straightforward tasks," and capability-first for "complex reasoning" and "high-autonomy agentic work." Its matrix lists subagent tasks under the small, low-latency tier. The subagent docs are more direct still: use subagents to "control costs by routing tasks to faster, lower-cost models like Haiku."

The pattern underneath: put the expensive model where errors multiply, and the cheap model where errors are caught. An explorer that misses a call site is caught when the build fails. A planner that picks the wrong approach is caught days later, if at all.

QA on a cheap model is not a compromise. A QA agent's job is to follow a script and say what it saw. The intelligence lives in the scenario, which a stronger model or a person wrote. A cheap model running a precise script many times beats an expensive model improvising once. What it must not do is judge, retry until green, or edit the scenario. More on that in part 4.

Part 2: the cost of a wrong answer moves the tier​

Job shape gives a default. The stakes move it.

  • Move up when a wrong answer is silent or expensive: anything touching money, auth, data deletion, migrations or concurrency. A middle-tier model implementing a payment retry is fine if the tests are strong. If the tests are thin, the review of that change should be top tier, and so should the plan.
  • Move down when a wrong answer is loud and cheap: a formatting pass, a rename that the compiler checks, a search whose results get verified anyway.
  • Consider effort before tier. Many current models take an effort or thinking setting that trades depth for speed within one model. Anthropic's guide notes that "tuning effort is often a better lever than switching models." Try the same tier at lower effort before you drop a tier.

Part 3: pass the model explicitly, every time​

This part is a habit, not a judgement. Every dispatch names its model. In Claude Code that means the model field in a subagent's definition (haiku, sonnet, opus, a full model ID, or inherit), or the model parameter on the call that starts it. The docs give the precedence: the model passed for that invocation, then the definition's model field, then the CLAUDE_CODE_SUBAGENT_MODEL environment variable, then the parent's model.

Write it into your agent instructions so the orchestrator does it without being reminded:

CLAUDE.md · Model routing
  • Always pass model when starting a subagent. An omitted model inherits this session's, which is usually the most expensive.
  • Haiku: exploration, file search, summaries, scripted QA runs.
  • Sonnet: implementation against a written plan; QA that needs to read logs.
  • Opus: plans, design decisions, correctness review, anything touching money, auth or data deletion.
  • A subagent that fails the same way twice is escalated one tier, not retried on the same model.
  • Reviewers get read-only tools and answer in the given schema.

Two details make this robust. Put the tier in the subagent's definition file, so a definition like explorer always runs small regardless of who starts it. And check the built-ins: the default exploration and planning helpers follow the parent, so if you want cheap exploration, define your own explorer with model: haiku, as the docs suggest.

Part 4: tools match the role​

Model choice is half of routing. The other half is what each agent is allowed to do, and the most important case is the reviewer.

A reviewer that can edit files is a second author. Ask it to review a change, and it will often "just fix" what it found. Now the review has changed the code it was reviewing, nobody reviewed the fix, and the finding is gone from the record. Worse, an author agent that controls the reviewer's prompt or output can steer the verdict.

The fix is structural. Give reviewers only read tools. The subagent docs show exactly this, a reviewer with tools: Read, Grep, Glob, or alternatively disallowedTools: Write, Edit to keep everything else. Then add three rules:

Reviewer ruleWhy
Read, Grep and Glob only; no shell, no editIt cannot change what it judges, run something with side effects, or "verify" by retrying
Answer in a fixed schema (rule, file, line, verdict, evidence)Findings can be counted, compared and checked by a second pass
The author never edits the findingA finding that can be argued away before it is recorded is not a finding
Give it the diff by file reference, not pastedThe author's framing does not leak into the reviewer's context
No delegation from inside the reviewerReviewers that spawn reviewers multiply cost and blur responsibility

The same thinking applies to QA agents. A QA runner should not be able to edit the scenario it is running or the code under test. Its job is to report. If it can change the test, it can make the test pass.

Part 5: the context budget​

The last part is the one that dominates long sessions. Three habits:

Hand over file paths, not file contents. If the orchestrator pastes a 300 KB diff into a subagent's prompt, that diff now lives in two contexts: the orchestrator's (because it wrote the message) and the subagent's. Write the prompt to a file and start the subagent with "read this file and follow it." The orchestrator's context grows by one line.

Keep the orchestrator lean. The orchestrator is usually on the top tier and lives longest, so every token it holds is re-read on every turn at the top-tier price. Push reading into subagents and keep only their conclusions. That is what fresh, isolated subagent contexts are for.

Watch the cache-read line. In a long session on a large context, cache reads can be the biggest single line on the bill even at a tenth of the input price, because they happen on every turn. Starting a new session with a short written handoff, rather than carrying 600,000 tokens of history forward, is often the cheapest optimisation available.

When to escalate, and when to step down​

Routing is not a one-time choice per job type. Within a task, signals tell you to move.

SignalMoveReason
The same failure twice on the same modelUp one tierA third attempt on the same model rarely differs; a stronger model or a different approach does
The task turns out to be ambiguousUp to the plannerAmbiguity is a planning problem; an implementer will guess
The change touches money, auth, deletion or concurrencyUp, for plan and reviewSilent failure modes
Reviewer verdicts disagree between runsUp, or add a humanThe question needs more judgement than the tier has
A top-tier agent is mostly running searchesDownIt is paying top price for checkable work
A QA run is long and scriptedDownVolume work on a precise script
A subagent hits its context limitSplit the task, not up a tierA bigger model does not fix a task that is too big

The first row deserves care. Retrying a failure on the same model, with the same context, is the most expensive way to learn nothing. Escalation should change something: the model, the plan, or the information available.

A worked example​

One feature, end to end: add rate limiting to an internal API, with a config option, tests and docs. Here is the same team before and after routing.

StepBeforeAfterReason for the change
Map the code: handlers, middleware, config loadingFive subagents, model omitted, so top tierThree explorers on Haiku, each with a narrow questionCheckable output; fewer, sharper questions
Plan the change and its risksOrchestrator on top tierUnchangedErrors here multiply
Implement middleware and configOne subagent, top tier by inheritanceSonnet, with the plan and failing tests written firstBounded by plan and tests
Run the test suite and summarise failuresOrchestrator reads raw test output into its own contextHaiku QA runner returns failures in a schemaKeeps thousands of log lines out of the expensive context
Fix two failing testsSame implementer retries four timesTwo failures on Sonnet, then escalated once to Opus with the failure textEscalation changes something
ReviewA general reviewer with full tools, which edited two filesOpus reviewer, read-only, schema output; a Haiku pass for mechanical style rulesReviewer cannot become an author
Hand-offPasted the full diff into the reviewer promptReviewer started with a file referenceDiff stays out of the orchestrator context

The changes compose. Cheap explorers are only safe because their output is checkable. The read-only reviewer is only trustworthy because its findings are in a schema the author cannot edit. And keeping test output out of the orchestrator matters most precisely because the orchestrator is on the expensive tier.

How to measure it​

Routing decisions should be revisited with data, especially at every model release, when both prices and capability gaps move.

MetricWhere to get itWhat good looks like
Token spend by role (explore, implement, QA, plan, review)Usage logs tagged by subagent typeTop-tier spend concentrated in plan and review
Share of subagent calls with an explicit modelSession transcripts100%; any omission is a bug
Cache-read share of total costProvider usage reportFalling as sessions get shorter and orchestrators leaner
Escalation rate per job typeCount tier changes within tasksLow for explore and QA; if high, the default tier is wrong
Rework after merge, by implementing tierFix commits linked to the change they fixNot higher for the middle tier than for the top
Reviewer findings confirmed versus refutedStructured review output plus a verification passStable or rising confirmation as rule lists shrink

The fifth metric is the one that tells you whether cheap routing is costing quality. If changes implemented on the middle tier need more follow-up fixes, move the review up before you move the implementation up.

What this does not fix​

  • Tier names are not stable. Today's small model may out-reason last year's top model. A routing table written for one generation needs re-checking at the next. Route by job shape and measured results, not by brand loyalty to a tier.
  • Cheap QA can be confidently wrong. A small model can report a pass it did not observe. Require evidence for every verdict (the command, the output, a screenshot) so a false pass is visible.
  • Same-family review is not independent review. A reviewer from the same model family as the author shares its blind spots. For high-risk changes, a different model or a person adds independence that a bigger model of the same family cannot.
  • Orchestration has overhead. Every subagent costs a prompt, a fresh context and a summary. For small tasks that fit comfortably in one context, a single agent at a lower effort setting is often cheaper than a team.
  • Read-only does not mean harmless. A reviewer with read access can still read secrets that are in the repository. Tool limits are about what an agent can change, not what it can see.

What it costs​

Routing adds decisions to every dispatch, and somebody has to maintain the table. Explicit models in agent definitions are one more thing to update at each release. Read-only reviewers need a second step (an implementer) to act on findings, which adds a hop. Schema outputs need schemas, and parsers that fail loudly when the model returns something else. And escalation rules mean some tasks take longer, because they stop and move up instead of grinding on.

The return is that the expensive model spends its time where it changes the outcome, and the bill tracks the hard parts of the work instead of the volume.

The framework, condensed​

PartQuestionDefault answer
1. Job shapeFind, build, check or decide?Find and check: small. Build: middle. Decide and judge: top
2. Cost of a wrong answerIs failure loud and cheap, or silent and expensive?Silent and expensive moves the plan and review up
3. Explicit modelIs the model named at dispatch?Always; an omitted model inherits the session's
4. Tools match the roleCan this agent change what it judges?Reviewers and QA runners are read-only and answer in a schema
5. Context budgetWhat does this agent read, and how often?File references in, short results out, lean orchestrator

Adopt it in this order, because each step is cheap and the early ones pay for the later ones:

  1. Add the routing rules to your agent instructions and pin model in every subagent definition you own. This alone removes the biggest leak.
  2. Define your own explorer on the small tier and route searches to it.
  3. Make every reviewer read-only with a fixed output schema.
  4. Change hand-offs to file references and move test-output reading into a QA subagent.
  5. Tag usage by role and look at the split after a week. Move whatever the data says is misrouted.

The default is not neutral. Every agent you start without naming a model is a decision to pay top price for it, made by nobody.


Written by CatalEx Engineering. We build the AI operating layer for AI-native companies: one platform to build, deploy, and run AI agents in production. More at catalex.co.