Claude Models Explained: Fable vs Opus vs Sonnet vs Haiku (and Mythos) — Which One for Which Job
Claude now comes in four models you can actually pick from — Fable, Opus, Sonnet and Haiku — and the honest answer for most readers is the simplest one: start with Claude Opus 5.5. It is the model Anthropic itself recommends as the default for most workloads, it is the strongest daily driver in the family, and it costs half as much as the flagship. Go up to Claude Fable 5.2 only when a job is genuinely hard, long, or agentic enough to need the frontier model. Go down to Claude Sonnet 5.5 for everyday coding and writing, and down to Claude Haiku 5.5 for high-volume work where speed and price matter more than depth. Claude Mythos 5.2 is real, but it is not a fifth choice on that list: it is the same underlying model as Fable 5.2, with some safeguards relaxed, and it is available only to organisations verified through Anthropic’s verification programs — so if you are not in one of those programs, you will never see Mythos in your model picker, and you get Fable instead. This guide compares the four pickable models on price, context, speed, thinking and task fit, with every price and specification checked against Anthropic’s own documentation. Checked 13 November 2026. Prices and model availability change often, so treat the figures here as the position on that date and check Anthropic’s pricing page before you budget a project.

The Short Answer: Which Claude Model Should You Use?
<img src="

” alt=”A person at a desk choosing between four glowing pathways on a screen, warm light, shallow depth of field”>
If you only read one section of this guide, read this one. The Claude family is a ladder, and the right rung depends on the job in front of you, not on which model is newest or most powerful. Anthropic’s own advice, printed on its models overview page, is direct: “If you’re unsure which model to use, start with Claude Opus 5.5 for most workloads. Use Claude Fable 5.2 for demanding reasoning and long-horizon agentic work, or when your evals on Claude Opus 5.5 at higher effort still fall short.” The launch announcement for Fable 5.2 says the same thing in plainer language: “For most coding and knowledge tasks, we recommend that users start with Claude Opus 5.5, our strongest daily driver, and then switch… upward to Fable or Mythos, or downward to Claude Sonnet 5.5 or Claude Haiku 5.5.” That is the whole picker in one sentence, and the rest of this guide is the evidence behind it.
Here is the picker in one paragraph. Use Claude Opus 5.5 as your default: it handles long-running coding projects, serious knowledge work, and anything you would call your main job, at $4 per million input tokens and $20 per million output tokens. Use Claude Fable 5.2 when the work is at the edge of what Opus can do — agent sessions that run for hours, multistep research that has to end in a finished document, spreadsheet or deck, or reasoning so demanding that Opus at its highest effort still falls short. It costs twice as much as Opus, $8 in and $40 out per million tokens, and it earns that price only on work that is genuinely hard. Use Claude Sonnet 5.5 for the everyday middle: routine coding, drafting and editing, and most production applications, at $2 in and $10 out per million tokens, with the best balance of speed and intelligence in the family. Use Claude Haiku 5.5 when volume and latency are the point — classification, extraction, routing, and fleets of subagents — at $0.10 in and $0.50 out per million tokens for prompts under 100,000 tokens, which makes it eighty times cheaper than Fable on a typical small job. And Claude Mythos 5.2 is not on this list because it is not a choice you make: it is Fable 5.2 with cybersecurity and biology safeguards relaxed, available only to verified organisations, at exactly Fable’s price and specifications.
Three facts keep the whole comparison honest. First, all four current models share the same context window — one million tokens — and the same maximum output of 128,000 tokens, so the difference between them is not how much they can read but how well they reason about what they read. Second, all four share the same knowledge cutoff, June 2026, so a newer model does not know more recent events than an older one. Third, the price ladder is steep on purpose: Fable costs two times Opus, four times Sonnet and eighty times Haiku on the same small job, so picking the biggest model by default is the most expensive habit in the family. The skill is not knowing which model is best in the abstract. It is knowing which model is enough for the job in front of you, and this guide works through that job by job.
A note on how this guide is built, because it matters for trust. Every price, specification and benchmark figure in it comes from Anthropic’s own pages — the models overview and API pricing documentation, the Fable and Mythos model pages, the Haiku 5.5 model page, the effort documentation, the plans and pricing page, and the 9 November 2026 launch announcement — all read in full on 13 November 2026. Benchmark figures are Anthropic’s own self-reported numbers, labelled as such wherever they appear, and the one benchmark where Opus 5.5 beats Fable is stated, not hidden. No figure in this guide comes from a comparison site or a third-party benchmark board. Where something could not be confirmed from an Anthropic source — exact per-plan model availability inside the apps, for example — this guide says so rather than guessing.
The Claude Lineup at a Glance (November 2026)

