Claude Fable 5 Released: Features, Benchmarks, and Claude Code Guide

Anthropic just made its most capable model class available to everyone. Claude Fable 5 shipped on June 9, 2026, and it is the first public model from the same family as Mythos, the system whose cybersecurity ability spooked governments earlier this year. Fable 5 sits one tier above Opus 4.8 and is, by Anthropic’s own framing, state of the art on nearly every capability benchmark it has tested.

The twist is that Anthropic shipped it as two models. Fable 5 is the public one with safety classifiers turned on. Mythos 5 is the same weights with the guardrails lifted, locked behind an invitation-only program. This guide covers what Fable 5 actually is, how it benchmarks against Opus 4.8 and the competition, what it costs, the exact model IDs, how to call it from the API and from Claude Code, and whether the jump is worth double the price. The model IDs, pricing, and API calls below were checked against Anthropic’s June 2026 documentation and run live against the claude-fable-5 endpoint.

What Claude Fable 5 is, and the Mythos split

Fable 5 is a “Mythos-class” model. Mythos is the internal name for Anthropic’s most powerful tier, a step beyond the Opus line. Earlier in 2026 Anthropic gave a small set of partners access to Mythos Preview under Project Glasswing because the model was good enough at finding and exploiting software vulnerabilities that a wide release looked reckless.

Fable 5 is how that capability reaches the public without handing everyone an offensive cyber tool. It is the Mythos model with three classifier categories bolted on. When a request trips one of them, Fable 5 declines it. Anthropic says those refusals fall back to Opus 4.8 and happen in under 5% of sessions, so more than 95% of the time you are talking to the full Mythos-class model. On the raw API that fallback is opt-in rather than automatic, which the safety section below covers in detail.

Mythos 5 is the unrestricted twin. Same weights, safeguards removed in some areas, and according to Anthropic it has the strongest cybersecurity capabilities of any model in the world. It is not on self-serve. Access runs through Project Glasswing for vetted infrastructure providers and cybersecurity researchers, with a separate trusted-access track planned for biology.

Claude Fable 5 vs Claude Mythos 5

For practical purposes the difference is access and guardrails, not raw intelligence. The table below is the short version.

Anthropic also tightened the data policy for everything in this class. All Fable 5 and Mythos 5 traffic carries a mandatory 30-day retention window, even for enterprises that previously had zero-retention agreements. The data is not used for training, human access is logged, and logs are deleted after 30 days in almost all cases. If you work under strict data-handling rules, factor that retention floor into your decision before routing production traffic to Fable 5.

Fable 5 benchmarks vs Opus 4.8, GPT-5.5, and Gemini 3.1 Pro

Anthropic’s launch post leads with customer results rather than a clean benchmark grid, and those results are the most concrete proof points so far. Stripe ran a codebase-wide Ruby migration across a 50-million-line codebase in a single day, work it estimated would take a full team more than two months. Hebbia said Fable 5 was the first model to break 90% on its core finance-analytics benchmark, a ten-point jump over Opus. Cognition reported the highest FrontierCode score of any frontier model at medium effort, and Replit said it one-shots apps that took a hundred prompts a year ago.

The numeric comparisons below combine Anthropic’s published figures with early independent testing. Treat them as a launch-week snapshot rather than a final, fully audited table. The asterisked figure reflects the unrestricted Mythos-class score; on safeguarded cyber and bio domains, Fable 5’s classifiers can pull the number down toward Opus 4.8.

The agentic-coding gap is the clearest single signal. On SWE-Bench Pro, the standard real-world software-engineering benchmark, Fable 5 opens an eleven-point lead over Opus 4.8 and roughly laps the nearest competitor:

The pattern is consistent. Fable 5’s biggest leads are on the hardest agentic and frontier-reasoning tasks, where it roughly doubles Opus 4.8 on FrontierCode and Blueprint-Bench. On already-saturated benchmarks like OSWorld the margin is small. It holds outside code too: on the GDPval-AA knowledge-work rating Fable 5 leads Opus 4.8 by 42 Elo, a real edge but a narrower one than its coding lead. The takeaway for the pricing question later is the same everywhere: you pay the premium for the top of the difficulty curve, not for routine work.

