Which Claude Model Should You Use? Anthropic's Own Answer, in Six Rules

Claude Haiku 5.5 costs $0.10 in and $0.50 out per million tokens. Claude Fable 5.2 costs $8 and $40. That is an 80 times price gap, so which model should you actually use? Anthropic just answered that in writing, and the answer is not its best model: start most work on Claude Opus 5.5 at medium effort.

The answer comes from a playbook on Anthropic's site, "Which Claude model should you build with? Fable, Opus, Sonnet, or Haiku", by Addy Osmani. We turned it into six rules, each with Anthropic's number behind it.

The four models in 60 seconds

A token is a small chunk of text, and it is the thing you pay for. Prices below are per million tokens, going in and coming out.

Here is what is the same. All four can read up to one million tokens at once, and all four can write up to 128,000 tokens in one answer. So the difference is not size. It is skill, speed, and price. Paying more only makes sense when the job is hard enough to need it.

Rule 1: Start on Opus 5.5 at medium

Start on Opus 5.5, at medium effort, and move only when you have a reason. It is the default model in Claude Code, and it costs half as much as Fable for every token.

• Move down to Sonnet when the work is everyday and well scoped: a bug fix, a feature built against a clear spec, everyday documents, slides and spreadsheets, or a chat where a person is waiting for the reply.
• Move down again to Haiku for the simplest work at high volume: sorting, routing, tagging, pulling fields out of text, and helpers that search files, read logs, or summarize.
• Move up to Fable in three cases: the hardest technical projects in coding, finance, and the sciences (major refactors, big migrations, deep research), when Opus at high effort still falls short, and long runs with nobody watching.

One catch. A clear spec does not mean an easy job. Hard work stays on Opus. And if you are not sure, the article's table has a row for that too: "You aren't sure yet." Opus 5.5. Medium.

Rule 2: Turn the effort dial first

Before you change the model, turn the effort dial. Effort is how hard the model works on your task: how long it thinks, how many tools it calls, how much it checks its own work.

Anthropic put numbers on that dial for Opus 5.5, on a coding benchmark called SWE-bench Pro. Take high effort as the baseline:

That last row is a lot of money for one point. Past high, one more effort level can cost as much as a bigger model, so test the next model up at a lower effort instead. And more effort means a slower answer. It cannot give a model skill it does not have.

Rule 3: Price the task, not the token

Do not compare the price per token. Compare the cost per finished task, because a higher price per token does not always mean a higher cost per task.

Anthropic's example: on a hard coding benchmark, FrontierCode 2.0, Fable 5.2 at high effort scored 45.3%. Opus 5.5 at max effort scored 45.5%. That is level. But Fable got there for roughly half the cost per task. On that job, the model with double the price was the cheaper one.

So before you push Opus past high on a hard task, try Fable.

When you compare two models, price your hardest tasks, not just your typical ones. On one benchmark with twenty problems, just two of them carried 43% of the spend. Your hardest tasks are most of your bill.

Rule 4: Let Claude check its own work

This is the rule that has nothing to do with which model you pick. Give Claude a way to check its own work: a test, a build, a script that calls the real endpoint.

When a model is not good enough for a task, Anthropic gives you an order:

1. Check that the model can verify its own work.
2. Raise effort one level.
3. Only then move to the next model up, and start it at a lower effort than you used before.

And if you can check results automatically, run everything at low effort, then re-run only the failures at high. Anthropic tried it. With every task at high effort, 95.3% passed, at $0.29 a task. With low first and only the failures re-run at high, about 97% passed, at about $0.17 a task. A better score, for about 40% less.

Rule 5: Keep the big model's context lean

Context is everything the model is holding in the conversation. Every model here can hold one million tokens, but a large context costs you on every turn, because each turn sends it again.

On long runs, most of that bills as cache reads, which are cheap: on Opus, $0.20 per million tokens. But it adds up. In Anthropic's example, at 150,000 tokens of context each turn's cache read costs about $0.03. At 20,000, it costs less than half a cent. So keep the expensive model's context for the decisions, and let cheaper helpers do the long reading.

Rule 6: Mix models, and watch three traps

The easy way to mix models is subagents. A subagent is a helper that runs in its own context window and hands back a summary, and you pay for its tokens at the rate of the model it runs on.

The article's example is a log reader, saved in Claude Code as .claude/agents/log-reader.md with the model set to haiku. It reads test output and reports each failing case, and it never edits a file. Small models get the work where a mistake is cheap to spot: finding files, running tests, reading logs. Code edits and judgment calls stay on the main model.

For work bigger than one context window, a top model can lead a team of cheaper workers. On a bug hunt across about 22 million tokens of code, Opus leading Sonnet workers cost about a third less than Opus alone, and scored about the same.

The three traps

1. The prompt cache belongs to the model that wrote it. Switch models in the middle of a chat, and your first turn pays to write the whole conversation again. Switch at a natural break: run /compact first, or start a fresh session with a short written plan.
2. Move down a tier, and you lose the earlier reasoning. A model never reads the thinking of a model above it. The request still succeeds. The reasoning is just gone.
3. The built-in Explore subagent runs on your session's model in current Claude Code, not always on Haiku. To keep exploring cheap, define your own subagent named Explore and set the model to haiku.

To be fair: two shortcuts that did not clearly win

The opusplan alias plans with Opus, then makes the edits with Sonnet. That is the reverse of the advice above, so measure it on your own tasks first. And the advisor tool, where a cheaper model asks a stronger one for guidance? In the platform's own table, none of the four pairings clearly beat the model working alone. One pairing gained 1.7 points, for about double the money.

If you build on the API: four things that break

You cannot always change the model name and nothing else. Opus 5.5 and Fable 5.2 always think, so turning thinking off returns an error. Forcing a tool returns a 400 error on Sonnet, Opus, and Fable, so send auto and mark the tool strict. Fable 5.2 needs an append only message history. And going from Haiku 4.5 to Haiku 5.5, replace budget tokens with an effort level and drop any custom temperature. The simple fix is to build every request for the strictest model.

Test it on your own work

Do not take our word for any of this, or even Anthropic's. Pull a sample of real tasks and write a check for each one: a passing test, a closed ticket, a correct row count. Run each model at two or three effort levels, then plot score against spend. Keep a mixed setup only if it beats every single model on that chart.

The two minute version: in Claude Code, run one task from your backlog on two models with /model, then compare what /usage reports.

The right pick is not the best model. It is the cheapest setup that passes your check.

Get the Claude Model Lineup Sheet

All six rules are on one free cheat sheet: the task table, the prices, the effort numbers, and the subagent file, ready to copy. Comment LINEUP on the video, or grab it below.

How we covered this: every price and benchmark number is from Anthropic's article, read November 11, 2026. The 80 times and "about 40% less" figures are our arithmetic. List prices can change. Independent, not affiliated with Anthropic.