The current Claude lineup changed on Monday 9 November 2026, when Anthropic announced Claude Fable 5.2 and Claude Mythos 5.2, a new generation at the top of the family. Fable 5.2 replaced Fable 5.1 as the flagship, at a lower price — $8 per million input tokens and $40 per million output tokens, down from $10 and $50 — and with, in Anthropic’s words, outputs up to 30% faster than the 5.1 generation. Opus 5.5, Sonnet 5.5 and Haiku 5.5 were already the current versions of their lines, and they remain so. The result is a four-model family with a clear order: Fable at the top for the hardest work, then Opus, then Sonnet, then Haiku for the fastest and cheapest work. Mythos 5.2 sits alongside Fable, not above it, because it is the same model behind a different set of safeguards.
Here is the whole lineup in one table. Prices are US dollars per million tokens, standard API rates with global routing, which is the default. All four current models accept text and image input, produce text output, and support multilingual work, vision and tool use.
| Model | Model ID | Price in / out per MTok | Context | Max output | Speed | Thinking | Default effort | Knowledge cutoff |
|---|---|---|---|---|---|---|---|---|
| Claude Fable 5.2 | claude-fable-5-2 | $8 / $40 | 1M tokens | 128K tokens | Moderate | Adaptive, always on | high | June 2026 |
| Claude Opus 5.5 | claude-opus-5-5 | $4 / $20 | 1M tokens | 128K tokens | Moderate | Adaptive, always on | medium | June 2026 |
| Claude Sonnet 5.5 | claude-sonnet-5-5 | $2 / $10 | 1M tokens | 128K tokens | Fast | Adaptive | high | June 2026 |
| Claude Haiku 5.5 | claude-haiku-5-5 | from $0.10 / $0.50 | 1M tokens | 128K tokens | Fastest | Adaptive | medium | June 2026 |
| Claude Mythos 5.2 | claude-mythos-5-2 | $8 / $40 | 1M tokens | 128K tokens | Moderate | Adaptive, always on | high | June 2026 |
Two things about that table deserve attention before anything else. The first is how uniform it is. Every current model has the same one-million-token context window, the same 128,000-token maximum output, and the same June 2026 knowledge cutoff. That uniformity is recent and deliberate: in the previous generation, context windows differed between models, and the cheapest model was also the one that could read the least. That is no longer true. A Haiku 5.5 request can hold just as much context as a Fable 5.2 request; the difference is what each model does with it. The second is the price spread. Fable costs eighty times Haiku’s starting rate, and the steps between models are exact doublings on the way down from Fable to Opus to Sonnet — $8, $4, $2 per million input tokens — which makes the cost of moving up a tier easy to calculate and hard to ignore.
Haiku’s “from” in the price column is the one trap in the table, and it is explained in full later in this guide: Haiku 5.5 is priced by prompt length, so short prompts cost $0.10 in and $0.50 out per million tokens, but prompts over 100,000 tokens cost five times as much. Nothing else in the table has a hidden condition like that, and it is the single most important pricing detail in the whole family for anyone building high-volume systems.
The launch itself is worth a short paragraph because it explains why the family looks the way it does now. Anthropic announced Fable 5.2 and Mythos 5.2 together, on 9 November 2026, as a single model with two different safety postures: Fable carries strong cybersecurity and biology safeguards so it can be available to all users, while Mythos has those safeguards relaxed and is available only to verified organisations. Anthropic’s own words are worth quoting because they settle the relationship exactly: “Claude Fable and Claude Mythos are the same underlying model.” The launch also brought a price cut at the top — $8 and $40 per million tokens against $10 and $50 for the 5.1 generation, a 20% reduction — and, Anthropic says, outputs up to 30% faster than the 5.1 generation. For the full launch detail, see our coverage of the Fable 5.2 and Mythos 5.2 launch; this guide is the picker, not the news, so it takes the launch as its starting point and spends its time on which model fits which job.
One more piece of context belongs here: where you can actually use these models. All four are available through the Claude Platform API, through the Claude apps (claude.ai, desktop and mobile), through Claude Code, and through AWS, Google Cloud and Microsoft Foundry. Subscription-plan limits apply inside the apps, and which models appear in the app depends on your plan — the exact per-plan availability is not stated in a form this guide could verify from Anthropic’s pricing page, so it is not stated here as fact. What is confirmed is that Fable needs a paid plan: on Pro it is available through usage credits, and on Max and Ultra it is included up to half of the weekly usage limit. The API prices in the table above are Anthropic’s first-party prices; cloud-platform prices are set by the providers themselves and are not quoted here.
Claude Fable 5.2: The Frontier Model for the Hardest Jobs

Claude Fable 5.2 is the most capable model Anthropic makes, and the most expensive one you can buy from them. Its own one-line description in the documentation is “For demanding reasoning and long-horizon agentic work,” and that is a precise summary of where it belongs. Fable is the model for work that runs for hours rather than minutes: agent sessions that keep going, multistep deep research that has to end in a finished document, spreadsheet or deck, and analysis carried through to a completed deliverable rather than a first draft. It is also the model Anthropic casts in the Advisor and Orchestrator roles — the model other models consult, and the one that delegates simpler tasks down to smaller models while it keeps the hard reasoning for itself. If your work does not look like that, Fable is probably more model than you need, and the rest of this guide will show you the cheaper rung that does the same job.
What Fable actually does better than Opus is depth and persistence. In Anthropic’s own benchmark table, Fable 5.2 leads Opus 5.5 on most of the tests that measure long, hard work — agentic coding, long-horizon science, knowledge work and computer use — and the gaps are widest where the work runs longest. On FrontierCode 2.0, a test of agentic coding, Fable 5.2 scores 49.1% at Xhigh effort against Opus 5.5’s 45.5%. On Humanity’s Last Exam with tools, it scores 74.2% against Opus’s 67.7%. On RoboDojo Sim, a robotics benchmark, the gap is dramatic: 64.9% against 39.4%. These are Anthropic’s own self-reported numbers, and the full table, with its caveats, is examined later in this guide. The pattern they show is consistent: Fable’s advantage grows as the task gets longer, more open-ended and more dependent on sustained reasoning. On short, well-defined tasks the advantage shrinks, and on some measures Opus actually leads — Opus 5.5 scores higher than Fable on the AA-Briefcase Elo measure of knowledge work, 1800 against Fable’s 1785, even though Fable leads on the same test’s rubric score. That single row is a useful warning against treating “most capable” as “best at everything”.
Fable’s thinking is always on. Like Opus 5.5, it uses adaptive thinking that cannot be turned off; you control the depth with the effort parameter — low, medium, high, xhigh or max — and Fable’s default effort is high, against Opus’s medium. In practice that means Fable thinks hard by default and you have to deliberately turn it down, while Opus thinks at a medium depth by default and you turn it up when a job demands it. That default matters for cost, because deeper thinking means more output tokens, and output tokens on Fable are the most expensive in the family at $40 per million. A Fable request that thinks at length is a Fable request that bills at length.
Two Fable details are easy to miss and expensive to learn the hard way. The first is fast mode. Fable 5.2 supports a fast mode that delivers up to 2.5 times the output tokens per second, at a premium price of $16 in and $80 out per million tokens — double the standard rate. It is available on Claude Code, the Claude Platform, Google Cloud and Microsoft Foundry, and it is not available with the Batch API. Fast mode is a speed purchase, not a capability purchase: the model is the same, the answers are the same quality, they just arrive faster. The second is data retention. Fable 5.2 requires 30-day data retention, and it is not available under zero data retention unless Anthropic expressly authorises it. If your organisation’s policy is zero retention, that alone may decide the question, and you should confirm the position with Anthropic before building on Fable.
Fable also carries the strongest safeguards in the family, and they shape what it will and will not do. Its classifiers block most penetration testing, exploit generation, binary vulnerability work and most research-biology requests. When a request is blocked, it does not simply fail: Anthropic says blocked cyber and biology queries fall back transparently to another model — Opus 4.8 for cybersecurity and Opus 5 for biology. Anthropic also says safeguard false positives are down by about 55% against Fable 5.1 in early testing, which is its own claim, not an independent measurement. The practical point for most readers is simple: Fable is the frontier model you can actually use, with the frontier’s safety limits built in. If your work is the kind those safeguards block, Fable is not the model for it — Mythos is, and that is a different door with a different key, covered later in this guide. For long-running agent work, our report on Claude’s managed agents in self-hosted beta shows the kind of persistent, multi-step work Fable is built to drive.
The honest test for Fable is a sentence, not a benchmark. If you can describe your job as “this runs for hours, it has many steps, and the result has to be a finished deliverable,” Fable is worth its price. If you can describe it as “I need a good answer to a hard question,” Opus 5.5 at half the price is almost certainly the better buy. Anthropic says so itself, and the next section explains why.
Claude Opus 5.5: The Default Most People Should Start With