Pricing, model IDs, and availability

Fable 5 costs exactly double Opus 4.8. That is the single most important number for deciding where to point it.

Prompt caching still applies, and cache reads are billed at roughly a tenth of the input rate, about $1 per million tokens, which softens the cost on long agentic runs that reuse a large context. On the subscription side, Fable 5 is included free on Pro, Max, Team, and seat-based Enterprise plans through June 22, 2026. After that it moves to usage credits on those plans. If you have a Pro or Max subscription, that free window is the cheapest chance you will get to stress-test it.

The model identifiers are stable, pinned snapshots. Use these exact strings depending on where you call it.

Fable 5 is generally available on the Claude API, Claude Platform on AWS, Amazon Bedrock, Vertex AI, and Microsoft Foundry from launch day. The headline specs: a 1 million token context window, up to 128,000 output tokens per response, adaptive thinking always on (there is no separate extended-thinking toggle), and a January 2026 knowledge cutoff, the same as Opus 4.8. One caveat on the context number: this generation uses the tokenizer introduced with Opus 4.7, so the same text produces roughly 30% more tokens than older models, which eats into that million faster than you might expect and adds to the output bill.

Access is immediate for anyone with a Claude API key and for Pro and Max subscribers. On Amazon Bedrock and Vertex AI you may need to request model access in the console first, and as with past Claude releases regional enablement can trail the launch by a few days. If a call to claude-fable-5 returns a model-not-found error on a cloud platform, check the model-access page for your region before assuming something is broken.

Call Claude Fable 5 from the API

The API call is identical to any other Claude model. Only the model string changes. Put your key in an environment variable first so it never lands in shell history or a committed file:

export ANTHROPIC_API_KEY="your-anthropic-api-key"

A minimal request with curl:

curl -s https://api.anthropic.com/v1/messages \
  -H "x-api-key: ${ANTHROPIC_API_KEY}" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Write a hardened systemd unit for a Go web service running as a non-root user on port 8080."}
    ]
  }'

We ran exactly that prompt against the live claude-fable-5 endpoint. The response metadata came back stamped "model": "claude-fable-5", and the unit it produced already carried the namespace and capability hardening most people paste in from a blog post days later:

Here is the core of that generated unit as copyable text:

[Service]
Type=simple
User=webapp
Group=webapp
ExecStart=/usr/local/bin/webapp
Restart=on-failure

# Filesystem hardening
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
ProtectKernelTunables=true
ProtectKernelModules=true
ProtectControlGroups=true
ReadWritePaths=/var/lib/webapp

# Privilege hardening
NoNewPrivileges=true
CapabilityBoundingSet=
RestrictSUIDSGID=true
LockPersonality=true
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX

The Python SDK call is just as short. The anthropic package needs no version pin for the model string:

from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from the environment
msg = client.messages.create(
    model="claude-fable-5",
    max_tokens=8192,
    messages=[
        {"role": "user", "content": "Plan and implement the refactor in this repo."}
    ],
)
print(msg.content[0].text)

Fable 5 supports the same effort levels as Opus 4.8, and they have a real cost. In Simon Willison’s launch-day testing, the same “pelican on a bicycle” SVG prompt produced about 1,900 output tokens at low effort (roughly $0.10) and about 14,400 tokens at max effort (roughly $0.72) on the same task. Higher effort buys more thinking and a better answer, but you are billed for every one of those tokens at $50 per million, so set effort deliberately rather than leaving it at the ceiling.

Two Fable-specific behaviors will trip you up if you port code from Opus 4.8. Adaptive thinking is always on, so you cannot disable thinking. Tune its depth with the effort parameter instead. And the raw chain of thought is never returned: thinking.display defaults to omitted, so thinking blocks arrive empty unless you set it to summarized. Vision, the memory tool, and context compaction all work from launch.

