Quick summary: If you don't know which Claude model to pick, start on Opus 5.5 at
mediumeffort. Drop to Sonnet 5.5 when the work is well scoped and easy to check, and to Haiku 5.5 for simple high-volume work and subagents that read logs. Try Fable 5.2 when Opus athighstill falls short, or when the work is very large and full of decisions that constrain each other. Before you switch models, let the model check its own result, then adjust effort.
Take an example: today you open a repo and have three jobs. Fix a bug that already has a clear spec, migrate the whole codebase to a new framework version, and hand a subagent (a helper agent that runs in its own conversation) the test logs to read and report failures. All three can go to a coding agent, but none of them has to run on the same model as the other two.
This post folds model and effort (how much work the model puts into each turn) into one order of decisions. The numbers come from Anthropic's documentation, which I accessed on November 11, 2026, plus my own Claude Code usage history. The three jobs in the repo above are only an illustration, not a test run of mine. I start with the default, then cover when to leave it.

Which model should you start on?
Opus 5.5 at medium effort. Anthropic's guide to choosing a model also recommends starting most work on Opus 5.5 and treats adjusting effort as usually a better lever than switching models. The same guide gives a different path for simple high-volume work called through the API (Application Programming Interface): start on Haiku 5.5 and move up from there.
There are two practical reasons. According to the Claude Code model configuration docs, Opus 5.5 is the default model in Claude Code on the Pro, Max, Ultra, Team and Enterprise plans, and also when you run Claude Code with an Anthropic API key. At list price, each input and output token on Opus 5.5 costs half as much as on Fable 5.2.
Four models are generally available, one line each:
| Model | Good for |
|---|---|
| Haiku 5.5 | Simple, high-volume work: classification, extraction, reading logs, finding files, summarizing. |
| Sonnet 5.5 | Work that is well scoped and easy to check: fixing a bug with a spec, iterating on a feature. |
| Opus 5.5 | Everyday engineering: debugging, features that span several PRs, work where you decide as you go. |
| Fable 5.2 | Large, open-ended work: big refactors, migrations, architecture, deep research, leading many subagents. |
This table gives a starting point by type of work. It is not a ranking. A bigger model does not guarantee the right answer to every problem.
Don't confuse Mythos 5.2 with Fable 5.2. The two models have the same capabilities, but Mythos 5.2 is only open to organizations that have passed Anthropic's verification program for cybersecurity and life sciences. For ordinary users, Fable 5.2 is the highest tier you can pick.
Which models do I use?
From September 25, 2026 to November 10, 2026, the Claude Code history on my machine recorded the following number of model responses. One response is one message the model returned in the history, with duplicate records removed:
| Model | Responses | Share |
|---|---|---|
| Opus 5.5 | 85,691 | 87.6% |
| Fable 5.1 and 5.2 | 5,566 | 5.7% |
| Sonnet 5.5 and 5 | 4,651 | 4.8% |
| Haiku 5.5 and 4.5 | 1,961 | 2.0% |
Nearly nine out of ten of my responses are on Opus 5.5. Fable accounts for only a small share of responses.
This number has clear limits. It is the habit of one person on one machine, counted across every project in Claude Code. It does not measure output quality, does not compare the same job on two models, and is not a ratio I recommend you follow. I also have not run my own benchmarks or measured cost per job. Every benchmark figure in this post was run and published by Anthropic.
Which work goes down to Sonnet or Haiku, and which goes up to Fable?
Go down to a smaller model when the scope is clear, the result is easy to check and redoing it is cheap. Go up to a bigger model when the work has many decisions that constrain each other, or when the current model still fails even though it has the tools to check itself.
The table below gives starting points by type of work. I paraphrased it from Anthropic's model selection guide of November 9, 2026. You pick effort at the same time as the model.
| Work | Starting model | Starting effort |
|---|---|---|
| Everyday engineering, debugging, features that span several PRs | Opus 5.5 | medium, then high |
| Well-scoped code: bug fixes, feature iteration, working from a spec | Sonnet 5.5 | medium, then high |
| Subagents that find files, read logs, summarize | Haiku 5.5 or Sonnet 5.5 | The model's default |
| High-volume classification, routing, labeling, extraction | Haiku 5.5 | medium |
| Chat and interactive sessions | Sonnet 5.5, or Haiku 5.5 if simple and high-volume | low or medium |
| Repeated agent work: investigation, code review, drafting | Sonnet 5.5 | medium |
| Everyday documents, slides, spreadsheets | Sonnet 5.5, Opus 5.5 for complex financial models | high on the API, medium in Claude Code |
| Computer use and vision-heavy work | Opus 5.5 | medium |
| Big refactors, migrations, architecture, leading many subagents | Fable 5.2 | medium, then high |
| Deep research, scientific or quantitative analysis | Fable 5.2 | medium, then high |
| Not sure how hard the work is | Opus 5.5 | medium |
Applied to the three jobs: the bug with a clear spec starts on Sonnet 5.5, the whole-codebase migration starts on Fable 5.2, and the log-reading subagent starts on Haiku 5.5 and moves to Sonnet 5.5 if Haiku's summary misses things.
Two places are easy to apply mechanically. A clear spec does not automatically mean Sonnet is enough: if the bug sits in a part of the system with many hard-to-see dependencies, Opus is still the safer choice. And not every migration needs Fable: for a small upgrade with a guide and runnable tests, starting on Opus is enough.
If the hardest part of your work is not knowing what information you are still missing before you write code, I wrote separately about putting the strongest model on that step in Fable 5 and the unknowns problem: fix the map before you code.
When the result is not good enough, do you raise effort or switch models?
Take three steps, in this order:
- Let the model check its own work with tests, a build or a script.
- Raise effort one level.
- If you are already at
highand it still falls short, try a bigger model at lower effort before you push the current model toxhighormax.
Step 1 comes first because, according to Anthropic's guide, it is usually cheaper and faster than raising effort. A model that can run the tests sees for itself where it went wrong, while raising effort only makes it put more work into a job that still has no way to be checked.