Claude Opus 5.5 is the model this guide recommends first, because Anthropic recommends it first. Its documentation description is “For long-running agentic coding and knowledge work,” and the launch announcement calls it “our strongest daily driver.” Those two phrases together describe a model that is built for the work most serious users actually do: coding projects that span days, research and writing that requires sustained attention, and knowledge work where the answer has to be right, not just fast. It is the strongest model in the family that is available to everyone without conditions, and at $4 in and $20 out per million tokens it costs exactly half of Fable. That combination — strongest generally available model, half the flagship’s price — is why it is the default.
Opus earns the default on capability, not just on price. In Anthropic’s own benchmark table it is close behind Fable on most measures and ahead on at least one that matters: on AA-Briefcase, a knowledge-work benchmark, Opus 5.5 scores 1800 Elo against Fable’s 1785, even though Fable leads on the same test’s rubric score. On FrontierCode 2.0 it scores 45.5% against Fable’s 49.1% — behind, but not far behind, and ahead of GPT-6 Astra at 42.8% and Gemini 4 Carbon at 41.1% in Anthropic’s own table. On OSWorld 2.1, a computer-use benchmark, it scores 87.2% against Fable’s 89.3%. The picture is a model that is within a few points of the flagship on the hardest tests and ahead of it on at least one — which is exactly what a daily driver should look like. All of these figures are Anthropic’s own self-reported numbers, and the full table with its limits is covered later in this guide.
Opus’s thinking works the same way as Fable’s, with one difference that matters in practice. Its adaptive thinking is also always on and cannot be turned off, but its default effort is medium rather than Fable’s high. That makes Opus cheaper to run by default, because it thinks less deeply before answering, and it makes the effort parameter a genuine dial: turn it up to high, xhigh or max when a job is hard, and leave it at medium when it is not. Anthropic’s own guidance points the same way: use Fable “when your evals on Claude Opus 5.5 at higher effort still fall short.” In other words, the workflow Anthropic expects is to start on Opus, push its effort up, and only move to Fable when the results still do not meet your standard. That is a practical, testable rule, and it is cheaper than starting on Fable and working down.
Where Opus beats Fable on value is everywhere except the extreme edge. On the worked example later in this guide — 10,000 input tokens and 2,000 output tokens — the same job costs $0.08 on Opus and $0.16 on Fable. On a monthly volume of one million input tokens and 200,000 output tokens, Opus costs $8 and Fable costs $16. Those are not large sums in isolation, but they double at every scale, and they double again if you are running agents that think at length: Fable’s higher default effort means more output tokens per request, and its output tokens cost twice as much. The question is never whether Fable is better — on the hardest work it is — but whether the work in front of you is hard enough for the difference to show. For most coding and knowledge work, the answer is no, and Opus is the model that proves it.
Opus is also the model where the coding-agent reality check matters most. Coding agents are the flagship use case for Opus, and they are also the use case where expectations most often outrun results: independent reporting on coding agents has found they finish only about one task in four without help, and the details of that gap are worth reading before you hand a long project to any model, Opus included. Our report on coding agents failing a TPU move is a useful counterweight to the benchmark table: the models are strong, and they still fail in specific, instructive ways. Opus is the right default because it is strong enough for the work and cheap enough to use for all of it — not because it never fails.
The rule for Opus is the simplest in this guide. If you do not know which model to use, use Opus 5.5. If you know your job is everyday work, use Sonnet and save half the cost. If you know your job is at the edge of what models can do, use Fable. Opus is the centre of the family, and the centre is where most work belongs.
Claude Sonnet 5.5: The Everyday Workhorse

Claude Sonnet 5.5 is the model for the work that fills most days: everyday coding, drafting and editing, and most production applications. Its documentation description is “The best combination of speed and intelligence,” and that is the whole pitch. Sonnet is fast — faster than Fable and Opus, which both run at moderate speed — and it is intelligent enough for the large middle of real work, at $2 in and $10 out per million tokens, half the price of Opus and a quarter of the price of Fable. If Opus is the default for hard work, Sonnet is the default for normal work, and normal work is most work.
The question Sonnet answers is not “can it do the job?” but “is Opus overkill for this job?” For a routine code fix, a first draft, an edit, a summary, a data transformation, or a production API call that runs thousands of times a day, the answer is usually yes. Sonnet’s capability is close enough to Opus on well-defined tasks that the difference rarely shows in the output, while the price difference always shows in the bill: the same 10,000-in, 2,000-out job that costs $0.08 on Opus costs $0.04 on Sonnet, and a monthly volume of one million input and 200,000 output tokens costs $4 on Sonnet against $8 on Opus. At production scale — millions of calls, or a feature that runs on every user action — that halving is the difference between a feature that pays for itself and one that does not. Sonnet is also the model Anthropic points to for “most production applications,” which is a deliberate statement: the model built for everyday production use is the middle model, not the flagship.
Sonnet’s thinking differs from Fable and Opus in a way that suits its role. Its adaptive thinking is not always on — it is available and it engages when the task needs it — and its default effort is high, the same as Fable’s. That combination means Sonnet thinks hard when it has to and gets out of the way when it does not, which is the right behaviour for a model whose main virtue is getting everyday work done quickly. Speed is the other half of the pitch: Sonnet is rated fast against Fable and Opus at moderate, and in interactive use — a coding assistant, a writing tool, a chat product — that speed is something users feel on every single request.
The test for Sonnet is a practical one. Take the job you were about to give to Opus and give it to Sonnet instead, then read the output with the same critical eye. If the output is as good, you have just halved your cost and sped up your response, and you should keep the job on Sonnet. If the output is weaker — if the reasoning is shallower, the code has more errors, the analysis misses a step — move the job back to Opus and note the boundary. Most jobs will stay on Sonnet. The ones that move back are the ones that genuinely need Opus, and knowing which is which is the whole skill this guide is teaching. The commonest mistake in the family is the opposite one: running everything on Opus or Fable because they are the strongest, and paying flagship prices for work a workhorse would have done just as well.
Sonnet is also the right model for the first version of almost anything. A new feature, a new agent, a new workflow — build it on Sonnet first, because it is cheap and fast enough to iterate on, and promote the parts that prove hard to Opus or Fable only when the evidence says so. That is the same logic Anthropic’s own guidance follows in reverse: start on Opus and move up only when evals fall short. For everyday work, start on Sonnet and move up only when the output falls short. Either way, the direction is the same — start in the middle, move only on evidence — and Sonnet is the middle for most of the work most people do.
Claude Haiku 5.5: The Cheapest, Fastest Claude — With One Catch