Use Claude Fable 5 in Claude Code

Claude Code added Fable 5 support in version 2.1.170. Update first so the model shows up:

claude update
claude --version

Start a session pinned to Fable 5 with the model flag:

claude --model claude-fable-5

Or switch mid-session without restarting, which keeps your prompt cache warm:

/model claude-fable-5

Opus 4.8 stays the default in Claude Code, and that is the right call for most work. Switch to Fable 5 for the jobs where its lead is largest: a multi-hour autonomous migration, a repo-wide refactor, deep research across hundreds of files, or a long-horizon agent run that has to stay coherent across millions of tokens. Because Claude Code can burn a lot of output tokens in a long session, watch the bill at the doubled rate. If cost is the worry, the techniques in our guide on cutting Claude Code token usage apply directly, and they matter twice as much on Fable 5. The Claude Code cheat sheet covers the rest of the model and session commands.

The safety classifiers and the Opus 4.8 fallback

The refusal behavior is the one genuinely new thing API developers must plan for. Three classifier families can decline a request:

• Cybersecurity: exploitation and offensive cyber tasks. In external testing across 30 public jailbreak techniques, Fable 5 complied with zero harmful single-turn requests around attack planning, exploit development, or defense evasion.
• Biology and chemistry: broad coverage of dual-use requests, including capabilities like viral vector design.
• Reasoning extraction: prompts that try to make the model reproduce its internal chain of thought, the route competitors use to distill a model.

When a classifier declines, the Messages API does not throw an error. It returns a normal HTTP 200 with stop_reason set to refusal, and names the classifier that fired in stop_details.category, one of cyber, bio, or reasoning_extraction. So the way to detect a refusal in your own code is to branch on stop_reason on every response, not to wrap the call in a try/except. Monitoring built on error rates never sees it, because a refusal is a 200. The fallback to another model is opt-in, not automatic: pass the fallbacks parameter (in beta) to have the API retry on a model you choose, or use the Anthropic SDK middleware to retry from the client. You are not billed for a refused generation, and on a retry the fallback credit refunds the prompt-cache cost of switching. Anthropic’s refusals and fallback guide has the exact response shapes.

For normal software work none of this fires, but it explains why a security-adjacent prompt occasionally behaves differently. Writing a port scanner, reverse-engineering a binary, or fuzzing a parser can land in the cyber classifier and come back refused. Anthropic’s external bug bounty found no universal jailbreaks in over 1,000 hours of testing, and one partner rated Fable 5’s safeguards the toughest of any model it had tested, so do not expect to talk past the classifier.

Should you switch to Fable 5?

For day-to-day coding, Opus 4.8 at half the price and high effort by default is still the model to reach for. Fable 5 earns its premium on the hard tail: large migrations, multi-hour autonomous agents, frontier reasoning, and deep research where one correct long-horizon run is worth more than a stack of cheaper attempts. The benchmark gaps back this up, with Fable 5’s biggest leads sitting exactly on those frontier tasks and shrinking to almost nothing on routine ones.

Run the math on a real job. A repo-wide refactor that burns 2 million input and 200,000 output tokens costs about $30 on Fable 5 against about $15 on Opus 4.8. If that one run replaces a day of an engineer’s time, the $15 gap is noise. Fire thousands of cheap, routine calls and it is not noise at all: the doubled rate stacks up fast, and Sonnet 4.6 or Haiku 4.5 is the right tool. Skip Fable 5 for chat, simple edits, latency-sensitive work, and high-volume classification.

A simple rule: if the job fits comfortably in a single focused session, keep Opus 4.8. If it is the kind of task you would normally break across a whole sprint, point Fable 5 at it and let it run. And if you are on a Pro, Max, or Team plan, test it before June 22 while it is free, because once it moves to usage credits the experiment stops being cheap. This is the third Anthropic frontier release in quick succession after Opus 4.7 and Opus 4.8, and the cadence is the real story: the frontier is moving fast enough that “most capable model” now comes with a price tag and a guardrail attached.