Read time: ~9 minutes. What you’ll learn: the exact model IDs for Claude Fable 5 across the API and cloud platforms, how to enable it in Claude Code and claude.ai, and the three API behaviors that are different from Opus 4.8 — always-on adaptive thinking, HTTP 200 refusals, and the cyber/bio/distillation handoff to Opus 4.8. Every fact below is from Anthropic’s models overview and the Fable 5 launch doc, with vendor/marketing claims flagged as such.

Anthropic released Claude Fable 5 on June 9, 2026 — now its most capable widely released model, built for long-horizon agentic coding. (Source: Anthropic) Switching to it looks trivial: set your model string to claude-fable-5 and go.

It isn’t quite that simple. Fable 5 is a Mythos-class model, and the launch doc is explicit that the Messages API behaves differently for it than for Opus, Sonnet, and Haiku. (Source: Fable 5 launch doc) If you swap the string and assume everything else is identical to Claude Opus 4.8, three things will surprise you. This guide does the easy part first (the model IDs per surface), then the three changes that actually matter.

Key facts:

• The Claude API model ID is claude-fable-5 — dateless, all dashes, a pinned snapshot (not an evergreen pointer). (Source: models overview)
• It’s generally available on the Claude API, Claude Platform on AWS, Amazon Bedrock, Vertex AI, and Microsoft Foundry as of June 9, 2026. (Source: launch doc)
• 1M-token context window, up to 128K output tokens, $10 / $50 per million tokens (input / output). (Source: models overview)
• Adaptive thinking is always on — it’s the only thinking mode, and thinking: {"type": "disabled"} is not supported. (Source: launch doc)
• Refusals return as a successful HTTP 200 with stop_reason: "refusal", not an error. (Source: launch doc)
• Fable 5 is a Covered Model: 30-day data retention, no zero-data-retention option. (Source: launch doc)

The 30-second answer

Where you use Claude	How to switch to Fable 5
Anthropic API	Set model to claude-fable-5 (dashes, pinned snapshot)
Claude Code	claude update, then /model and pick Fable 5 — or claude --model claude-fable-5
claude.ai / desktop app	Click the model name in the prompt box → Claude Fable 5
Amazon Bedrock	Model ID anthropic.claude-fable-5
Vertex AI	Model ID claude-fable-5
Claude Platform on AWS	Same ID as the API: claude-fable-5
Microsoft Foundry	Available June 9; read the exact ID from the model catalog

If you only build against the API, the switch is one line. But read the three sections after the platform IDs — they’re the difference between a working integration and one that throws on the first refused request.

For what Fable 5 actually is and whether it’s worth the price jump, see the companion release breakdown: Claude Fable 5 lands at $10/$50 and tops SWE-Bench Pro.

The Anthropic API: the model string and the dash rule

For direct API use, switching is one field:

claude-fable-5

As with the 4.6-and-later generation, it’s all dashes and dateless — claude-fable-5, never claude-fable-5.0 or claude_fable_5. Each such ID is a pinned snapshot, not a pointer that silently rolls forward. (Source: models overview)

Minimal curl to confirm it works:

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": 256,
    "messages": [{"role": "user", "content": "Reply with the model you are running."}]
  }'

Same string in the official SDKs:

# Python
import anthropic
client = anthropic.Anthropic()
msg = client.messages.create(
    model="claude-fable-5",
    max_tokens=256,
    messages=[{"role": "user", "content": "hello"}],
)

// TypeScript
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const msg = await client.messages.create({
  model: "claude-fable-5",
  max_tokens: 256,
  messages: [{ role: "user", content: "hello" }],
});

That’s the whole “switch” if you only ever read message.content. The next three sections are what bites everyone who assumed Fable 5 is a drop-in Opus 4.8.

Change #1 — Thinking is always on, and you can’t turn it off

On Opus 4.8 you control reasoning with the effort parameter and can run with extended thinking off. Fable 5 is different.

Adaptive thinking is the only thinking mode on Fable 5. It applies whenever the thinking parameter is unset, and crucially, thinking: {"type": "disabled"} is not supported — there is no “thinking off.” You shape depth, not on/off, using the effort parameter. (Source: launch doc)