Claude Haiku 5.5 is the cheapest and fastest model in the family, and for the work it is built for, it is also the right model. Its documentation description is “For high-volume, latency-sensitive tasks such as classification, extraction, and routing,” and its model page adds subagent tasks to that list — the small, fast jobs that a bigger model delegates to a smaller one. Haiku is the model you use when a task runs thousands or millions of times, when the answer has to come back in a fraction of a second, and when the task is narrow enough that depth of reasoning is not the constraint. Classification, extraction, routing, tagging, triage, and the subagent fleet behind a larger agent’s work: that is Haiku’s territory, and on that territory nothing else in the family comes close on price.
At its starting rate, Haiku is dramatically cheap. Prompts up to 100,000 tokens cost $0.10 per million input tokens and $0.50 per million output tokens — one eightieth of Fable’s price, one fortieth of Opus’s, and one twentieth of Sonnet’s. The worked example makes the gap concrete: the same 10,000-in, 2,000-out job that costs $0.16 on Fable and $0.04 on Sonnet costs $0.002 on Haiku. Two tenths of a cent. At that price, work that would be unthinkable on a bigger model becomes routine: classifying a million support tickets, extracting fields from a million documents, routing every incoming message in real time. Haiku is also the fastest model in the family, which matters just as much as price when the task is interactive — a user waiting for a classification, a pipeline waiting for a routing decision, an agent waiting for a subagent to return.
Now the catch, because it is the one pricing trap in the whole family and it is easy to walk into. Haiku 5.5 is priced by prompt length. Prompts up to 100,000 tokens pay the $0.10 and $0.50 rates. Prompts over 100,000 tokens pay $0.50 in and $2.50 out per million tokens — five times as much, applied to the whole request. Prompt length counts all input tokens, including cache reads and cache writes, so a long cached context can push a request over the threshold just as surely as a long fresh prompt can. The other Haiku prices follow the same two tiers: cache reads cost $0.01 per million tokens at or under 100,000 tokens and $0.05 above it; five-minute cache writes cost $0.125 and $0.625; one-hour cache writes cost $0.20 and $1.00; and the Batch API costs $0.05 in and $0.25 out at the lower tier, $0.25 and $1.25 at the upper tier. The rule to remember is simple: keep Haiku prompts under 100,000 tokens and it is the cheapest model Anthropic sells by a wide margin; let them cross that line and it is still cheap, but five times less cheap than you budgeted for.
There is a second Haiku detail that affects cost comparisons with older models. Haiku 5.5 uses the newer tokenizer that Claude 4.7 and later models use, and the same text counts as about 30% more tokens on it than on Haiku 4.5. That means a direct price comparison between Haiku 4.5 at $1 and $5 per million tokens and Haiku 5.5 at $0.10 and $0.50 understates the real saving slightly — the 5.5 model counts more tokens for the same words — but even after that adjustment, Haiku 5.5 is roughly seven times cheaper per word than its predecessor on short prompts, with five times the context window. The tokenizer change is a reason to re-measure your token counts when you migrate, not a reason to stay on the old model.
Haiku fails in predictable ways, and knowing them is part of using it well. It fails on work that needs deep reasoning, long chains of inference, or genuinely hard judgment — the work Fable and Opus exist for. It fails on open-ended creative work where quality is the point rather than speed. And it fails when a task that looks like classification turns out to need understanding: a support ticket that needs a nuanced reply rather than a category label, a document that needs a judgment call rather than a field extracted. The step up is straightforward. When Haiku’s output is too shallow, too literal, or too often wrong, move that task to Sonnet, which costs twenty times as much at the starting rate but is still a quarter of Fable’s price — and if Sonnet is still not enough, move it to Opus. The discipline is the same as everywhere else in this family: start low, move up only on evidence. With Haiku, the starting point is so cheap that the evidence is nearly free to gather.
One more piece of context is worth having, because it shows what Haiku’s price point makes possible for others. Meta’s Muse Ember, a rival model, has been positioned as a cheaper way to do exactly Haiku’s job — high-volume, low-cost inference — and the comparison is instructive: when a model’s main virtue is price, the competition is always about price, and rivals will undercut it. Our report on Meta Muse Ember and the cost of Haiku’s job covers that rivalry. For a Claude user the point is simpler: Haiku is the cheapest way to do high-volume work inside Anthropic’s own family, and it is the model to beat for anyone else who wants that work.
Claude Mythos 5.2: The Same Model Behind a Locked Door

Claude Mythos 5.2 is the most misunderstood model in the family, and the misunderstanding is the reason this section exists. Mythos is real — Anthropic announced it on 9 November 2026 alongside Fable 5.2 — but it is not a fifth model you can choose. Anthropic’s own words settle the matter: “Claude Fable and Claude Mythos are the same underlying model.” Same specifications, same price — $8 in and $40 out per million tokens, one million tokens of context, 128,000 tokens of maximum output, the same June 2026 knowledge cutoff, the same always-on adaptive thinking with a high default effort. The difference is not capability, size or training. The difference is safeguards and access, and that difference is the whole story of Mythos.
Fable 5.2 carries strong cybersecurity and biology safeguards, which is what allows Anthropic to make it available to all users: its classifiers block most penetration testing, exploit generation, binary vulnerability work and most research-biology requests. Mythos 5.2 is the same model with those safeguards relaxed. It is, in Anthropic’s words, “our most capable model for cybersecurity engineering,” and its benchmark numbers show why: on CVE Rediscovery, a test of finding known vulnerabilities, Mythos 5.2 scores 89.6% against Opus 5.5’s 81.3%, and Anthropic’s internal evaluation says it found 10.2% more vulnerabilities than Opus 5.5 and 14.4% more than Mythos 5.1. On CyScenarioBench it scores 76.3% against Opus 5.5’s 67.6%. On Terminal-Bench-Science it scores 75.3%, slightly ahead of Fable 5.2’s 74.6% and well ahead of Opus 5.5’s 58.7%. All of these are Anthropic’s own self-reported figures. The pattern is consistent: where the safeguards are the constraint, relaxing them produces measurably better results on security work.
That capability comes with a locked door. Mythos 5.2 is available only to organisations verified through Anthropic’s Cyber Verification Program or Life Sciences Verification Program, plus Claude Enterprise customers through Claude Security. There is no self-service route to it, no plan upgrade that unlocks it, and no API key that turns it on. If you are not in a verification program, you will never see Mythos in your model picker — you get Fable instead, with Fable’s safeguards in place. That is the honest framing, and it is the reason this guide counts four pickable models rather than five: for most readers, Mythos is not a choice, it is a fact about the family. The writer of any model guide that lists five pickable Claude models, or gives Mythos a separate strengths-and-weaknesses box as if a reader could choose it, has misunderstood the product.
What happens if you ask Fable a question its safeguards block? Anthropic says the request falls back transparently to another model — Opus 4.8 for cybersecurity work and Opus 5 for biology work — so the request is answered, just not by Fable. That fallback is the practical meaning of the Fable-Mythos split for an ordinary user: the frontier model you can use will sometimes hand your hardest security or biology question to a different model, and the frontier model without the safeguards is reserved for organisations Anthropic has verified. Whether that split is the right policy is a question about AI safety, and Anthropic’s own safety research is the background to it — our explainer on Anthropic’s AI safety research covers the work behind the safeguards, and our report on Anthropic’s assessment of newer models against attacks covers how the company tests whether its models can be turned against their own protections.
For the small number of readers who do work in cybersecurity engineering or the life sciences inside a verified organisation, Mythos is the most capable tool Anthropic offers for that work, and its price is Fable’s price — no premium for the relaxed safeguards, just the same $8 and $40 per million tokens, the same fast mode at $16 and $80, and the same Batch API discount to $4 and $20. For everyone else, the section to remember is the one above it: Fable is your frontier model, Opus is your default, and Mythos is the same model behind a door you do not have a key for. That is not a limitation of this guide. It is the product as Anthropic built it.
Fable vs Opus vs Sonnet vs Haiku: The Comparison Table, Explained

