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

> Fable 5 is GA at $10/$50 per million tokens with a 1M context - and refusals arrive as HTTP 200, so integrations need refusal handling and a fallback.

URL: https://bartlomiejkrupa.dev/articles/claude-fable-5/
Published: 2026-07-06
Updated: 2026-10-07
Tags: claude, fable, mythos, pricing, refusals, model-selection, prompting
Summary: Fable 5 is GA at $10/$50 per million tokens with a 1M context - and refusals arrive as HTTP 200, so integrations need refusal handling and a fallback.

> **Update (2026-10-07):** Fable 5 is now a legacy model. Its successor, **Claude Fable 5.1** (`claude-fable-5-1`, released 2026-09-01), keeps the $10 / $50 price and cuts cache reads to 2.5% of input. Anthropic retires Fable 5 no sooner than 2027-06-09. The refusal contract below applies to both; refusal billing changed in September 2026 and is corrected below. Current lineup: [tier guide](/articles/claude-model-tier-comparison).

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 5](/articles/claude-opus-5) 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: only organizations verified through Anthropic's verification programs (such as the Cyber Verification Program) get access. 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. See [refusal as API contract](/notes/refusal-as-api-contract).

**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

| | Fable 5 | Mythos 5 | Opus 5 |
| --- | --- | --- | --- |
| API ID | `claude-fable-5` | `claude-mythos-5` | `claude-opus-5` |
| Input / output ($/M tokens) | $10 / $50 | $10 / $50 | $5 / $25 |
| Context / max output | 1M / 128K | 1M / 128K | 1M / 128K |
| Safety classifiers | Yes - can refuse | No | Lighter cyber classifiers; optional fallback to Opus 4.8 |
| Availability | GA: Claude API, Claude Platform on AWS, Bedrock, Google Cloud, Microsoft Foundry | Limited: verified organizations only | GA |
| Data retention | 30-day required, no zero-data-retention | Same | None required for general access |

Both models launched 2026-06-09; access was interrupted after launch and has since been restored - see [Anthropic's redeployment statement](https://www.anthropic.com/news/redeploying-fable-5). 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](https://platform.claude.com/docs/en/models/fable-5/introducing-claude-fable-5-and-claude-mythos-5).

## The refusal contract

Symptom - a request that ran fine on Opus 5 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 Opus 5 (or enable Anthropic's beta automatic fallbacks). With server-side fallback, the API picks the retry model per refusal category - check Anthropic's [refusals and fallback guide](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback) for the current routing:

```ts
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-5", messages);
}
```

Three retry paths, in order of least code:

| Path | Mechanism | Where |
| --- | --- | --- |
| Server-side | `fallbacks` request parameter - the API retries for you | Beta on the Claude API (not on Bedrock, Google Cloud, or Foundry) |
| Client-side | SDK middleware retry | Python, TypeScript, Go, Java, C#, and PHP SDKs - works on any platform |
| Manual | Build the retry yourself | Any platform, any language |

Billing depends on the refusal category. As of September 2026, a refusal before any output is **billed** when its category is `bio`, `frontier_llm`, or `reasoning_extraction` - the categories where Anthropic measures few false positives - and **free** in every other category. A refusal mid-stream bills the input and the output already streamed. 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](/articles/claude-model-tier-comparison) gains a rung on top:

| Role | Tier | Why |
| --- | --- | --- |
| Frontier escalation | **Fable 5** | Hardest reasoning and longest-horizon agentic work - at 2× Opus 5's token rate, plus refusal handling |
| Orchestrator | [Opus 5](/articles/claude-opus-5) | Near-Fable agentic quality at $5/$25 without Fable's full refusal surface |
| Default worker | [Sonnet 5](/articles/claude-sonnet-5) | Near-Opus agentic quality at $2/$10 |
| Parallel worker | Haiku 4.5 | Cheapest fan-out tier |

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](/articles/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"](https://www.youtube.com/watch?v=9fubhllmsBU) (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](/articles/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:

| Pattern | Move |
| --- | --- |
| Blind-spot pass | Before any code, ask the model to enumerate the unknown unknowns - hidden dependencies, API surprises |
| Extreme prototyping | Force radically divergent variants to surface preferences and constraints you have not articulated |
| Reverse interview | Have the model interview you to fill critical gaps in the spec |
| Deviation log + quiz | Model documents its decisions when it hits unplanned barriers, then quizzes you to verify you understand the generated code |

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 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 to Opus 5 (or beta automatic fallbacks), and account for fallback credit in your billing. Reserve the tier for work that earns $10/$50 pricing, keep Opus 5 as the orchestrator default, and shorten your system prompts before you blame the model.

Sources:
- Introducing Claude Fable 5 and Claude Mythos 5: https://platform.claude.com/docs/en/models/fable-5/introducing-claude-fable-5-and-claude-mythos-5
- Claude Fable 5: https://platform.claude.com/docs/en/models/fable-5/overview
- Claude Fable 5.1: https://platform.claude.com/docs/en/models/fable-5-1/overview
- Refusals and fallback: https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback
- Redeploying Claude Fable 5: https://www.anthropic.com/news/redeploying-fable-5