TLDR; The right Claude model in Claude Code is Opus 5.5 at
mediumeffort for the main session, with Sonnet 5.5 and Haiku 5.5 on the jobs you hand off. Change effort, not model, as the work changes. Send search and extraction to Haiku and standard implementation to Sonnet only where a test shows they match Opus. Reviews, root causes, security and agents that act on untrusted input stay on Opus. Fable 5.1, the dearest current model, has no default job.
When to route Claude models
- You hand work to sub-agents, the helper sessions Claude Code starts for one job.
- A new model has landed, or your agent definitions name an older one.
- You pay per token (Claude’s billing unit, a word fragment) or keep hitting plan limits.
- Skip it if you hand nothing off. Step 1 below is all you need.
How Claude model selection works: price, benchmarks and effort
At October 2026 list prices, Opus 5.5 costs $4 per million input tokens and $20 per million output, and Sonnet 5.5 $2 and $10. Haiku 5.5 costs $0.10 and $0.50 for prompts up to 100,000 tokens, a twentieth of Sonnet’s price and a fortieth of Opus’s. Above that size every Haiku rate rises fivefold, so split a large PDF or web crawl into smaller chunks. Anthropic’s pricing page has the current table.
Fable 5.1 is the dearest current model at $10 and $50. Mythos 5.1 is the same model with different safeguards and costs the same. On Terminal-Bench 4.0, a standard set of coding tasks, Opus 5.5 scores 66.4% against Fable’s 55.8% (Opus 5.5 launch post, Fable and Mythos launch post), at 40% of the price.
Anthropic’s cost and intelligence guide says “For most agent workloads, start with Claude Opus 5.5 at its default effort (medium).” Effort sets how much work the model puts into a response, including its thinking and tool calls. The levels are low, medium, high, xhigh and max. The choosing a model page says “tuning effort is often a better lever than switching models”. It sends you to Fable 5.1 only if your evals (repeatable tests on your own task) at xhigh or max still fall short.
Which Claude model to use: the routing table
Each row gives the model and effort I use as of October 2026, and why. My evals ran one to three times per prompt per model, so read them as tie-breakers. The Claude evals ran 1–8 October 2026; the two local-model rows date from August and September. Dollar figures are list-price API equivalents from Claude Code’s cost reporting; on my flat Max plan none was billed.
| Work | Model | Effort | Why |
|---|---|---|---|
| Main session: planning, small edits, handing out work | Opus 5.5 | medium; high for one hard planning turn |
Anthropic’s model configuration docs: Opus 5.5 at medium matches or beats Opus 5 at high on coding and knowledge-work evaluations. |
| Code search: find call sites, list files, map a codebase | Haiku 5.5 | medium |
Three prompts to find code, answers checked with grep, two runs each: Haiku 5.5 and Sonnet 5.5 both 6/6 runs, 34/34 files, no wrong files. Explore is Claude Code’s built-in search agent. In the month before a hook set model: "haiku" on its spawns, 44 of its 49 runs went to Opus, $31.88 of the $33.69 it cost |
| Fetch, parse, extract, classify | Haiku 5.5 | low for a single call; medium past a few tool calls |
Anthropic’s models overview positions it “for high-volume, latency-sensitive tasks such as classification, extraction, and routing”. On my cost-check tests (the agent must state the price and cap the rows before a paid API call), Haiku and Sonnet 5.5 tied on two prompts. On the third, Haiku passed 2 of 3 runs and Sonnet 1 of 3, at $0.01 a run against $0.15 |
| Knowledge-base search | Haiku 5.5 | medium |
Four questions with known answers against my knowledge base, two runs each: Haiku 4/4 on both runs, Sonnet 4/4 on one. The other Sonnet run searched too narrowly and said, with confidence, that an answer wasn’t there |
| Web research with an evidence trail (name screening) | Haiku 5.5 | medium |
Two runs each: Haiku 5/5 and 5/5, Sonnet 4/5 and 5/5. Both models stated a few details no search result showed, so the agent now searches first and records evidence for every name it rules out |
| Writing records into a store (saving what a session learned) | Sonnet 5.5 | medium |
Haiku scored higher (6/7 against 5/7) but skipped the duplicate check and reached the right answer from memory. I kept Sonnet, because the duplicate check is the job |
| Standard implementation, tests, deploy steps | Sonnet 5.5 | medium; high for longer runs |
Anthropic’s Sonnet 5.5 prompting guide: medium for clearly specified agent work. Terminal-Bench 4.0: Sonnet 5.5 70.6%, Opus 5.5 66.4%. Untested by me |
| Long-form drafting through a review pipeline | Opus 5.5 | inherit (the session’s) | My drafting eval, three runs each: both met 4/5 expectations, but Sonnet skipped the pass that strips AI writing tells in 2 of 3 runs and never ran the editorial review. Opus cost about seven times as much ($2 to $3 a run) |
| Complex implementation: four or more files, a new pattern | Opus 5.5 | medium, never above high for a code change |
Anthropic’s Opus 5.5 prompting guide reserves xhigh and max for work with a measured gain. The Opus 5.5 system card (Anthropic’s test report on the model) shows that its FrontierCode score drops above medium; that benchmark marks down changes outside the task. Untested by me |
| Code review, root-cause debugging, eval grading | Opus 5.5 | medium; high for security |
Untested by me. Step 5 gives the Haiku 5.5 system card’s findings |
| An agent that reads untrusted content and can act on it (edit files, run commands) | Opus 5.5 | high or below |
Untested by me. A Haiku fetch or research agent that only reads gets read-only tools and reports back. Pass outside text as a file the agent reads, never pasted into its prompt. The Opus 5.5 system card reports that the final model followed instructions planted in its prompt in about 2% of attempts. A pre-release snapshot never followed them from a tool result (0 of 105). A file read lowers the risk without removing it |
| Escalation for one problem Opus cannot solve | Fable 5.1 | high |
No default job; untested by me. Opus 5.5 outscores it at 40% of the price |
| Cheap hook steps (scripts Claude Code runs at set points): session summaries, yes/no nudges | Local Qwen3.6-35B-A3B (fast) and Qwen3.8-27B (quality) | n/a | My September eval, with Opus judging blind: the 35B model scored 16/16 on the nudge at 0.4 s; the 27B beat Haiku 4.5 6–0 on JSON session summaries. Apple’s on-device model lost every task |
| Code that must not leave the machine | Local Qwen3.8-27B | n/a | 49/49 on my six-task Ruby eval (best of two runs, about 29 tokens a second). Sonnet 5 and Opus 5 scored the same in August |
How to choose a Claude model and effort in Claude Code
1. Run the main session on Opus 5.5 at medium effort
The main session plans, makes small edits and decides whether a reviewer’s report clears the code to merge. A cheaper model puts that last job at risk. If you pay per token through the API, starting on Sonnet 5.5 and passing its failures to Opus is a reasonable alternative.
/model opus
/effort medium
Claude Code runs Opus 5.5, Sonnet 5.5 and Haiku 5.5 at medium by default, and most other models at high (model configuration docs). Through the API, Sonnet 5.5 defaults to high.
Anthropic’s effort documentation has moved its recommended starting point for Opus twice: xhigh for Opus 4.8, high for Opus 5 and medium for Opus 5.5. Re-test effort settings copied from an earlier model.
Check: /status names Opus 5.5 as the model, and /effort status reports medium.
2. Change effort, not the model, mid-session
Each model has its own cache (a stored copy of the conversation that makes the next request cheaper), so after a /model switch the next request reprocesses the whole conversation. Opus 5.5 also cannot read the reasoning an earlier Fable turn wrote. An effort change keeps the cache on Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 with an API key or a Claude subscription. An effort change loses the cache on Amazon Bedrock, Google Cloud or a Claude apps gateway, and also when CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS is set or a HIPAA configuration applies.
- xhighOne hard architecture step, if tests show a gain
- highA planning or review turn
- mediumDrop back here before implementing
- lowStatus checks and quick answers
/model switch does not.Leave max alone: I have found no task where it paid off. Simon Willison ran Opus 5.5 at max on launch day and got no response at all: “This makes me suspect that ‘max’ is effectively useless.” His Sonnet 5.5 test at max thought for 128,000 tokens, cost $1.28 and still failed the task.
Ultracode, in the same /effort menu, is a setting rather than an effort level: with it on, Claude runs dynamic workflows at the session’s effort. The --effort ultracode flag turns it on and sets effort to xhigh (model configuration docs).
Two model switches hide elsewhere. The opusplan setting runs Opus in Plan Mode, where Claude plans but writes no code, and Sonnet outside it. Every switch in or out of Plan Mode starts a fresh cache. Skills and commands are instruction files Claude Code loads on demand. One that names a model in its frontmatter (the settings block at the top) switches to it for that turn. Find those:
grep -rn "^model:" .claude/skills .claude/commands ~/.claude/skills ~/.claude/commands 2>/dev/null
Check: the grep prints nothing, or only the model your session already runs.
3. Move a job to Sonnet or Haiku only on evidence
Evidence means the cheaper model matched the dearer one on a test whose answers you know, such as code-search prompts checked against grep. Run each prompt more than once per model. The evals and drift guide covers the test setup.
Sonnet 5.5 is the cheapest API model I let write code without close supervision. Anthropic’s launch post puts it ahead of Opus 5.5 on Terminal-Bench 4.0 and behind it on CursorBench (the Cursor editor’s coding benchmark) and on “complex, open-ended work requiring sustained judgment”. Test Sonnet first on changes that touch one to three files and follow an existing pattern, with a clear brief and tests to pass. A new pattern, or four or more files, goes to Opus.
Drafting and judgement stay on Opus. In my drafting eval, a Sonnet draft that looked finished would have shipped unreviewed. Reviews, root-cause analysis, security audits and eval grading stay on Opus too: they decide what ships.
When a new model lands, run your cheapest and most expensive delegated jobs on it at two effort levels before you change any agent definition.
Check: every job you moved to Sonnet or Haiku has a test run, on the current model, where it matched the dearer model.
4. Pin model and effort in each agent definition
Sub-agents multiply every routing mistake: Anthropic measured its own multi-agent research system at about 15 times the tokens of a chat. Set model and effort in each agent’s frontmatter:
---
name: code-search
description: Find call sites, list files and map a codebase. Read-only.
model: haiku
effort: medium
---
An agent with no effort runs at the session’s level. A /effort high turn does not lift an agent pinned at medium. From Claude Code v2.1.292, an effort parameter on the spawn (the call that starts the agent) does. The CLAUDE_CODE_EFFORT_LEVEL environment variable overrides both.
For the model, the first setting found wins: the spawn’s model, then the agent’s frontmatter, then CLAUDE_CODE_SUBAGENT_MODEL, then the main session’s model (sub-agents docs). That variable leaves the built-in Explore and Plan agents alone. Frontmatter beats it unless CLAUDE_CODE_SUBAGENT_MODEL_FORCE=1 is set, and that flag downgrades your reviewers too. Explore uses the main conversation’s model, so on an Opus session it runs on Opus unless the spawn names haiku.
- Per-spawn modelThe model named on the spawn itself
- Agent frontmatterThe model field in the agent definition
- CLAUDE_CODE_SUBAGENT_MODELEnvironment variable; reaches only agents with no model field
- Main session’s modelUsed when nothing else names a model
CLAUDE_CODE_SUBAGENT_MODEL_FORCE=1 is set.Check: grep -L "^effort:" .claude/agents/*.md lists only agents you chose to leave on the session’s effort.
5. Brief the cheaper model for its weak spots
Haiku 5.5’s system card says it makes things up more often than other recent Claude models, so brief it to report only what is in front of it:
Report only what you read in the files or pages you were given.
If a field is not there, write "missing". Do not fill it from memory.
Keep Haiku off grading and review: the card finds it slightly favours its own answers, more than Opus does, and grades less consistently. Re-run a refusal on Sonnet: Haiku has no fallback model to take over a refused turn, and a retried turn is usually refused again. Keep it out of the browser, where it follows instructions planted in web pages more often than Sonnet or Opus.
Give a multi-step Haiku agent medium: at low, in long agent prompts, it is more likely to skip a search, stop early or skip a check (Haiku 5.5 prompting guide).
Below medium, Sonnet “can skip verifying a change” (Sonnet 5.5 prompting guide). At low and medium on long tasks it is more likely to stop and check in, which ends a sub-agent’s run with the work half done. My code-writing Sonnet agents carry these two lines:
Keep going until the task is done.
Before you report, run a real check that exercises the change.
Rules written in prose still slip. In my lesson-design tests, Sonnet 5.5 ran a third fix round without asking when the two-round limit lived only in the skill’s text. Once a hook enforced it, Sonnet met every expectation. When a rule must hold, put it in a hook.
Check: given a source with one field absent, the Haiku agent reports that field as missing, and a Sonnet agent’s report names the check it ran.
Pitfalls
| Symptom | Cause | Fix |
|---|---|---|
| The turn after a Plan Mode toggle is slow and costly | opusplan switches model; each model has its own cache |
One model per session; change effort instead |
| A sub-agent stops halfway | Sonnet at low or medium stops to check in on long tasks |
Tell it to keep going until done |
| Waking an idle agent costs dollars | By default a sub-agent’s cache expires after five idle minutes; a late wake re-sends the context at the cache-write price, the higher rate for storing it | End an agent when its report lands; give follow-up work to a fresh agent |
| You default to Fable 5.1 because it is the newest | It is the dearest current model, so it looks like the best | Opus 5.5 scores higher on Terminal-Bench 4.0 at 40% of the price; keep Fable for one problem Opus cannot solve |
In practice
The model lineup changed four times between 1 September and 7 October 2026. I moved every Fable route in my plugins to Opus on 23 September. Haiku 5.5 launched at a tenth of Haiku 4.5’s price and started matching Sonnet on search. The routing advice I published in April no longer matches what I run.
Idle sub-agents get expensive. By default their cache expires after five idle minutes; the main conversation’s lasts an hour as long as you stay within a subscription’s included usage (prompt caching docs). The subagentPromptCacheTtl setting gives sub-agents an hour, at a higher price for each cache write. On 14 September I woke a Fable implementation agent seven times over seven idle hours. Each wake re-sent 160,000 to 277,000 tokens at the cache-write price, and that one task cost $37.
I serve the two local models in the table with oMLX, an MLX model server for Apple silicon. They handle hook steps and code that should not leave the machine. I label every local draft unverified until it is checked: by a hosted Claude model where the code may leave the machine, and by me where it may not. The models are slow: the 27B took about 17 minutes over my Ruby eval, against under a minute for Sonnet. The full write-up has the setup, timings and failures.
The agents I build for Applied AI clients follow the same rule. A cheaper model takes a step only when it matches the expensive one on that step’s tests, and judgement stays on the strongest.
Related reading
- Claude Code pricing: what plans, tokens and models cost, pricing, subscriptions and context costs
- Multi-agent orchestration, running parallel agents on real projects, mixing models across a team of agents
- Evals and drift, keeping agents honest when the model changes, the harness behind the first-party numbers here
- A local 27B model shipped code through my dev workflow, the local-model experiment in full
Sources
- Pricing, Anthropic, per-token and cache prices, including Haiku 5.5’s 100,000-token price tier. Documentation
- Introducing Claude Opus 5.5, Claude Sonnet 5.5, Claude Haiku 5.5 and Claude Fable and Mythos 5.1, Anthropic launch posts and Terminal-Bench 4.0 scores. Product announcements
- Optimizing for cost and intelligence, Anthropic, Opus 5.5 at default effort as the starting point. Documentation
- Choosing a model, Anthropic, “Tuning effort is often a better lever than switching models”. Documentation
- Model configuration, Claude Code Docs, aliases,
/model,/effortand Claude Code’s per-model effort defaults. Documentation - Models overview, Anthropic, positioning for each current model. Documentation
- Prompting Claude Sonnet 5.5 and Prompting Claude Haiku 5.5, Anthropic. Early stopping and skipped checks at low and medium effort; Haiku safeguard refusals. Documentation
- Prompting Claude Opus 5.5, Anthropic, Opus 5.5 at
mediumagainst Opus 5 athigh; reservexhighandmaxfor measured gains. Documentation - Effort, Anthropic, effort levels, per-model defaults and supported models. Documentation
- Prompt caching, Claude Code Docs, each model has its own cache; which actions invalidate it, including
opusplantoggles and effort changes; cache lifetime for the main conversation and sub-agents. Documentation - Preserved thinking, Anthropic, Opus 5.5 does not read thinking blocks written by Fable 5.1. Documentation
- Opus, Sol and Luna and Claude Sonnet 5.5, Simon Willison, September 2026. Launch-day tests, including
maxeffort failures. Independent practitioner - How we built our multi-agent research system, Anthropic, multi-agent runs use about 15 times the tokens of a chat. Engineering blog
- Create custom subagents, Claude Code Docs,
modelandeffortfrontmatter and the model resolution order. Documentation - Claude Opus 5.5 system card, prompt-injection rates by input channel and FrontierCode scores by effort level. System card
- Claude Haiku 5.5 system card, hallucination, grader bias, classifiers with no fallback model, and prompt-injection rates in GUI computer use. System card
Common questions
Which Claude model should I use for coding?
Opus 5.5 at medium effort for the main session. Hand standard coding and tests to Sonnet 5.5 sub-agents, and code search, fetching and extraction to Haiku 5.5, once a test shows each matches Opus on that job.
How much more does Opus cost than Sonnet?
Twice as much. At October 2026 list prices, Opus 5.5 is $4 per million input tokens and $20 per million output; Sonnet 5.5 is $2 and $10.
Which Claude model is the most expensive?
Among current models, Fable 5.1 and Mythos 5.1 (the same model with different safeguards), at $10 per million input tokens and $50 per million output (October 2026); the older Fable 5 and Mythos 5 cost the same. Opus 5.5 scores higher on the Terminal-Bench 4.0 coding benchmark (66.4% against 55.8%) at 40% of the price.
What is the default effort level in Claude Code?
Medium on Opus 5.5, Sonnet 5.5 and Haiku 5.5, high on most other models and xhigh on Opus 4.7. Through the API, Sonnet 5.5 defaults to high. Effort sets how much work the model puts into a response, including its thinking and tool calls.
Should I use Opus or Sonnet for writing?
Opus, for writing that goes through several review steps. In my drafting eval both met four of five expectations, but Sonnet skipped the pass that strips AI writing tells in two of three runs and never ran the editorial review. Opus cost about seven times as much per run.
Is Haiku good enough for Claude Code sub-agents?
For searching, fetching and extracting, yes. In my tests Haiku 5.5 matched Sonnet 5.5 on every code-search run (34 of 34 files, no wrong files) and did better on knowledge-base search. Keep it off reviews, root-cause analysis, grading and anything that needs facts it has not just read.