There’s a second consequence that breaks naive logging: the raw chain of thought is never returned. thinking.display defaults to "omitted", which sends back thinking blocks with an empty thinking field. If you want readable reasoning, set it explicitly:

msg = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Plan a refactor of this module."}],
    thinking={"display": "summarized"},   # default is "omitted" → empty thinking field
)

Two rules that follow from this, both from the launch doc:

• Don’t expect raw CoT. summarized gives you a readable summary, not the verbatim reasoning. There is no setting that returns the raw chain of thought on Fable 5.
• In multi-turn conversations on the same model, pass thinking blocks back unchanged. Don’t strip or rewrite them between turns.

If your Opus integration sets thinking: {"type": "disabled"} or parses raw thinking text, both will need changing before Fable 5 works.

Change #2 — Refusals are an HTTP 200, not an error

This is the one most likely to take down a production integration on day one.

Fable 5 ships with safety classifiers that can decline a request. When that happens, the Messages API returns a successful HTTP 200 with stop_reason: "refusal", and the response also reports which classifier declined. It is not an HTTP error and won’t land in your except/catch block. (Source: launch doc)

So code that only checks the HTTP status will treat a refusal as success and hand your users an empty or truncated answer. Check stop_reason:

msg = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": user_input}],
)

if msg.stop_reason == "refusal":
    # not an exception — a normal 200. Handle it explicitly.
    handle_refusal(msg)

Anthropic gives you two ways to recover automatically:

• Server-side fallbacks parameter (in beta on the Claude API and Claude Platform on AWS): pass it and the API retries the refused request on another Claude model for you.
• SDK middleware (TypeScript, Python, Go, Java, and C#): retry from the client on any platform.

And the billing is sane about it: you are not billed for a request that’s refused before any output is generated, and when you retry on another model, fallback credit refunds the prompt-cache cost of switching. (Source: launch doc) So adding a fallback path doesn’t double your token bill on refused calls.

Change #3 — Cyber, bio, and distillation work is handed to Opus 4.8

The most visible classifier in practice is the cyber one. When Fable 5’s classifiers detect a request related to cybersecurity, biology and chemistry, or distillation, the response is automatically handled by Claude Opus 4.8 instead. Anthropic reports that more than 95% of Fable sessions involve no fallback at all. (Source: Anthropic)

This is why Fable 5 scores 0.0 on every offensive-cyber benchmark — not because it’s weak there, but because it declines and hands off by design:

What this means if you build security tooling: a fraction of your Fable 5 calls will quietly be served by a less capable coding model (Opus 4.8 scores 69.2% on SWE-Bench Pro vs Fable’s 80.3%). If your product depends on consistent capability, detect the handoff and decide whether to surface it to users. If you do defensive-security work that keeps tripping the classifier, that’s expected behavior, not a bug.

claude.ai and the desktop app

No setup here — Anthropic rolls the model out server-side and says Fable 5 is “available everywhere today.” (Source: Anthropic)

1. Open claude.ai or the Mac/Windows desktop app.
2. Click the model name at the bottom of the prompt box (it shows whatever you last used).
3. Pick Claude Fable 5 from the menu.

The billing window to know: Fable 5 is included at no extra cost on Pro, Max, Team, and seat-based Enterprise from June 9–22, 2026. From June 23 onward it draws on usage credits. (Source: Anthropic) So there’s a two-week window to try it on your existing subscription before it costs anything.

Claude Code

Fable 5 is the strongest coding model in the lineup, so it’s the one to reach for on long, multi-step runs in Claude Code as a daily driver. The enablement path is the same as any new model:

Step 1 — Update the CLI

claude update

The model picker only shows what your installed CLI knows about, so an out-of-date build won’t list Fable 5. Update first, then confirm:

claude --version

(At the time of writing, a current build is 2.1.170.)

Step 2 — Pick it in /model

Inside a session:

/model

Select Fable 5 in the interactive picker. Since v2.1.153, the model you pick in /model is saved as the default for new sessions — it writes the model field into your user settings, so you don’t re-pick every time. (Source: Claude Code model configuration)

Step 3 — Or pin it directly

For one session without changing your default:

claude --model claude-fable-5

Or permanently, in ~/.claude/settings.json:

{
  "model": "claude-fable-5"
}

If Fable 5 isn’t in your picker after claude update, it’s almost always a stale CLI or a plan that doesn’t include it yet — the same pattern as enabling Opus 4.8, where 95% of “it’s missing” reports are an old CLI.

Cloud platforms: Bedrock, Vertex, Foundry

Fable 5 is GA on all three from June 9. The model-ID string differs per platform:

Platform	Model ID
Claude API	claude-fable-5
Claude Platform on AWS	claude-fable-5 (same as the API)
Amazon Bedrock	anthropic.claude-fable-5
Vertex AI	claude-fable-5
Microsoft Foundry	Read from the model catalog

(Source: models overview.) Confirm the exact current string in your platform’s model list before shipping — cloud IDs occasionally carry endpoint or version suffixes the first-party API does not. Note that Bedrock and Vertex both offer global vs regional endpoint types for current models; pick the one that matches your data-routing requirements.

What’s supported at launch

If you rely on advanced features, here’s what Fable 5 supports out of the gate (Source: launch doc):

• Effort — control thinking depth (your replacement for “thinking off”).
• Task budgets — beta, via the task-budgets-2026-03-13 header.
• The memory tool.
• Tool-result clearing via context editing — beta, via the context-management-2025-06-27 header.
• Compaction.
• Vision — text and image input.

The one to internalize is Effort: since you can’t disable thinking, effort is how you keep cost and latency in check on routine calls. Reserve high effort for the hard agentic runs the model is built for.

Pricing: when to actually reach for Fable 5

At $10 / $50 per million tokens, Fable 5 costs roughly double Opus 4.8’s $5 / $25. (Source: models overview) It is not a blanket replacement. The clean pattern:

• Reach for Fable 5 on the hard, long-horizon, multi-step agentic runs where its SWE-Bench Pro lead (80.3% vs Opus 4.8’s 69.2%, on Anthropic’s own table) translates into fewer failed iterations.
• Stay on Opus 4.8 or cheaper for routine edits, short chats, and high-volume calls where the capability gap doesn’t pay for the price.

Anthropic cites Stripe and GitHub executives crediting Fable 5 with large autonomy gains; treat vendor quotes as marketing, but the measured SWE-Bench Pro gap over Opus 4.8 is on the same eval.

One more constraint: data retention

Fable 5 (and Mythos 5) are Covered Models, which carry 30-day data retention and are not available under zero data retention. (Source: launch doc) If your compliance posture requires ZDR, Fable 5 is off the table and you stay on a model that offers it. This is a hard gate, not a setting.

Troubleshooting

Symptom	Cause	Fix
API “succeeds” but returns empty/odd output	Refusal returned as HTTP 200	Check stop_reason == "refusal"; add a fallbacks path
thinking: {"type": "disabled"} errors	Not supported on Fable 5	Remove it; use effort to control depth
thinking field comes back empty	display defaults to "omitted"	Set thinking: {"display": "summarized"}
Security prompts answered by a weaker model	Cyber classifier handoff to Opus 4.8	Expected; detect the handoff if capability must be consistent
Fable 5 missing in Claude Code /model	Stale CLI or plan gate	claude update, then /model
Can’t use zero-data-retention	Covered Model: 30-day retention required	No fix; choose a ZDR-eligible model if required
Cloud call 404s	Wrong per-platform ID	Bedrock = anthropic.claude-fable-5; read the catalog

Bottom line

The model string — claude-fable-5, dashes, pinned — is the easy 10%. The real switch is the three behavior changes: thinking is always on (shape it with effort, never disable it), refusals come back as a 200 you have to check, and cyber/bio/distillation work is handed to Opus 4.8. Wire those three into your integration and Fable 5 is a clean upgrade for hard agentic coding. Skip them and your first refused request looks like a silent failure.

If you haven’t switched your everyday model yet, the Opus 4.8 enablement guide covers the surface you’ll fall back to — and our Claude Fable 5 release breakdown has the full benchmark picture.

Sources

• Introducing Claude Fable 5 and Claude Mythos 5 — Anthropic docs (API changes, refusals, availability)
• Models overview — Anthropic docs (model IDs, context, pricing)
• Claude Fable 5 and Claude Mythos 5 — Anthropic (free window, cyber fallback, benchmarks)
• Claude Code model configuration — Claude Code docs
• Companion: Claude Fable 5 release breakdown · How to switch to Opus 4.8