Claude Fable 5 Developer Guide: API, Pricing, Refusals

Anthropic’s most capable generally available model has been live for forty days, and the coverage gap is embarrassing. Claude Fable 5 (claude-fable-5

) is the model that 64 Claude agents used to rewrite Bun’s entire 535K-line codebase from Zig to Rust in 11 days. It leads every published competitor on SWE-Bench Pro by 11 points. It also ships with a refusal system that returns HTTP 200 — which will silently break your error handling if you’re not ready for it. Here’s what developers actually need to know.

Get the Model ID Right #

The API model ID is claude-fable-5

. No date suffix — it uses the dateless naming convention Anthropic introduced with the 4.6 generation, where the ID is still a pinned snapshot, not an evergreen pointer that updates without warning.

Availability: Claude API, Amazon Bedrock (anthropic.claude-fable-53

), Google Cloud (claude-fable-5

), Microsoft Foundry, and Claude Platform on AWS. If you’re running behind an OpenAI-compatible gateway, switching to Fable 5 is one line.

• Context window: 1M tokens
• Max output: 128K tokens per request
• Adaptive thinking: always on — thinking: {"type": "disabled"}

is not supported - Raw chain-of-thought: never returned (summary or omitted via thinking.display

) - Knowledge cutoff: January 2026

One tokenizer note that affects cost calculations: Fable 5 uses the tokenizer introduced with Opus 4.7. Compared to models before Opus 4.7, the same text produces roughly 30% more tokens. Run your existing prompts through the tokenizer before your pricing assumptions carry into production.

The Refusal You Won’t See Coming #

This is the thing that will bite you if you migrate from Opus 4.8 without reading the docs. Claude Fable 5 includes safety classifiers that can decline certain requests. When that happens, the API returns HTTP 200 — not a 4xx error — with stop_reason: "refusal"

. The content array is empty. Any code that reaches into content before checking stop_reason

will fail silently or throw a null reference error.

Branch on stop_reason

before you touch content. Every time. That is the rule.

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Refactor this authentication module..."}],
    fallbacks=[{"model": "claude-opus-4-8"}],
    betas=["server-side-fallback-2026-06-01"],
)

if response.stop_reason == "refusal":
    print("Request declined by classifier.")
else:
    print(response.content[0].text)

Three fallback options are available. Server-side fallback (currently in beta on the Claude API) lets you declare a fallback model in the request, and the API retries automatically. Client-side fallback uses SDK middleware. Manual fallback means you catch the refusal and send a second request yourself.

What triggers refusals? Offensive security tooling, exploit development, malware, and biology synthesis routes are the main categories. In practice, fewer than 5% of sessions hit a classifier. A refusal that fires before any output is generated is free — no charge, doesn’t count against rate limits. Mid-stream refusals bill for whatever was already generated.

What Does $10/$50 Per Million Tokens Buy You? #

Fable 5 costs twice what Opus 4.8 costs ($10/$50 vs $5/$25 per million input/output tokens). The case for paying the premium lives in the benchmarks. SWE-Bench Pro: 80.3%, which is 11 points ahead of the next published score. Spatial reasoning: 38.6%, versus Opus 4.8’s 14.5%. FrontierCode Diamond: more than double the performance on difficult production-codebase tasks.

The pattern holds across every benchmark: the longer and more complex the task, the larger Fable 5’s lead. It is not built for quick queries. It is built for multi-stage work where the model needs to plan across sessions, delegate to subagents, write its own tests, and use vision to evaluate outputs.

Make the Cost Math Work #

Prompt caching is the first thing you set up, not an afterthought. A 200K-token agent context costs $2.00 every time you re-send it cold. Cache it and the cost drops to $0.20 per call — 90% savings. Over 50 agent iterations, that gap is $100 versus $12. The 5-minute cache TTL pays for itself after a single read.

The second lever is model tiering. Fable 5 as orchestrator, Sonnet 5 or Haiku 4.5 as subagents for mechanical execution. Planning an approach, reviewing a diff for real bugs, designing architecture — that is Fable’s work. Renaming symbols across forty files, running the test suite, generating boilerplate — that is Sonnet’s work. This pattern cuts real costs substantially while preserving quality where it matters.

Use the effort

parameter to control thinking depth. The task budgets beta (task-budgets-2026-03-13

header) lets you cap compute per task.

Fable 5 or GPT-5.6 Sol? #

Both are the flagship model in their respective ecosystems. They win different benchmarks.

Fable 5 leads on SWE-Bench Pro (80.3%; OpenAI has not published a Sol score for this benchmark). GPT-5.6 Sol leads Terminal-Bench 2.1 at 88.8%. Sol is cheaper at $5/$30 per million tokens, and its Programmatic Tool Calling feature reduces API round trips by 38–63% on tool-heavy workloads.

Pick Fable 5 when the work is codebase-level complexity, long-horizon agents, or tasks that play to Anthropic’s safety posture. Pick Sol when the work is terminal automation, tool orchestration, or cost-sensitive scale. They’re not interchangeable — they’re complementary if your stack can route between them.

Bottom Line #

Fable 5 is the best available model for complex engineering work right now. Opus 5 is reportedly coming — a Cursor changelog leak showed “Claude Honeycomb” with an Opus 5 designation. Until that lands, Fable 5 is where the capability ceiling sits for Anthropic users. Set up the refusal handler, enable prompt caching, tier your subagents, and start with the smallest effort level that works for your task.