Claude Fable 5: refusals are an API contract, not an error

Anthropic shipped Claude Fable 5 (claude-fable-5) on 2026-06-09 as its most capable widely released model - a 1M-token context, up to 128K output tokens, at $10 / $50 per million input/output tokens. The integration-breaking change is not the price: Fable 5 is the first Claude whose safety classifiers can decline a request, returned as a successful HTTP 200 with stop_reason: "refusal". If your code treats every 200 as usable output, it is wrong on Fable 5. Plan for three changes: refusal handling, a fallback path to another Claude model, and new billing rules.

Definitions

Fable 5 - Anthropic’s frontier tier (claude-fable-5), above Opus 4.8 in capability, built for the most demanding reasoning and long-horizon agentic work. Generally available; includes safety classifiers.

Mythos 5 - the same model without the safety classifiers (claude-mythos-5). Not generally available: limited release to approved customers through Anthropic’s Project Glasswing. Successor to Claude Mythos Preview.

Refusal - a Fable 5 response where a safety classifier declined the request. Delivered as HTTP 200 with stop_reason: "refusal"; the response reports which classifier declined.

Fallback credit - a billing mechanism that covers the extra charge of rebuilding Claude’s prompt cache (the discount lost when a cached prompt has to be reprocessed from scratch on a new model) when you retry a refused request elsewhere.

What shipped

Both models launched 2026-06-09; access was interrupted after launch and has since been restored - see Anthropic’s redeployment statement. Both are designated Covered Models: 30-day data retention, not available under zero-data-retention agreements - check this before routing regulated workloads.

Source: Introducing Claude Fable 5 and Claude Mythos 5.

The refusal contract

Symptom - a request that ran fine on Opus 4.8 returns HTTP 200 on Fable 5 but no usable output. Cause - a safety classifier declined it; the Messages API reports this as a success with stop_reason: "refusal", not as an error, so nothing throws. Solution - branch on the stop reason and retry on a model without classifiers in your allowed set:

const msg = await client.messages.create({
  model: "claude-fable-5",
  max_tokens: 4096,
  messages,
});

if (msg.stop_reason === "refusal") {
  // HTTP 200, not an exception. Retry on another Claude model -
  // fallback credit covers the prompt-cache cost of switching.
  return retryOn("claude-opus-4-8", messages);
}

Three retry paths, in order of least code:

Billing follows the same contract: a request refused before any output is generated is not billed, and fallback credit covers the prompt-cache cost of the retry model.

Thinking works differently

Two Messages API behaviors are specific to Fable 5 and Mythos 5 - Opus, Sonnet, and Haiku are unchanged:

• Adaptive thinking is the only mode. thinking: {"type": "disabled"} is not supported; depth is controlled by the effort parameter.
• Raw chain of thought is never returned. thinking.display: "summarized" gives a readable summary; "omitted" (the default) returns empty thinking blocks. Pass thinking blocks back unchanged in multi-turn conversations on the same model.

At launch both models support effort, task budgets (beta), the memory tool, code execution, programmatic tool calling, context editing (beta), compaction, and vision.

Where Fable 5 sits in the stack

The role table from pick the right Claude tier gains a rung on top:

The escalation logic mirrors the Sonnet-to-Opus rule: move up only when the task needs it, because the price doubles again and the refusal contract adds an integration cost the lower tiers do not have. A 1M window at $10 per million input also sharpens the case that context engineering beats a bigger window - filling the window is now a $10 decision per shot.

Working with Fable: notes from Anthropic’s field guide

Thariq Shihipar’s launch talk “Field Guide to Fable” (Anthropic) is the closest thing to an official operating manual. Claims below are from the talk, not the docs:

• Capability overhang. Fable routes around gaps in its own knowledge by invoking external scripts and tools on its own initiative - capability you get without prompting for it.
• Shorter prompts win. Fable needs much shorter system instructions than earlier models; rigid prohibitions and long few-shot example blocks suppress its analysis. If your prompt is a wall of rules, that is now a liability - the same failure mode as an overloaded CLAUDE.md, covered in why agents ignore your CLAUDE.md.
• Four patterns for managing unknowns - closing the gap between your architecture-as-imagined and the code-as-it-is:

The talk’s larger claim - the fast-good-cheap triangle stops binding, and the bottleneck moves from writing code to finding the business value worth building - is a thesis, not a benchmark. The four patterns above are the actionable part.

Bottom line

Fable 5 is the new top of the stack, and the migration work is not prompt tuning - it is plumbing. Handle stop_reason: "refusal" on every call, wire a fallback model, and account for fallback credit in your billing. Reserve the tier for work that earns $10/$50 pricing, keep Opus 4.8 as the orchestrator default, and shorten your system prompts before you blame the model.