The comparison table in the second section of this guide looks simple — four rows, nine columns, and a set of numbers that mostly repeat. The numbers that repeat are the point, and the numbers that differ are the whole decision. This section reads the table row by row, so that each figure means something concrete before you use it to choose.
Start with the figures that are identical across all four models, because they are the most important fact in the table. Every current model has a context window of one million tokens. In practical terms, a million tokens is roughly 750,000 words — several hundred pages of text, a large codebase, a long document set, or a very long conversation with plenty of room to spare. A 900,000-token request is billed at the same per-token rate as a 9,000-token one on Claude 4.6 and later models, which means long context is included at standard pricing rather than sold as a premium tier. The exception is Haiku 5.5, whose prompt-length pricing means a long prompt costs more per token, as explained in the Haiku section. Every model also has the same maximum output of 128,000 tokens — about 96,000 words, or a very long document in a single response — and the same knowledge cutoff of June 2026. The uniformity is the news: the cheapest model can now read as much, write as much, and knows as much about the world as the most expensive one. What it cannot do is reason about it as well.
Next, the figures that differ, in the order that matters for choosing. Price differs by a factor of eighty from Haiku to Fable, and it is the first filter: never pay for capability you do not need, because the family charges for it precisely. Speed differs in the opposite direction — Haiku is the fastest, Sonnet is fast, Fable and Opus are moderate — and speed matters most in interactive use, where every request has a human waiting at the end of it. Thinking differs in configuration rather than in kind: all four use adaptive thinking, which adjusts its depth to the task, but Fable and Opus have it always on and cannot turn it off, while Sonnet and Haiku engage it as needed. Default effort differs too — high on Fable and Sonnet, medium on Opus and Haiku — which means Fable and Sonnet think hard by default and Opus and Haiku think at a medium depth until you ask for more. Those defaults are not decorative: deeper thinking means more output tokens, and output tokens are the expensive half of every price in the table.
The effort parameter deserves a paragraph of its own, because it is the second dial in the family after the model choice itself. The API exposes it as output_config.effort, with five levels: low, medium, high, xhigh and max. The defaults are high on most models and medium on Opus 5.5 and Haiku 5.5. On Fable 5.2, adaptive thinking is always on and cannot be turned off, so effort is the only way to control how deeply it thinks — and the documentation is specific about what else changes on Fable: omit the temperature, top_p and top_k sampling parameters, and do not use forced tool use, because a forced tool choice returns a 400 error. The practical rule is to treat effort as a cheaper way to buy capability than switching models: before you move from Opus to Fable, try Opus at high or xhigh effort, because Anthropic’s own guidance says to move up only “when your evals on Claude Opus 5.5 at higher effort still fall short.” Effort is the test you run before you pay for the upgrade.
Finally, the table’s last column — the one-line description of what each model is for — is the most honest summary in the whole guide, because it comes from Anthropic itself. Fable is “for demanding reasoning and long-horizon agentic work.” Opus is “for long-running agentic coding and knowledge work.” Sonnet is “the best combination of speed and intelligence.” Haiku is “for high-volume, latency-sensitive tasks such as classification, extraction, and routing.” Those four sentences, taken together, are the picker. If your job matches one of them, you have your model. If it matches none of them, you are probably describing two jobs, and you should split them.
What It Actually Costs: Worked Examples

Prices per million tokens are abstract until you run a real job through them, so this section does the arithmetic in public. Take the same small job on every model: 10,000 input tokens and 2,000 output tokens, at standard API rates, with the prompt under 100,000 tokens so Haiku pays its starting rate. The maths is simple division — 10,000 tokens is one hundredth of a million, so the input cost is the per-million input price divided by 100, and 2,000 output tokens is one five-hundredth of a million, so the output cost is the per-million output price divided by 500.
| Model | Input: 10,000 tokens | Output: 2,000 tokens | Total for the job |
|---|---|---|---|
| Claude Fable 5.2 | $0.08 | $0.08 | $0.16 |
| Claude Mythos 5.2 | $0.08 | $0.08 | $0.16 |
| Claude Opus 5.5 | $0.04 | $0.04 | $0.08 |
| Claude Sonnet 5.5 | $0.02 | $0.02 | $0.04 |
| Claude Haiku 5.5 | $0.001 | $0.001 | $0.002 |
Read the ratios, because they are the decision. Fable costs twice as much as Opus, four times as much as Sonnet, and eighty times as much as Haiku on this job. Opus costs twice as much as Sonnet and forty times as much as Haiku. Those ratios hold at every scale, because they are ratios of the per-token prices, so the small job and the large job tell the same story: the model you choose is the price you pay, and the cheapest model that does the job well is always the right economic choice. The Batch API halves all of these figures — Fable $0.08, Opus $0.04, Sonnet $0.02, Haiku $0.001 on this job — because batch requests are billed at 50% off input and output on every model, in exchange for asynchronous processing rather than an immediate answer.
Now scale the job up to a month of steady use: one million input tokens and 200,000 output tokens, which is roughly the volume of a small production feature or a heavy individual user. At standard rates the monthly bill is $16 on Fable, $16 on Mythos, $8 on Opus, $4 on Sonnet, and $0.20 on Haiku — assuming Haiku’s prompts stay under 100,000 tokens each. With the Batch API those figures halve to $8, $8, $4, $2 and $0.10. And here is Haiku’s cliff in money terms: if those same million input tokens arrived in prompts over 100,000 tokens, Haiku would bill at $0.50 in and $2.50 out per million, and the same month would cost $1.00 instead of $0.20 — five times as much, still the cheapest in the family, but no longer the near-free rate the headline price suggests. The cliff is a design constraint, not a surprise: keep prompts short and Haiku is nearly free; let them grow long and the discount shrinks.
Prompt caching is the largest saving available to most users, and it is worth a worked example of its own. When you send the same context repeatedly — a system prompt, a document, a codebase summary — Anthropic can cache it and charge you a fraction of the fresh-input price to read it back. Cache reads cost a tenth of the base input price on most models, and less on the top models: Fable and Mythos charge $0.20 per million tokens for cache reads, which is 0.025 times their $8 base; Opus charges $0.20, which is 0.05 times its $4 base; Sonnet charges $0.10, which is 0.05 times its $2 base. Writing to the cache costs more than reading it — a five-minute cache write is 1.25 times the base input price and a one-hour cache write is twice the base — so caching pays when you read the same context many times, not once. Take a Fable workload of one million input tokens where 800,000 tokens are cache reads and 200,000 are fresh: the cached portion costs $0.16, the fresh portion costs $1.60, and the total is $1.76 against $8.00 if all million tokens were fresh. That is a saving of $6.24 on a single million-token workload, and it repeats on every request that reuses the same context.
Two more pricing details belong in any honest cost guide. Fast mode, which delivers up to 2.5 times the output speed, doubles the price: Fable and Mythos cost $16 in and $80 out per million tokens in fast mode, and Opus costs $8 and $40. It is not available with the Batch API, so you choose between speed and the batch discount, not both. And data residency has a multiplier of its own: setting inference_geo to “us” applies a 1.1 times multiplier to all token pricing on Claude 4.6 and later models, while global routing, the default, is billed at standard pricing. Neither of these is a trap; both are choices with a stated price, and the point of knowing them is to make the choice deliberately.
What about using the models in the Claude apps rather than the API? The subscription plans are Free at $0, Pro at $20 a month billed monthly or $17 a month when $200 is billed up front for the year, Max at $100 a month, and Ultra at $200 a month. Max provides five times Pro’s usage and Ultra provides ten times Pro’s weekly usage; Claude Code is included in all paid plans and shares the plan’s usage pool. Fable’s place in the plans is the detail to note: on Pro it is available through usage credits, and on Max and Ultra it is included up to half of the weekly usage limit, with Max adding $100 a month in API credits and Ultra adding $200 a month, and Ultra removing the five-hour limit for verified accounts. Enterprise is $20 per seat per month plus usage billed at API rates, billed annually. Anthropic also ran a launch-week offer around the Fable 5.2 announcement, giving subscribers on eligible paid plans extra Fable usage that week, with Fable included for up to 50% of weekly usage limits for Pro plans and standard seats on the Team plan — a time-limited launch offer, not a permanent entitlement, and not something to assume is still running. Availability of each model inside the apps depends on your plan, and the exact per-plan picture is not stated here because Anthropic’s pricing page did not render it in a form this guide could verify; check the live pricing page before you choose a plan for a particular model. Rival-model pricing moves just as fast, and for a sense of how quickly the market reprices, see our report on Gemini 4 Argon doubling in price from 1 December — the reminder that every price in this guide is a snapshot, checked 13 November 2026.
How to Pick by Task: The Task-Based Picker

