Claude Opus vs Sonnet vs Haiku: model and effort guide

TLDR; Run the main Claude Code session on Opus 5.5 at medium effort, and change effort, not model, as the work changes. Push work down to Sonnet or Haiku only where your own evals show the cheaper model holds: Haiku 5.5 for search, fetch and extraction, Sonnet 5.5 for standard implementation and tests. Reviews, root causes, security and untrusted input stay on Opus. Fable 5.1 no longer has a default job.

The model lineup changed four times between 1 September and 7 October 2026: Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5. The last three each moved rows in my routing. Opus 5.5 took the top job from Fable at 40% of the price. Sonnet 5.5 became a model I trust to write code without close supervision. Haiku 5.5 dropped to a tenth of Haiku 4.5’s price and started matching Sonnet on search.

The routing advice I published in April (Sonnet by default, Opus for architecture, Haiku for sub-agents) no longer matches what I run. This guide replaces it. Every row in the table comes from Anthropic’s documentation, from evals I ran on my own plugins, or from spend I measured. Rows marked “no first-party test” rest on Anthropic’s sources alone.

Three rules for picking a model

One model for the main session, and change effort instead. Opus 5.5 at medium handles planning, small edits and review. I raise effort for a hard planning turn and drop it for routine ones.
Downgrade a sub-agent only on evidence. A cheaper model is right for a job when it matches the expensive one on a test you trust.
Judgement stays on the strongest model. Reviews, root-cause analysis, security audits and eval grading decide what ships, so they get the model least likely to wave a defect through.

The routing table

Each row gives the model and effort I use for that work as of October 2026. “Effort” is the Claude Code effort setting (low, medium, high, xhigh, max). The Why column names the source. First-party results come from my plugin eval suite and session logs, and those evals ran one to three times per prompt per model, so read them as tie-breakers. Dollar figures are list-price API equivalents from Claude Code’s own cost reporting; I’m on a flat Max plan, so none was billed.

