Claude Fable 5: what it is, how good it is, and when to use it

On June 9, 2026, Anthropic did something it had never done before: it handed the public a model from its Mythos tier, the class that until then only a small set of cyber-defense partners and vetted researchers were allowed to touch. The public-safe version is called Claude Fable 5, and the framing that matters is this - it does not sit inside the Opus family, it sits above it. Anthropic describes it plainly as its most capable widely released model, built for the most demanding reasoning and long-horizon agentic work.

This is the full guide: what Fable 5 actually is, how good it really is and at what, and the practitioner's rule for when its price is worth paying. If you only remember one line, make it this - Fable 5 is not a new default, it is a new ceiling. We are a data and AI delivery firm, not a model vendor, so everything here is written from the only question that matters to us and our clients: does it change what you can ship, and does it change what it costs?

Mythos, Fable, and the tier above Opus#

Anthropic's model line used to top out at Opus. Fable 5 introduces a new rung above it: the Mythos class. The naming trips people up, so here is the clean version. Mythos is the capability tier. Fable 5 is the version of that tier made safe for general release, with safety classifiers switched on. Mythos 5 is the same underlying model with some safeguards lifted, available only to a small group of cyberdefenders and infrastructure providers, and it carries the strongest cybersecurity capabilities of any model in the world. The tier first appeared in April as Claude Mythos Preview through Project Glasswing, an invitation-only channel, before Fable 5 brought a guarded version of that capability to everyone.

So Fable and Mythos are not two different brains. They are the same brain with different locks on the doors. Fable is the one you can actually call from an API key today, and everything below is about Fable.

The frontier became a menu#

The more useful way to understand Fable 5 is by what it did to the rest of the lineup. Claude Opus 4.8 had been Anthropic's flagship since late May. Overnight, it stopped being the top of the range and became the middle of a three-model menu. For the first time, Anthropic's frontier is a choice, not a single flagship:

This is the single most important mental shift the release forces. Before Fable, "use the best model" meant one model. Now it means picking the right rung for the job, because the top rung costs real money and only earns it on a specific class of work. Hold the shape: Sonnet for throughput, Opus for correctness, Fable for the long horizon. The last third of this guide is entirely about making that call.

The specs that actually change how you use it#

Most spec sheets are noise. Three numbers and one behaviour on Fable 5 genuinely change how you build with it.

• A 1M-token context window, by default. The maximum context is also the default, so you are not opting in to the big window, you are always in it. That is what lets Fable hold a large codebase or a long research trail in a single session without you stitching context back together by hand.
• Up to 128K output tokens per request. It can produce a very large single response - a full migration, a long document, a dense analysis - without being artificially truncated mid-thought.
• Thinking is always on. Fable 5 runs with adaptive extended thinking that you cannot turn off, and unlike the Opus family, the raw chain of thought is never returned to you. You either get a readable summary of the reasoning or an empty thinking block, never the model's private working. This is a deliberate safety choice, and it means you should design around the answer, not around inspecting the reasoning.
• Safety classifiers can reroute your request. For flagged domains such as cybersecurity, biology, and chemistry, a request may be answered by Claude Opus 4.8 instead of Fable, or refused. Anthropic tuned this conservatively, and reports that it triggers in less than 5 percent of sessions, with at least 95 percent of sessions running entirely on Fable's own responses. It is rare, but if you build in a sensitive domain, it is a behaviour to plan for.

Put together, the profile is a model that carries a lot of context, thinks hard by default, produces large outputs, and occasionally hands sensitive work to a safer sibling. That is a very different tool from a quick, cheap, one-shot model, and it should be used for a different class of task.

The launch that shut itself down#

You cannot understand Fable 5's first month without the drama, because it shaped who actually got to use it. Three days after launch, on June 12, the US government applied export controls to both Fable 5 and Mythos 5, requiring Anthropic to restrict access for foreign nationals. The order took effect immediately, and because there was no reliable real-time way to verify a user's nationality, Anthropic did the only thing it could and suspended access to both models for everyone. The most capable model in the world went dark for roughly 19 days.

The controls were later lifted by the Department of Commerce, and Anthropic redeployed Fable 5 to users globally starting July 1, across the Claude Platform, Claude.ai, Claude Code, and Claude Cowork. Access on paid subscription plans was then extended briefly before shifting to metered, prepaid usage credits at the full $10 and $50 rate. The takeaway for anyone wiring Fable into a product is not the politics, it is the fragility: a frontier model can be geopolitically volatile in its first weeks, and you should not hard-wire your critical path to a model that new without a fallback. More on that engineering point below.

How good is it? Task length is the whole story#

The single idea that organizes every result comes straight from Anthropic's own framing: the longer and more complex the task, the larger Fable 5's lead over other models. On a one-line question you may not notice a difference. Hand it a job that takes hours and dozens of steps, and the gap becomes the whole point.