What is effort, and what is the default?
Effort is not how long the model gets to sit and think. According to the effort docs, it adjusts the total amount of work the model puts into each turn. Anthropic's guide adds that raising effort makes a turn run longer but does not give the model more knowledge or skill. It also does not make up for information missing from the request.
All four models have five levels: low, medium, high, xhigh, max. It is easy to assume medium is the default everywhere. That is only true in Claude Code:
| Model | Default on the Claude API | Default in Claude Code |
|---|---|---|
| Haiku 5.5 | medium | medium |
| Sonnet 5.5 | high | medium |
| Opus 5.5 | medium | medium |
| Fable 5.2 | high | medium |
The practical consequence: if you move a job from Claude Code into code that calls the API and don't pass an effort, Sonnet 5.5 and Fable 5.2 run at high, higher than the level you are used to.
In Claude Code, you view and change effort with the commands below, typed into the Claude Code input box. The four commands are independent. You don't run them in sequence:
/effort
/effort high
/effort status
/effort auto/effort with no argument opens a slider. /effort status shows the level in use. /effort auto clears the level you set and returns to the model's default. A level typed after /effort is saved as your default for later sessions, except max. To change it for the current session only, open /effort and press s.
Is raising effort worth the money?
In the Anthropic measurement below it is, up to high. Above that, each percentage point costs a lot more.
Anthropic measured Opus 5.5 on a 478-task subset of SWE-bench Pro and published the results in its docs on optimizing for cost and intelligence:
| Opus 5.5 effort | Resolve rate | Cost per task |
|---|---|---|
low | 87.4% | $0.11 |
medium | 92.8% | $0.21 |
high | 95.3% | $0.29 |
xhigh | 96.7% | $0.74 |
From medium to high, you gain 2.5 points while the cost goes from $0.21 to $0.29. From high to xhigh, you gain only 1.4 points but pay about 2.5 times as much. The xhigh level has a single run, and the other levels are the average of two.
These are internal measurements, run in Anthropic's own evaluation environment, capped at 16,384 tokens per turn, and carried out on September 19 and 20, 2026. Anthropic states that these rates cannot be compared with the public SWE-bench Pro leaderboard.
The same document has a way of using effort that is more worth trying: run every task at low first, then rerun only the failed ones at high. This resolved between 96.4% and 97.5% at about $0.17 per task. Running everything at high from the start resolved 95.3% at $0.29. The condition is that you need a check that tells you which tasks failed. That is why step 1 comes before step 2.
When should you try a bigger model?
When the current model is already at high and still falls short. At that point a bigger model at lower effort can give a comparable result at lower cost, but not always.
According to the Fable 5.2 announcement, in early testing on FrontierCode 2.0, Fable 5.2 at high scored 45.3%, close to Opus 5.5 at max with 45.5%, at about half the cost per task. The "half" figure is Anthropic's. I could not recompute it because the post does not give the underlying costs.
Another Anthropic measurement points the other way. On 463 tasks from the SWE-bench Pro set above, Opus 5.5 at xhigh resolved 96.5% at $0.75 per resolved task. Fable 5.2 at high resolved 96.3% at $1.39. The two scores are close, and Opus costs slightly more than half of what Fable does. Anthropic notes that only the problem set is matched, not the grading setup: Fable was graded in an environment without network access and Opus with it, and the Fable costs are estimates.
The two Anthropic documents also set different thresholds. The November 9 guide says to go up to Fable when Opus at high still falls short. The guide to choosing a model says to move to Fable 5.2 when your evaluation at xhigh or max still does not pass. I read the two this way: Opus falling short at high is the moment to try Fable on that same job, while changing your default to Fable waits until Opus at the higher levels does not pass either.
Back to the example. For the bug with a clear spec, let Sonnet run the tests first. If it still fails, go to high, and only then to Opus at medium. For the migration: if it is a small upgrade you started on Opus and at high it still keeps tripping on architecture decisions, try Fable at medium on that same piece of work and compare the results.
How far apart are the four models on price and limits?
Each tier costs twice the tier below it for input and output tokens, except that Haiku 5.5 is as much as 20 times cheaper than Sonnet 5.5 on short prompts. But two details keep that ratio from being fixed: Haiku's price changes with prompt length, and Fable's cache read price is exactly the same as Opus's. Cache read is the input the model rereads from the prompt cache, the store that keeps the start of the conversation so it does not have to be processed again.
Claude API list prices, in USD per million tokens, from Anthropic's pricing page, accessed on November 11, 2026:
| Model | Input | Output | Cache read |
|---|---|---|---|
| Haiku 5.5, prompts up to 100K tokens | $0.10 | $0.50 | $0.01 |
| Haiku 5.5, prompts over 100K tokens | $0.50 | $2.50 | $0.05 |
| Sonnet 5.5 | $2 | $10 | $0.10 |
| Opus 5.5 | $4 | $20 | $0.20 |
| Fable 5.2 | $8 | $40 | $0.20 |
On limits the four models are the same: a context window of 1 million tokens and up to 128K output tokens per synchronous API call, according to the model overview table.
Haiku is cheapest, as long as the prompt is short
Haiku 5.5's 100K token threshold counts the entire input of a request, including cache reads and cache writes. Past the threshold, the whole request is billed at the higher price, including the part served from cache. Input then costs five times as much, though that is still only a quarter of Sonnet 5.5.
So for a subagent that always has to read a long prompt, don't compare unit prices. Compare the cost per finished job.
In a long session, almost all input is cache reads
Cache reads are much cheaper than fresh input. In a long session, nearly all input is of this kind.
My history shows this. On Opus 5.5, over the same period from September 25 to November 10, 2026, 18.64 billion out of a total 19.10 billion input tokens were cache reads, or about 97.6%. This number does not say how much money I saved, because I have not measured cost per job. It only shows that, counted in tokens, almost all input is cache reads. Counted in money it looks different: the remaining 2.4% is almost entirely cache writes, which cost 25 to 40 times as much as a cache read on Opus 5.5, so they still make up a sizable part of the input bill.
Two consequences follow:
- Moving up to Fable does not make cache reads cost more: still $0.20 per million tokens. What costs twice as much is fresh input, cache writes and output. Total cost per job can still more than double, because Fable may use a very different number of tokens. In Anthropic's SWE-bench Pro measurement, each resolved task cost $1.39 on Fable 5.2 at
high, compared with $0.30 on Opus 5.5 athigh. These two figures carry the same grading caveat as in the previous section. - The more the context grows, the more each turn costs. According to the post on what a task costs on Opus 5.5, each turn that rereads 150K tokens of context costs about $0.03, while 20K tokens costs only about $0.004. Both figures are for Opus 5.5. Multiply by a few hundred turns and you see why it pays to keep the expensive model's context lean and let a cheap subagent do the long reading.
Fast mode: faster, at twice the price
Among these four models, fast mode is only available on Opus 5.5 and Fable 5.2. According to the fast mode docs, it speeds up output generation by up to 2.5 times, does not shorten the time to first token, and costs twice the standard price: $8 and $40 for Opus 5.5, $16 and $80 for Fable 5.2. Fast mode uses a separate cache, so toggling it mid-session costs you the cache once.
Price the tail, not the average
On one 20-task run of WideSearch, an external benchmark, carried out and published by Anthropic with three attempts per task, two tasks accounted for 43% of total cost, while the cheapest half of the tasks accounted for only 10%. When you compare two configurations, look separately at the hardest jobs in your set, because they carry most of the bill.
How do you choose on a Pro or Max plan?
Choose by usage limits, not by price per million tokens. The price table in the section above is for the API. On a subscription plan, the real question is whether this week's limit is enough to finish the work.
Three things worth knowing:
- Keep the default of Opus 5.5 at
medium. That has been the built-in setting in Claude Code since v2.1.280. Runclaude --versionin a terminal to check. To pick Fable 5.2 you need v2.1.321 or later. - Fable uses your limits in its own way. It can count against usage credits, a balance separate from the plan's limit. This depends on your plan, and on the Team plan it depends on your seat type within the team. According to the Fable 5.2 launch offers page, the Pro plan and standard seats on the Team plan can use Fable for up to 50% of the weekly limit, through the end of November 16, 2026, Pacific Time. After that, or once the 50% is used up, Fable counts against usage credits if you have turned them on. In the
/modelpicker, the Fable row reads "Requires usage credits" when it counts against that balance. - Fast mode on subscription plans only counts against usage credits, not against the plan's limit.
You don't need to know how to program to check for yourself which model suits you. Pick a job with a clear result, run it on Opus 5.5, then open a new session and run exactly the same job, with the same request, on Sonnet 5.5. If the job edits files, do it in two copies of the same folder, so the second run does not inherit the results of the first. Use two commands:
/model
/usage/model opens the model picker. Your choice is saved as the default, and if you only want to change it for the current session, press s in the picker. /usage shows the session's cost and how much of the plan's limit you have used.
Note /usage before and after each run, then compare three things: whether the result meets the request, how many times you had to correct it, and how far /usage moved. The session figure and the plan limit bars are two different things. The limit bars include anything else you run on the same account, so do not run other work while you measure. If Sonnet finishes the job and uses less of your limit, move that type of work down to Sonnet. What you are comparing is the total limit spent to get an acceptable result, corrections included.
How do you mix several models in one job so that it pays off?
Give the easy-to-check parts to a small model, and keep the decisions and the code edits on the main model. The three approaches below are ordered by how worthwhile they are: switching models at the right moment, putting subagents on a small model, and only then Advisor and teams of parallel subagents.
Switch models at a pause point
Switching models mid-session has two costs. Switch when a phase is done and the tests have run.
The first is the cache. According to the Claude Code prompt caching docs, each model has its own cache, so after you switch with /model, the next request reads nothing from the old cache and has to write the whole conversation again. Anthropic's guide recommends running /compact before switching so there is less to rewrite.
The second is thinking blocks, the notes the model wrote for itself while reasoning in earlier turns. According to the docs on preserved thinking, on the Claude API, when you move up a tier the new model can read them, and when you move down it cannot. Fable 5.2 can read thinking blocks from Opus 5.5, Sonnet 5.5 and Haiku 5.5. In the other direction, Sonnet and Haiku cannot read Opus's blocks, and none of the other three models can read Fable 5.2's blocks. Blocks that cannot be read are skipped silently, with no error. They stay in the history, and the earlier model can read them again if you switch back. So before you move down a tier, have the model write out what has been decided and what is left to do.
Give subagents to a small model
A subagent that only reads and reports is the best fit for Haiku. In my history, 30.7% of Haiku responses ran in subagents, compared with 22.8% for Opus, 21.2% for Fable and 18.9% for Sonnet. That is a distribution of usage, not a measurement of how much Haiku saves.
In Claude Code, you set the model for each subagent with the model field in its definition file. The example below follows Anthropic's guide and lives at .claude/agents/log-reader.md:
---
name: log-reader
description: Reads test output and logs, reports each failure
tools: Read, Grep, Glob
model: haiku
---
Read the log you are given. For each failure, report the file name, the test name and the first error line.
Do not modify code.Call it with a sentence like "Use the log-reader subagent to read test.log and report the failures". If this is the first file in the .claude/agents/ directory, restart Claude Code so it gets loaded.
According to the subagent docs, the model field accepts haiku, sonnet, opus, fable, a full model ID or inherit. The CLAUDE_CODE_SUBAGENT_MODEL environment variable sets the model for subagents that declare nothing, but it ranks below the model passed at call time and below the model field in the file.
Three places where people trip:
- The
haikualias is not always Haiku 5.5. On the Anthropic API it points to Haiku 5.5, which needs Claude Code v2.1.293 or later. On Amazon Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS it still points to Haiku 4.5, a model priced at $1 and $5 per million tokens, ten times Haiku 5.5 on short prompts. To be sure, write the full model ID or setANTHROPIC_DEFAULT_HAIKU_MODEL. - The built-in Explore subagent runs on the session's model. It does not use Haiku on its own. One exception: when the session runs Fable on a subscription plan, an Anthropic Console account or a gateway connected through
ANTHROPIC_BASE_URL, Explore switches to the model theopusalias points to. If you want code exploration to be cheaper, create a subagent namedExplorewithmodel: haiku. - The
opusplanalias does the opposite of the advice in this section: Opus plans, Sonnet writes the code. Every time you enter or leave plan mode is a model switch and a fresh cache write. Measure before you make it your default.
I take apart how another tool assigns models by role in the guide Model routing in Oh-my-pi (OMP), for Subscribers.
Advisor and subagent teams: measure before you turn them on
Both approaches sound reasonable, but Anthropic's own measurements are fairly cautious.
Advisor is an experimental feature that lets a main model consult a stronger model at hard steps. In the cost optimization docs, Anthropic measured Opus 5.5 at high with Fable 5.1 as Advisor on 370 coding tasks: it scored 90.1% at $2.92 per attempt, compared with 88.4% and $1.38 when Opus ran alone. That is 1.7 more points at about 2.1 times the price, and Anthropic describes the gain as close to the run-to-run noise threshold.
None of the other pairs in the same table wins clearly, and one scores lower than running alone. I compare the kinds of Advisor in a separate guide on Advisor, for Subscribers.
Teams of parallel subagents do have one better result, under a narrow condition. Anthropic had models find 130 planted bugs in about 22 million tokens of Python code, with up to 25 subagents at once. The numbers below are the average of 10 runs on Claude Managed Agents, with subagents running at their default effort, which is high for Sonnet 5.5 and medium for Haiku 5.5. F1 is a score that combines finding all the bugs with finding only real ones, with a maximum of 1:
| Configuration | Average F1 | Cost per run |
|---|---|---|
Opus 5.5 at medium running alone | 0.827 | $200 |
Opus 5.5 at high leading Sonnet 5.5 subagents | 0.831 | $139 |
Opus 5.5 at high leading Haiku 5.5 subagents | 0.677 | $47 |
Opus leading Sonnet is about 30% cheaper with nearly the same score. Switching to Haiku is cheaper still, but the score drops clearly. Anthropic also notes that this split only pays off when a few hard jobs account for most of the cost, or when the job is larger than one context window. For a chain of steps that depend on each other, like the core of the migration in the example, a single model running alone at lower effort did better in measurements on previous-generation models.
What should you review before switching models on the API?
Review the five points below, because changing the model ID while keeping the old configuration can return a 400 error. If you only use Claude Code and don't call the API yourself, you only need to read the last point.
- Thinking is always on for Opus 5.5 and Fable 5.2. Passing
thinkingasdisabled, or asenabledwithbudget_tokens, returns a 400 error either way. Sonnet 5.5 also returns a 400 error when thinking is turned off. tool_choicewith a value ofanyortoolreturns a 400 error on Sonnet 5.5, Opus 5.5 and Fable 5.2. Useautoand say clearly in the prompt when a tool call is needed.- With Fable 5.2, editing any content that comes before a stored thinking block returns a 400 error. The same goes for Opus 5.5, Sonnet 5.5 and Haiku 5.5 on accounts created from August 31, 2026. Keep the conversation history append-only.
- From Haiku 4.5 to Haiku 5.5: change
thinkingfromenabledwithbudget_tokensto{"type": "adaptive"}, or drop the field, then set the effort level inoutput_config.effort. Endingmessageswith an assistant turn to prefill the answer returns a 400 error. The Haiku 5.5 docs saytemperature,top_pandtop_kcan return errors. The Haiku 5.5 migration guide says to omit them. The same text also produces about 30% more tokens than on Haiku 4.5. - Safety fallback in Claude Code differs by model. A request blocked by the classifier on Fable or Opus 5.5 is rerun on Opus 4.8 if it falls in the cybersecurity category, and on Opus 5 if it falls in the biology category. Sonnet 5.5 falls back to Sonnet 5 for the cybersecurity category and refuses the biology category. After a fallback, the session stays on the fallback model, so check again with
/model.
The fixed model IDs of the four models are claude-fable-5-2, claude-opus-5-5, claude-sonnet-5-5 and claude-haiku-5-5.
So what do you decide today?
Four decisions, in order:
- The default is Opus 5.5 at
mediumeffort. - Go down to Sonnet 5.5 when the work is well scoped and checkable. Go down to Haiku 5.5 for simple high-volume work and read-only subagents.
- Try Fable 5.2 when Opus at
highstill falls short, or when the work is large and full of decisions that constrain each other. - Adjust effort before you switch models, and let the model check itself before you adjust effort.
The benchmark figures in this post are Anthropic's, measured under their conditions. To get an answer for your own work, measure it yourself with the four steps Anthropic's guide suggests:
- Take a few real jobs, each with a check on the result: tests pass, the support request can be closed, the number of data rows matches.
- Run each model at two or three effort levels, each in its own session, starting from the same repo state.
- Compare results against cost or limit used. Keep a mixed-model configuration only if it gives equal or better results at lower cost than every single-model configuration.
- Run the new configuration in parallel on a slice of real work, in a separate copy, before you switch over fully.
Use this piece in your agent
Get an API keyCopy the text below and paste it into Claude Code, Codex or whichever agent you use. The agent reads the piece and checks it against the repo you have open.
Read "Which Claude model should you use: Fable 5.2, Opus 5.5, Sonnet 5.5 or Haiku 5.5?" on modernEngineer and apply it to this repo.
1. Call the content_get tool of the modernengineer MCP server with locale "en", slug "chon-model-claude-fable-opus-sonnet-haiku". If MCP is not connected or access is refused, read the page https://modernengineer.dev/en/library/chon-model-claude-fable-opus-sonnet-haiku instead.
2. Summarize the main steps of the piece and point out which apply to this repo.
3. Propose concrete changes and ask me before editing any file.Connect MCP in Claude Code (once)
claude mcp add --transport http modernengineer \
https://api.modernengineer.dev/mcp \
--header "Authorization: Bearer <API key>"This piece is open to everyone: without MCP, the agent can still read it straight from the link.
- Version
- v1.0.0
- Updated
- 11/11/2026
- Licence
- All rights reserved
- Slug
- chon-model-claude-fable-opus-sonnet-haiku