Model descriptions are abstract. Jobs are concrete. This section is the picker as a table: find your job, take the model, and read the one-line reason. If your job is not here, match it to the nearest row by asking two questions — how hard is the reasoning, and how many times will it run? — and the model follows from the answers.
| Job | Model | Why |
|---|---|---|
| Long coding project, spanning days | Opus 5.5 | Anthropic’s recommended default; long-running agentic coding is its stated purpose. |
| Quick code fix or small feature | Sonnet 5.5 | Everyday coding at half the price of Opus, and faster than the flagship tier. |
| Deep research report, finished document or deck | Fable 5.2 | Multistep research carried through to a finished deliverable is Fable’s stated use. |
| Drafting and editing | Sonnet 5.5 | Everyday writing is the middle model’s home ground; promote to Opus only if quality falls short. |
| Summarising long documents | Sonnet 5.5, or Opus 5.5 for hard ones | All models share the 1M context window, so the choice is about reasoning depth, not length. |
| Data extraction at scale | Haiku 5.5 | High-volume, latency-sensitive extraction is Haiku’s stated purpose; keep prompts under 100K tokens. |
| Customer-support classification and routing | Haiku 5.5 | Classification and routing at $0.10 per million input tokens, fastest in the family. |
| Agent and subagent fleets | Fable 5.2 orchestrating, Haiku 5.5 as subagents | Fable as Advisor/Orchestrator delegates simple tasks down; Haiku runs the delegated work cheaply. |
| Security research, penetration testing, exploit analysis | Mythos 5.2 — verified organisations only | Fable’s safeguards block this work; Mythos is the same model with the safeguards relaxed, behind a verification gate. |
| Production application, thousands of calls a day | Sonnet 5.5, or Haiku 5.5 for narrow tasks | Anthropic points to Sonnet for most production applications; Haiku where the task is narrow and fast. |
Three patterns in that table are worth calling out. The first is that Opus appears once and Sonnet appears most often, which is the point: the middle of the family does most of the work. The second is that Fable appears only where the job is long, hard or agentic, and never as a default. The third is that Haiku appears wherever the job repeats — and repetition is the signal to reach for it. A job you do once wants the best model you can afford; a job you do a million times wants the cheapest model that does it well. Most real systems contain both kinds of job, and the best systems split them: Fable or Opus for the hard reasoning at the top, Haiku for the volume at the bottom, Sonnet for everything in between.
One more decision rule helps when a job falls between two rows. Ask whether the cost of being wrong is high or low. If a wrong answer is expensive — a bug in production code, an error in a research report, a bad decision in an agent’s plan — use the stronger model, because the cost of the mistake dwarfs the cost of the tokens. If a wrong answer is cheap — a misclassified ticket that gets re-routed, an extraction error you can detect and retry — use the cheaper model, because the cost of the tokens dwarfs the cost of the mistake. That rule, applied consistently, will put most of your work on Sonnet and Haiku and reserve Opus and Fable for the jobs where quality is the constraint. It is also the rule that keeps a monthly bill from growing faster than the value it produces.
How to Switch Models in the Claude App, Claude Code, and the API

Choosing a model is only useful if you can actually switch to it, and the three places you use Claude — the apps, Claude Code and the API — each switch differently. The descriptions below are deliberately general where the source material is general: the exact steps inside the apps were not verified from an Anthropic support page for this guide, and the Claude Code mechanics described here rest on guides that cite Anthropic’s official Claude Code documentation, so this section states what is confirmed and keeps the rest short.
In the Claude apps — claude.ai, the desktop app and the mobile app — you choose the model from the model menu in the app. Which models appear in that menu depends on your plan: availability in the app is plan-dependent, and Fable needs a paid plan, available through usage credits on Pro and included up to half the weekly usage limit on Max and Ultra. That is as specific as this guide can honestly be about the apps, because Anthropic’s pricing page did not render its per-plan model table in a form that could be verified. If a model you expect is missing from your menu, the plan is the first thing to check, and the live pricing page is the place to check it.
In Claude Code, the /model command opens the model picker, and that is the switch most users will use most often. There are other ways to set the model: the --model flag when launching a session, for example claude --model opus; the ANTHROPIC_MODEL environment variable; the model key in settings; and ANTHROPIC_DEFAULT_MODEL as the fallback for new sessions. This guide does not assert the priority order between those controls or the difference between switching for one session and switching the saved default, because those details were not read directly from Anthropic’s Claude Code documentation in this session. The safe summary is that /model is the interactive switch, the flag and the environment variable are the scripted switches, and the settings key is the persistent one — and if the exact behaviour matters for your workflow, Anthropic’s Claude Code model-configuration documentation is the source to read.
In the API, switching is a single field. Set model in a Messages API request, for example model="claude-opus-5-5", and the request runs on that model. Aliases — opus, sonnet, haiku, fable — resolve to the current version of each line, which is convenient and also the reason to pin exact versions with full model IDs in production: an alias silently moves you to the next version when Anthropic ships one, and a pinned ID does not. The Models API can query capabilities and limits programmatically, which is the reliable way to confirm what a model supports before you build on it. And the effort parameter is the second dial in every API call: output_config.effort takes low, medium, high, xhigh or max, with defaults of high on most models and medium on Opus 5.5 and Haiku 5.5. On Fable 5.2, remember to omit the temperature, top_p and top_k sampling parameters, and do not use forced tool use, which returns a 400 error.
The switching advice that matters most is not technical but procedural. Do not switch models by feel. Switch by evidence: run the same task on two models, compare the outputs, and keep the cheaper one if the outputs are equal. That test costs almost nothing on Haiku and Sonnet, and it is the only test that tells you what your job actually needs rather than what the marketing suggests. A model picker is a hypothesis about your work; the comparison is the experiment that confirms it.
What the Benchmarks Do — and Don’t — Prove