The mechanism is worth understanding, because it explains everything else. Most model comparisons are run on short tasks, because short tasks are easy to score, and that is exactly why they undersell Fable. Its advantage is not that it answers a single question 3 percent better. Its advantage compounds over the length of a task, because it makes fewer mistakes per step and recovers from the ones it makes, so a long chain of work stays coherent instead of drifting off course. If you have read our post on agents that do the work, you know the math: end-to-end success is per-step reliability raised to the power of the number of steps. Nudge the per-step number up and hold it there across a hundred steps, and the end-to-end result moves enormously.

The coding benchmarks#

Coding is the headline. On Anthropic's published evaluations, Fable 5 sits clearly above Opus 4.8, and the gap is widest exactly where the task is longest and most agentic:

These figures are reported across the launch analyses (tech-insider, TrueFoundry). The SWE-bench Pro number is the one power users kept pointing at, because the next-best model sits roughly 11 points behind. FrontierCode Diamond is more telling: it more than doubles Opus, and it is a harder, longer-horizon coding benchmark. That is the pattern in miniature. On the tough, multi-step problems, the lead is not a few points, it is a different league.

Long-horizon agentic work#

Benchmarks are a proxy. The real story Anthropic tells is about duration. Run Fable 5 inside an agent harness such as Claude Code, and it is built to work for hours or days at a time: planning across stages, delegating to sub-agents, writing its own tests, and using vision to check its outputs against the goal. It adds automatic context compaction so a long session does not fall off the end of its own memory. This is what "most capable for ambitious coding projects" is meant to cash out as - large migrations, complex multi-file implementations, and multi-day autonomous sessions that previous models could not hold together. One anecdote captures the class of work: Fable reportedly finished a migration in a 50-million-line codebase in a single day. Whether or not any one number holds up, the shape is the claim. Fable is not built to win a trivia round. It is built to be handed a large, well-framed job and left to run.

The more interesting signal, because vendor benchmarks deserve skepticism, is from independent testers. Hex, an analytics company, said Fable was the first model to reach 90 percent on its core benchmark of complex, long-running analytical tasks. Genspark, an AI workspace platform, said Fable beat every other model in its evaluations and was notably stronger on UI design and game coding. And Andrej Karpathy called it a major-version-bump-deserving step change forward, which from someone who has watched models inch up half a point at a time is a strong line. None of this makes Fable magic. It makes it credible that the improvement is real on the hard end of the distribution, which is precisely the end that is expensive to serve any other way.

Where the numbers get soft#

Being honest about evidence is part of the value we sell, so three caveats before we spend real money on this. First, per third-party reporting, Anthropic listed the evaluations it ran but has not published every raw benchmark number on its model page, so some independent scores should be read as early, unofficial signals until the system card numbers are fully public. Second, the safety classifiers mean that in flagged domains such as cybersecurity or biology, the behaviour you see may differ from a raw benchmark, because a request can refuse or reroute to Opus 4.8. Third, benchmark leads on long tasks are the hardest to reproduce precisely, because long tasks are the least standardized. The direction is well supported. The exact decimals are not gospel. Treat them as evidence, not scripture.

When is it worth it? Route by task#

Here is where the guide turns practical. The developer consensus that formed within weeks of launch is refreshingly blunt, and it is the right default: do not switch to Fable by default. Stay on Opus 4.8 for the everyday premium work, and escalate to Fable only when the job is big, fully framed, and something you can hand over and walk away from. The Every team's line summed the model up well - a warp drive for power users, overpowered for everyone else.

Fable is not a replacement for your default model, it is an escalation path. The mental model is a three-lane road, and the discipline is sending each job to the lane it belongs in:

• Sonnet 5 for high-volume, everyday work where speed and cost matter most.
• Opus 4.8 for work that has to be correct but is normal-sized. This is your default premium lane, and it should carry most of your premium traffic.
• Fable 5 for the long-horizon jobs: large migrations, multi-day agentic sessions, deep research, dense analytical work with a long chain of dependent steps. The horizon itself is the differentiator, so if the task is short, you are paying for a lead that will not show up.

The test we use is three words: big, framed, hand-off-able. Big, because the lead only appears at length. Framed, because Fable rewards a well-specified job and cannot rescue a vague one. Hand-off-able, because if you are going to babysit every step, you are not using the thing Fable is uniquely good at, and you should have used Opus. If a job fails any of the three, route it down a lane.

The cost math that decides it#

Fable is priced at $10 per million input tokens and $50 per million output, precisely double Opus 4.8's $5 and $25, and the highest Anthropic has published for a generally available model. But sticker price is not what a task costs, and this is where the naive comparison misleads. Two mechanics bend the effective cost:

• Fewer tokens to finish. Anthropic and early customers report that Fable often completes hard tasks in fewer turns and fewer tokens. One striking example: a customer found Fable finished a frontier physics research task in 36 hours using about one-third the reasoning tokens a competing model took four days to match. At double the rate and a third of the tokens, Fable is cheaper on that job, not costlier. Fewer failed agent loops is where the 2x pays for itself.
• Prompt caching. Anthropic's prompt cache gives a 90 percent discount on cache hits, so Fable's cached input reads drop from $10 to about $1 per million. For agentic work that reuses a large system prompt or context across many turns, that changes the arithmetic materially.