Work	Model	Effort	Why
Main session: planning, small edits, orchestration	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. I ruled out a Sonnet main loop on 3 September, before the 5.5 releases, and the reason still holds: the main loop does standard work itself and holds the approval gates
Code search: find call sites, list files, map a codebase	Haiku 5.5	`medium`	Three locate prompts with grep ground truth, two runs each: Haiku 5.5 and Sonnet 5.5 both 6/6 runs, 34/34 files, no false positives. Before I routed it, 44 of 49 Explore runs in a month went to Opus, $31.88 of $33.69 spent
Fetch, parse, extract, classify	Haiku 5.5	`low` one-shot; `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-gate suite, which checks that an agent states the price and caps the row count before a paid API call, it planned calls as carefully as Sonnet 5.5: the two tied on two prompts, and on the third Haiku passed 2 of 3 runs against Sonnet’s 1 of 3, at $0.01 a run against $0.15
Knowledge-base search	Haiku 5.5	`medium`	Four questions against my markdown knowledge base with known answers, two runs each: Haiku 4/4 on both runs, Sonnet 4/4 on one; the other Sonnet run narrowed its search and reported a confident false negative
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 specifics no search result showed, so the agent now searches before it answers and records an evidence URL or command output for every name it rules out
Writing records into a store (session-knowledge extraction)	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 well-specified agentic work. Terminal-Bench 4.0: Sonnet 5.5 70.6%, Opus 5.5 66.4%. No first-party test. At `low` and `medium` on long tasks it is more likely to stop and check in, so code-writing agents carry an explicit “keep going until done, run a real check” instruction
Long-form drafting through a review pipeline	Opus 5.5	inherit	Drafting eval, three runs each: both 4/5, but Sonnet skipped the pass that strips AI writing tells in 2 of 3 and never ran the editorial review step. 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 diff	Anthropic’s Opus 5.5 prompting guide reserves `xhigh` and `max` for work with a measured gain. The Opus 5.5 system card’s FrontierCode score falls above `medium`, and that benchmark penalises out-of-scope changes. No first-party test
Code review, root-cause debugging, eval grading	Opus 5.5	`medium`; `high` for security	No first-party test. This work decides what ships. Haiku 5.5 hallucinates more than other recent Claude models and shows more self-preference as a grader than Opus (Haiku 5.5 system card)
Anything that reads untrusted content	Opus 5.5	`high` or below	No first-party test. Pass third-party text as a file the agent reads, never pasted into its prompt: the Opus 5.5 system card reports the final model followed planted instructions in about 2% of attempts from the prompt, and a pre-release snapshot never did 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, no first-party test. Opus 5.5 scores 66.4% on Terminal-Bench 4.0 against Fable’s 55.8%, at $4/$20 against $10/$50
Cheap hook steps: session summaries, yes/no nudges	Local Qwen3.6-35B-A3B (fast) and Qwen3.8-27B (quality)	n/a	My September eval, Opus as blind judge: the 35B MoE scored 16/16 on the nudge at 0.4 s; the 27B beat Haiku 4.5 6–0 on session-summary JSON. 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, in seconds where the 27B took minutes

Opus 5.5 carries five of the jobs; Haiku 5.5 takes the four cheap, high-volume ones.

Opus vs Sonnet for the main session

Opus, at medium effort. Anthropic’s documentation now says what I had already settled on. Its cost and intelligence guide says “For most agent workloads, start with Claude Opus 5.5 at its default effort (medium).” Its choosing a model page says “tuning effort is often a better lever than switching models.” The same page sends you to Fable 5.1 only if your evals at xhigh or max still fall short.

The case against Sonnet in the main loop is about what the main loop does. It plans, answers questions, makes the small edits that are not worth a sub-agent, and decides whether a reviewer’s report clears the merge gate. The fourth is the one a cheaper model puts at risk.

The common alternative is the reverse: run Sonnet 5.5 at medium first and escalate to Opus only for tasks that fail. On metered API billing with well-specified tasks that is a defensible choice. On a flat plan, where the main loop also holds the gates, I take Opus.

Change effort, not model

The case for one model per session is the cache. Claude Code’s prompt caching docs say each model has its own cache, so a /model switch makes the next request read the entire conversation with no cache hits. Opus 5.5 also cannot read the thinking blocks an earlier Fable turn wrote. Effort is different: on Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1, with an API key or a Claude subscription, changing effort keeps the cache. On Bedrock and Google Cloud it does not.

I use /effort low for status checks and quick answers, /effort high for a planning or review turn, and /effort xhigh for one hard architecture step. I drop back to medium before implementing.

Two model switches hide in places that don’t look like /model. The opusplan setting runs Opus in plan mode and Sonnet outside it, so every plan-mode toggle makes the next request read the whole conversation with no cache hits. A skill or command whose frontmatter names a different model switches the model for that turn, with the same result.

I have found no task where max paid off, and Anthropic reserves it for measured gains. 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,” he wrote. His Sonnet 5.5 test at max thought for 128,000 tokens and cost $1.28. It still failed the task.

When Haiku is enough

Haiku 5.5 costs $0.10 per million input tokens and $0.50 per million output for prompts up to 100,000 tokens, a twentieth of Sonnet 5.5’s price and a fortieth of Opus 5.5’s. Cache reads are $0.01. Above 100,000 prompt tokens every rate rises fivefold, so split a large PDF or crawl dump into chunks under that line. Anthropic’s pricing page has the full table.

The price only matters if the output holds up, so I tested it before moving anything. Three code-search prompts with a known answer from grep, two runs per model: Haiku and Sonnet each found all 34 files, with no false positives. On knowledge-base search Haiku held up better than Sonnet, which once narrowed its search to four directories and missed the two entries that mattered.

That result changed the default for one agent type. Claude Code’s built-in Explore agent uses the main conversation’s model, so on an Opus session every Explore run is an Opus run. In the month to 8 October, Explore cost me $33.69, $31.88 of it on Opus. A small hook now fills in model: "haiku" on any Explore spawn that names no model.

Four limits on Haiku:

Brief it to report only what it read. Haiku 5.5’s system card says it hallucinates more than other recent Claude models. Ask it to extract from the files or pages in front of it and to mark missing fields as missing.
Keep it off grading and review. Its self-preference bias is small but larger than Opus’s, and it is less consistent.
Re-run refusals on Sonnet. Haiku has no fallback model: a classifier refusal ends the turn, and a retry usually refuses again.
Keep it out of the browser. Its prompt-injection robustness is strong in code and tool results and weak in GUI computer use.

Set Haiku’s effort deliberately. low suits a one-shot extraction. A multi-step Haiku agent needs medium: Anthropic’s Haiku 5.5 prompting guide warns that at low, in long agent prompts, it is more likely to skip a search, stop early or skip a check.

Sonnet 5.5 for implementation, Opus for drafting

Sonnet 5.5 is the cheapest API model I let write code without close supervision. It costs $2 and $10 per million tokens, half of Opus 5.5. Anthropic’s launch post puts it ahead of Opus 5.5 on Terminal-Bench 4.0 (70.6% against 66.4%). The same post has it trailing on CursorBench and on “complex, open-ended work requiring sustained judgment.”

That split matches what I see. A pattern-following change across one to three files with a clear brief and a test suite to pass is Sonnet work. A change that invents a pattern or touches four or more files goes to Opus.

Two habits make Sonnet sub-agents reliable:

Pin the effort in the agent definition. Below medium, Anthropic’s Sonnet 5.5 prompting guide says it “can skip verifying a change.”
Tell it to finish. At low and medium, on long tasks, Sonnet is more likely to stop and check in. For a sub-agent a check-in ends the run with the work half done. Every code-writing Sonnet agent I run carries two paragraphs: keep going until the task is done, and run a real check that exercises the change before reporting it.

Guardrails written in prose still slip. My lesson-design suite tests a course-writing skill that allows two fix rounds per lesson unless the user grants a third. With the limit written only in the skill’s text, Sonnet 5.5 ran a third round without asking. Once a hook enforced the limit, Sonnet met every expectation on that eval. When a rule must hold, put it in a hook. The evals and drift guide covers that harness.

Long-form drafting stays on Opus, though Sonnet looks good enough on paper there too. Both met four of five expectations in my drafting eval. Sonnet skipped the pass that strips AI writing tells in two of three runs and never ran the editorial review, so a draft that looked finished would have shipped unreviewed. Opus cost $2 to $3 a run, about seven times as much. I pay it.

Effort defaults and how sub-agents inherit model and effort

Effort sets how many tokens Claude spends on a response, including tool calls. Claude Code runs Opus 5.5, Sonnet 5.5 and Haiku 5.5 at medium by default, and most older models at high (model configuration docs). Through the API, Sonnet 5.5 defaults to high.

If you copied effort settings from an earlier model, sweep them again. Anthropic’s effort documentation has changed its recommended starting point for Opus twice since Opus 4.8: xhigh for Opus 4.8, high for Opus 5 and medium for Opus 5.5.

Anthropic has lowered the starting effort with each Opus release since 4.8, so an effort setting copied from an older Opus is likely too high for 5.5.

Sub-agents multiply every routing mistake: Anthropic measured its own multi-agent research system at about 15 times the tokens of a chat. Four mechanics catch people out:

Sub-agents inherit. An agent with no effort in its frontmatter runs at the session’s level. Pin it in the definition for any agent whose quality depends on it.
Model resolution has an order. The per-spawn model wins, then the agent’s frontmatter, then CLAUDE_CODE_SUBAGENT_MODEL, then the main session’s model (sub-agents docs).
The environment variable has limits. CLAUDE_CODE_SUBAGENT_MODEL reaches only agents with no model field, such as the built-in general-purpose agent. It leaves the built-in Explore and Plan agents alone (sub-agents docs). Frontmatter beats it unless CLAUDE_CODE_SUBAGENT_MODEL_FORCE=1 is set, and that flag downgrades your reviewers too, so keep it for a deliberate cheap batch run.
A pinned agent ignores the session. A /effort high turn does not lift an agent pinned at medium. A per-spawn effort parameter does, from Claude Code v2.1.292. The CLAUDE_CODE_EFFORT_LEVEL environment variable overrides both the frontmatter and the per-spawn value (sub-agents docs).

The first setting found wins. The environment variable sits third, so frontmatter beats it unless CLAUDE_CODE_SUBAGENT_MODEL_FORCE=1 is set.

Ultracode sits in the same /effort menu, but it is a setting rather than an effort level. With it on, the model configuration docs say, “Claude orchestrates dynamic workflows for substantive tasks, at whichever effort level the session runs at.” The --effort ultracode flag turns it on and also sets effort to xhigh.

Fable 5.1 has no default job

Fable 5.1 is the most expensive model in the lineup at $10 and $50 per million tokens, the same price as Mythos 5.1, the same model with different safeguards. Opus 5.5 beats it on Terminal-Bench 4.0 (66.4% against 55.8%, from the Opus 5.5 launch post and the Fable and Mythos launch post) at 40% of the price. I moved every Fable route in my plugins to Opus on 23 September.

At Fable’s price an idle agent gets expensive fast. On a subscription, Claude Code gives the main conversation a one-hour cache lifetime and sub-agent requests five minutes (prompt caching docs). An agent left idle longer than that pays the cache-write price on every wake. On 14 September a Fable implementation agent sat idle for seven hours. I woke it seven times, each time with 160,000 to 277,000 tokens of context to re-send at the cache-write price, and it cost $37 for that one task. Whatever model you pick, end an agent when its report lands and give follow-up work to a fresh spawn.

Local models: privacy and the cheap steps

Local models do two jobs in my setup: they save API cost on the hook steps, and they keep private code on the machine.

The first job covers the steps too cheap to justify an API call: a pre-compaction session summary, a yes/no “is this worth remembering?” nudge, a draft lesson from a session’s errors. I run a fast Qwen3.6-35B-A3B mixture-of-experts model and a slower, more careful Qwen3.8-27B dense model on oMLX, an MLX model server for Apple silicon.

In a blind comparison judged by Opus, the 35B answered the nudge 16 of 16 times in 0.4 seconds, and the 27B beat Haiku 4.5 6–0 on session-summary JSON. Apple’s on-device model lost every task, so it is only the fallback for when no server is running. Every local draft is labelled unverified, and the frontier model corrects it.

The second is code that should not leave the machine. Qwen3.8-27B scored 49 of 49 on my six-task Ruby eval on a 64 GB M5 Pro, best of two runs at about 29 tokens a second. Sonnet 5 and Opus 5 scored the same in August. The 27B is slow: the full eval took it about 17 minutes, against under a minute for Sonnet. On a flag-sized task in my dev workflow, Sonnet finished in 33 seconds for $0.20, and even the faster local Qwen3.6-35B-A3B took 2 minutes 51 seconds. The full write-up of that experiment has the setup and the failures.

Re-check the table when the lineup moves

This table is a snapshot. The Claude eval rows come from runs between 1 and 8 October 2026 on the current models. The two local rows are older: the private-code row dates from August, and the hook-step row from September, scored against Haiku 4.5. Re-run those first. 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.

The agents I build for Applied AI clients follow the same three rules: a cheaper model takes a step only when it matches the expensive one on that step’s tests, and judgement stays on the strongest.

Token economics, what Claude Code actually costs, 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

Choosing a model, Anthropic, “Tuning effort is often a better lever than switching models”; most workloads start on Opus 5.5. Documentation
Optimizing for cost and intelligence, Anthropic, Opus 5.5 at default effort as the starting point; advisor results for the 5.5 models. Documentation
Models overview, Anthropic, positioning, default effort and context window for each current model. Documentation
Pricing, Anthropic, per-token and cache prices, including Haiku 5.5’s 100,000-token price tier. Documentation
Effort, Anthropic, effort levels, per-model defaults and supported models. Documentation
Prompting Claude Opus 5.5, Anthropic, Opus 5.5 at medium against Opus 5 at high; reserve xhigh and max for measured gains. Documentation
Model configuration, Claude Code Docs, aliases, /model, /effort and Claude Code’s per-model effort defaults. Documentation
Create custom subagents, Claude Code Docs, model and effort frontmatter and the model resolution order. 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
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
Opus, Sol and Luna and Claude Sonnet 5.5, Simon Willison, September 2026. Launch-day tests, including max effort failures. Independent practitioner
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
How we built our multi-agent research system, Anthropic, multi-agent runs use about 15 times the tokens of a chat. Engineering blog
Prompt caching, Claude Code Docs, each model has its own cache; which actions invalidate it, including opusplan toggles 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

Common questions

Which Claude model should I use for coding?

Run the main Claude Code session on Opus 5.5 at medium effort, hand standard implementation and tests to Sonnet 5.5 sub-agents at medium, and send code search, fetching and extraction to Haiku 5.5. Anthropic’s own guidance starts most agent workloads on Opus 5.5; Sonnet 5.5 and Haiku 5.5 take the narrower jobs where they match it. Sonnet costs half as much as Opus, and Haiku a fortieth.

How much more does Opus cost than Sonnet?

Opus 5.5 is $4 per million input tokens and $20 per million output, twice Sonnet 5.5’s $2 and $10. Haiku 5.5 is $0.10 and $0.50 for prompts up to 100,000 tokens, a twentieth of Sonnet’s price and a fortieth of Opus’s. On a subscription plan the gap shows up as allowance used rather than a line item.

Which Claude model is the most expensive?

Fable 5.1, at $10 per million input tokens and $50 per million output. Mythos 5.1, the same model with different safeguards, costs the same, as do the older Fable 5 and Mythos 5. Fable is no longer the default pick: Opus 5.5 scores higher on Terminal-Bench 4.0 (66.4% against 55.8%) at 40% of the price. Anthropic’s own docs say to start with Opus 5.5 and move to Fable only if evals at the top effort levels still fall short.

What is the default effort level in Claude Code?

Medium for Opus 5.5, Sonnet 5.5 and Haiku 5.5, and high for most other models (Opus 4.7 defaults to xhigh). Through the API Sonnet 5.5 defaults to high instead. A sub-agent without its own effort setting inherits the session’s level, so a spawn from a low-effort turn runs at low.

Should I use Opus or Sonnet for writing?

Opus, for anything that runs through a multi-step writing pipeline. In my own eval both models met four of five expectations on a drafting task, but Sonnet skipped the de-AI pass in two of three runs and never ran the editor gate. Opus cost about seven times as much per run, which is cheap against a published article that skipped its review.

Is Haiku good enough for Claude Code sub-agents?

For searching, fetching and extracting, yes. Haiku 5.5 matched Sonnet 5.5 on every code-search run I gave it (34 of 34 files, no false positives) and did better on knowledge-base search, at a twentieth of Sonnet’s list price. Keep it away from reviews, root-cause analysis, grading and anything that needs facts it has not just read.