Anthropic’s launch announcement for Fable 5.2 and Mythos 5.2 includes a benchmark table, and it is the only benchmark evidence this guide uses. Every figure in this section is Anthropic’s own, self-reported, from that announcement — not independently verified, not from a third-party board, and not to be quoted as though an outside body had confirmed it. The table is useful, but only if you read it the way a sceptic reads a vendor’s own test results: as evidence about where the vendor thinks its model is strong, not as a verdict on which model you should buy.
Here is the table, summarised. On FrontierCode 2.0, a test of agentic coding, Fable 5.2 scores 49.1% at Xhigh effort, against Fable 5.1 at 32.4%, Opus 5.5 at 45.5%, GPT-6 Astra at 42.8% and Gemini 4 Carbon at 41.1%. On FrontierSWE v2, Fable scores 69.9% against Opus’s 62.3%. On AutomationBench, a test of business workflows, Fable scores 51.4% against Opus’s 42.5% — but Gemini 4 Carbon leads that test at 53.9%, which is the second row in the table where a rival beats Fable. On Terminal-Bench-Science 0.1, Fable scores 74.6% and Mythos 75.3%, against Opus’s 58.7%. On Humanity’s Last Exam with tools, Fable scores 74.2% against Opus’s 67.7%. On OSWorld 2.1, a computer-use benchmark, Fable scores 89.3% against Opus’s 87.2%. On RoboDojo Sim, a robotics benchmark, Fable scores 64.9% against Opus’s 39.4%. And on the cybersecurity tests, Mythos 5.2 scores 89.6% on CVE Rediscovery against Opus 5.5’s 81.3% and Mythos 5.1’s 78.3%, and 76.3% on CyScenarioBench against Opus’s 67.6%.
Two rows in that table deserve more attention than the rest, because they are the ones that complicate the story. The first is AA-Briefcase v1.1, a knowledge-work benchmark, where Fable scores 66.1% on the rubric against Opus’s 61.2% — but Opus scores 1800 Elo against Fable’s 1785. On the Elo measure, the cheaper model leads. That single row is the reason this guide keeps saying to test on your own work: the flagship does not win everything, and on at least one measure of knowledge work the daily driver is ahead. The second is AutomationBench, where Gemini 4 Carbon leads at 53.9% against Fable’s 51.4% and Opus’s 42.5%. Anthropic published that row itself, which is to its credit, and it is a reminder that the frontier is contested: the rival Anthropic measures itself against is ahead on business workflows, and the gap between Fable and Gemini there is smaller than the gap between Fable and Opus. For the rival’s side of that contest, see our report on Gemini 4 Carbon’s cyber-defence positioning — the same model Anthropic benchmarks against, presented on its own terms.
The announcement also describes prerelease experiments, and these need even more careful handling than the benchmarks, because they are demonstrations rather than tests. Anthropic says a 1,000-agent team running Fable formalised Fermat’s Last Theorem in Lean in about 30 hours; that a prototype operating system was built by more than 1,000 subagents in 8 days; that two open black-hole physics problems were solved; and that three working electronic devices were designed. Anthropic also says Fable’s outputs are up to 30% faster than the 5.1 generation. All of these are Anthropic’s own claims about its own experiments, presented here as “Anthropic says” and nothing more. They are interesting as a picture of what a thousand agents can do with the strongest available model, and they are not evidence about what one agent will do for your job. The distance between a staged demonstration and a production result is exactly the distance this guide keeps warning about.
What benchmarks do prove, within their limits, is the shape of the family: Fable is strongest on long, hard, agentic work; Opus is close behind it and ahead on at least one measure; the gaps are largest where the work is longest and smallest where it is shortest. What they do not prove is which model is right for your job, because your job is not a benchmark. The only test that answers that question is your own work, run on two models, compared honestly — and the independent reporting on coding agents is a useful corrective to any benchmark table: agents finish only about one task in four without help, and the gap between a benchmark score and a finished task is the gap that matters. Our report on coding agents finishing one task in four is the reality check to read alongside this table.
Moving Up, Moving Down, and Moving Off Old Models