So the number that decides Fable is never the per-token rate. It is dollars per successfully completed task, including the failures and the retries, exactly the metric we argue for in inference cost is a product decision. Run the cheaper model three times and fail twice, and it was not cheaper. Run Fable once and finish, and the 2x was a bargain. Measure the task, not the token.

Two gates every builder has to check#

Two constraints will quietly break a Fable deployment if you meet them after you have built it rather than before.

No automatic fallback. On metered access, there is no automatic fallback from Fable to another model. If your credits are not enabled, the session simply ends - it does not quietly downgrade to Opus and keep going, it stops. Combine that with the 19-day export-control shutdown in the model's first month, and the engineering lesson is unambiguous: never put a brand-new frontier model on your critical path without your own fallback. Wire an explicit route to Opus 4.8 in your own code, so a credit lapse, a rate limit, or another shutdown degrades your product instead of breaking it. This is the same posture we take on any integration seam in agents that do the work: the failure is at the seam, so engineer the seam.

The retention gate. Fable 5 carries a 30-day data-retention requirement and is not available under zero data retention, whereas Opus 4.8 does support zero data retention. If your compliance posture, client contract, or data-handling policy requires zero retention, Fable is off the table for that workload regardless of how good it is, and Opus 4.8 is your ceiling. Check this before you design anything around Fable.

The Welzin decision checklist#

Here is the checklist we actually run when a client asks whether to reach for Fable on a workload. Route to Fable only if you can answer yes to all five:

1. Is the task long-horizon?      Multi-hour or multi-step with
                                  dependent stages. If short, use Opus.
2. Is it well framed?             A clear, specified goal Fable can run
                                  with. Vague jobs waste the premium.
3. Can you hand it off?           Minimal step-by-step babysitting. If you
                                  supervise every step, use Opus.
4. Does the domain clear ZDR?     No zero-retention requirement, and not a
                                  classifier-flagged domain that reroutes.
5. Is there a fallback wired?     An explicit route to Opus 4.8 so a lapse
                                  degrades, not breaks, the product.

Five yeses and Fable will very likely earn its price. A single no, and you route the job to Opus 4.8 or Sonnet 5 and spend the difference somewhere it matters. This is the same buy-versus-build-versus-tune discipline we bring to every model decision in buy, build, or fine-tune: the most capable option is rarely the right default, and the judgement is in the routing, not the ranking.

Takeaways#

• Claude Fable 5 is Anthropic's most capable widely released model and the first from its Mythos tier, a rung above Opus. Mythos is the tier, Fable is the safety-classified public version, Mythos 5 is the same model with safeguards lifted for a few defenders.
• It created a three-model menu: Sonnet 5 for throughput, Opus 4.8 for correctness, Fable 5 for the long horizon. Picking the rung is now the job.
• The specs that matter: 1M-token context by default, up to 128K output tokens, always-on thinking with no raw chain of thought returned, and conservative safety classifiers that can reroute sensitive requests to Opus 4.8.
• On performance, the lead grows with task length: about 80.3% vs 69.2% on SWE-bench Pro, more than double on the harder FrontierCode Diamond, and days-long agentic sessions are the target use case. Independent testers back that the gains are real at the hard end.
• The 2x per-token price is not the real cost. Fable often uses fewer tokens to finish, and prompt caching cuts cached input by 90 percent, so measure dollars per completed task, not per token.
• Two gates: there is no automatic metered fallback (wire your own route to Opus 4.8), and Fable requires 30-day retention with no zero-retention option. Check both before you build.
• The rule: do not default to Fable. Escalate to it only for big, framed, hand-off-able long-horizon jobs that clear ZDR and have a fallback. Five yeses to use it, one no to route it down a lane.

References#

1. Claude Fable 5 and Claude Mythos 5 (Anthropic)
2. Claude Fable (Anthropic)
3. Introducing Claude Fable 5 and Claude Mythos 5 (Claude Platform Docs)
4. Redeploying Claude Fable 5 (Anthropic)
5. Anthropic says Trump admin lifted export controls on Fable 5 and Mythos 5 (CNBC)
6. Anthropic's Claude Fable 5 is a version of Mythos the public can access today (TechCrunch)
7. Claude Fable 5 vs Opus 4.8: the SWE-Bench gap (tech-insider)
8. Claude Fable 5 vs Opus 4.8: benchmarks, pricing, when to use each (TrueFoundry)
9. Fable 5 and Mythos 5: pricing and benchmark comparison (Finout)
10. Sonnet 5 vs Opus 4.8 vs Fable 5: which to use when (Digital Applied)
11. Fable 5 subscription ends: per-token costs and who gets hit hardest (TechTimes)

Hero image via Unsplash.

Model routing is a delivery decision, and it is one we make with clients every week. If you are weighing where Fable 5 fits in your stack, explore our other insights or get in touch to talk it through.