Choosing a model is not a one-time decision. The right model for a job changes as the job changes, as your volume grows, and as Anthropic ships new versions — and the family is designed to be moved through, up and down, rather than settled in. This section covers when to move, in both directions, and what to do about the older models still listed in Anthropic’s documentation.
Move up a tier when the evidence says the current model is the constraint. The test is specific: the output is too shallow, the code has too many errors, the reasoning misses steps, or the agent stalls on work that needs more depth — and you have already tried raising the effort parameter, because Anthropic’s own guidance is to move to Fable only when Opus at higher effort still falls short. Move up when a job changes shape, too: a quick fix that becomes a long project, a summary that becomes a research report, a single agent that becomes a fleet with an orchestrator. And move up when the cost of being wrong rises: a prototype that becomes a production system, or a draft that becomes a deliverable a client will see. In each case the move is justified by the work, not by the novelty of the stronger model.
Move down a tier just as deliberately, because moving down is where the savings are. Move down when a job proves easier than you expected — the Sonnet output is as good as the Opus output, so keep it on Sonnet. Move down when volume grows: a feature that runs a thousand times a day on Opus may run better on Sonnet, and a feature that runs a million times a day may belong on Haiku. Move down when the task narrows: a general agent that only ever classifies tickets is a Haiku job wearing an Opus price tag. And move down when you split a job: the hard reasoning stays on Fable or Opus, the volume work moves to Haiku, and the bill falls without the quality falling with it. The discipline in both directions is the same — move on evidence from your own outputs, not on the feeling that a stronger model must be better or a cheaper model must be worse.
The older models are still listed in Anthropic’s documentation, and they are still available, so the question of when to leave them is a live one. Here are the legacy models that matter, with their prices:
| Legacy model | Price in / out per MTok | Context | Max output |
|---|---|---|---|
| Fable 5.1 / Mythos 5.1 | $10 / $50 | 1M tokens | 128K tokens |
| Fable 5 | $10 / $50 | 1M tokens | 128K tokens |
| Opus 5 | $5 / $25 | 1M tokens | 128K tokens |
| Opus 4.8 / 4.7 / 4.6 | $5 / $25 | 1M tokens | 128K tokens |
| Opus 4.5 | $5 / $25 | 200K tokens | 64K tokens |
| Opus 4.1 / 4 | $15 / $75 | 200K tokens | 32K tokens |
| Sonnet 5 | $2 / $10 | 1M tokens | 128K tokens |
| Sonnet 4.6 | $3 / $15 | 1M tokens | 128K tokens |
| Sonnet 4.5 / 4 | $3 / $15 | 200K tokens | 64K tokens |
| Haiku 4.5 | $1 / $5 | 200K tokens | 64K tokens |
The cost of staying put is clearest at the two ends of the family. At the top, Fable 5.1 costs $10 and $50 per million tokens against Fable 5.2’s $8 and $40 — the new model is 20% cheaper and, Anthropic says, up to 30% faster, so staying on 5.1 pays more for less. At the bottom, Haiku 4.5 costs $1 and $5 per million tokens against Haiku 5.5’s $0.10 and $0.50 on short prompts — ten times as much per token — with a fifth of the context window, 200,000 tokens against a million, and half the maximum output, 64,000 against 128,000. Staying on Haiku 4.5 is the most expensive legacy decision in the family in percentage terms, and it is the one to fix first. In the middle, the case is weaker: Opus 5 at $5 and $25 is only a dollar more per million input tokens than Opus 5.5 at $4 and $20, and Sonnet 5 at $2 and $10 is the same price as Sonnet 5.5 — so the reason to move there is capability and context, not price. Opus 4.1 and 4 at $15 and $75 are the outlier: they cost more than the current flagship’s predecessor and offer a fifth of the context, and there is no reason to stay on them.
Retirement is the other half of the legacy question, and this guide does not answer it with dates, because the dates were not verified from Anthropic’s own deprecations page for this guide. Secondary sources report retirement windows for the current models, but until those dates are read from Anthropic’s own page they are not stated here as fact. The practical advice does not need a date: migrate off legacy models on your own schedule, starting with the ones that cost the most relative to their replacement, and do not wait for a retirement notice to begin. Model retirement elsewhere in the industry is a reminder that old versions do go away — our report on GitHub Copilot retiring three models on 16 November shows how quickly a retirement can arrive — and the cheapest time to migrate is before you are forced to.
The Bottom Line: A Simple Rule for Every Job

The Claude family is four models for most readers, not five, and the rule for choosing between them fits in one paragraph. Start with Claude Opus 5.5, because Anthropic says to and because it is the strongest generally available model at half the flagship’s price. Go up to Claude Fable 5.2 when the work is genuinely hard, long, or agentic — agent sessions that run for hours, research that ends in a finished deliverable — and only after you have tried Opus at higher effort and found it still falls short. Go down to Claude Sonnet 5.5 for everyday coding, writing and production work, where it is as good as Opus for half the price. Go down to Claude Haiku 5.5 for high-volume, latency-sensitive work, where it is eighty times cheaper than Fable and the fastest model in the family — and keep its prompts under 100,000 tokens, or the price multiplies by five. Claude Mythos 5.2 is the same model as Fable behind a verification gate for cybersecurity and life-sciences work; if you are not in a verification program, it is not a choice you make, and Fable is the model you get.
Here is the picker as a quick reference, to keep beside your desk. Long coding project: Opus 5.5. Quick code fix: Sonnet 5.5. Deep research report: Fable 5.2. Drafting and editing: Sonnet 5.5. Summarising long documents: Sonnet 5.5, Opus 5.5 if they are hard. Data extraction at scale: Haiku 5.5. Customer-support classification: Haiku 5.5. Agent fleets: Fable 5.2 orchestrating, Haiku 5.5 as subagents. Security research: Mythos 5.2, verified organisations only. Production applications: Sonnet 5.5, Haiku 5.5 where the task is narrow. And the rule behind every row: start in the middle, move only on evidence, and let the cost of being wrong decide how strong a model the job deserves.
One last note, because this guide is meant to be maintained rather than read once. Prices, models and availability in this family change often — Fable 5.2 itself arrived on 9 November 2026, four days before this guide was checked — so every figure here is the position as of 13 November 2026, verified against Anthropic’s own documentation on that date. Before you budget a project, re-check the live pricing page, and before you build on a model, confirm its capabilities through the Models API. The picker will still be the same: start with Opus, go up only when the work demands it, go down whenever the work allows it, and remember that Mythos is a locked door, not a fifth choice.
Sources
All facts in this guide were checked against Anthropic’s own pages, read in full on 13 November 2026. Checked 13 November 2026. No competitor page or third-party benchmark board was used as a source for any figure in this guide; benchmark figures are Anthropic’s own self-reported numbers from its launch announcement, and prerelease experiments are presented as Anthropic’s claims.
- Anthropic models overview (docs) — current lineup table, prices, context and output limits, Anthropic’s “start with Opus 5.5” advice, model IDs and aliases, thinking configuration. https://platform.claude.com/docs/en/models/overview
- Anthropic API pricing (docs) — full price table including cache, batch, fast mode, long context and data residency; Haiku 5.5 prompt-length tiers. https://platform.claude.com/docs/en/about-claude/pricing
- “Introducing Claude Fable 5.2 and Claude Mythos 5.2” (Anthropic news, 9 November 2026) — launch announcement, the Fable-is-Mythos statement, benchmark table, availability, safety and safeguards, prerelease experiments. https://www.anthropic.com/claude-fable-and-mythos-5-2
- Claude Fable 5.2 model page (docs) — typical uses, comparison table, thinking always on, 30-day data retention, sampling-parameter guidance. https://platform.claude.com/docs/en/models/fable-5-2/overview
- Claude Mythos 5.2 model page (docs) — access restriction to verified organisations, “same specifications and pricing as Claude Fable 5.2”, comparison table. https://platform.claude.com/docs/en/models/mythos-5-2/overview
- Claude Haiku 5.5 model page (docs) — typical uses, full tiered price list, newer tokenizer, subagent tasks. https://platform.claude.com/docs/en/models/haiku-5-5/overview
- Anthropic plans and pricing — Free, Pro, Max and Ultra prices, Fable availability per plan, API credits, Enterprise pricing. https://www.anthropic.com/pricing
- Effort parameter (docs) — effort levels low, medium, high, xhigh and max, default effort per model, which models support max and xhigh. https://platform.claude.com/docs/en/build-with-claude/effort


0 Comments