Claude Fable 5.1 vs Opus 5: Detailed Comparison

Anthropic shipped Claude Fable 5.1 on 1 September 2026, five weeks after Claude Opus 5. On the price sheet the choice looks trivial: Fable 5.1 costs exactly twice as much per token. In practice it is not trivial at all, because the two models have different cache economics, different API surfaces, and one of them will reject request shapes the other accepts.

This is a working comparison — what each costs on a real workload, what actually differs at the API level, and which one to reach for.

At a glance

Read the cache-read row twice. It is the most important number in the table and it runs in the opposite direction to everything else.

The pricing headline: 2x on paper, not 2x in practice

Fable 5.1 is double Opus 5 on fresh input and output. But its prompt-cache reads are half Opus 5's — $0.25 per million against $0.50. Anthropic cut Fable's cache reads 4x at the 5.1 release, from $1.00 to $0.25, and did not touch Opus 5's.

That matters enormously, because a long-running agent's bill is not dominated by fresh tokens. It is dominated by re-reading the same cached context on every turn. So the honest question is not "which model is cheaper per token" but "what is the ratio of cached input to generated output in my workload".

The crossover, worked out

Per turn, with C cached tokens, F fresh input tokens and O output tokens, cost in dollars per million is:

Opus 5     = 0.50C +  5F + 25O
Fable 5.1  = 0.25C + 10F + 50O

Fable 5.1 is cheaper when 0.25C + 10F + 50O < 0.50C + 5F + 25O, which simplifies to:

Fable 5.1 costs less when cached tokens > (100 x output tokens) + (20 x fresh input tokens).

Put concretely, for a turn generating 1,000 output tokens on top of 2,000 new input tokens, Fable 5.1 wins once your cached context exceeds about 140,000 tokens. Here is what that looks like on real turn shapes:

So the intuition "Fable 5.1 is the expensive one" is only reliably true for chat-shaped traffic: short context, long answers, little caching. Invert that shape — a coding agent holding a large repository in cache and emitting short, surgical edits — and Fable 5.1 is the cheaper model despite the headline rate.

Two caveats before you act on this. Cache writes still scale with the base rate, so a workload that constantly invalidates its prefix pays Fable's premium twice over; get your caching stable first. And these are list rates for the first-party API — Bedrock and Vertex are partner-operated with their own pricing.

Capability: what the benchmarks actually show

Fable 5.1 is Anthropic's most capable widely released model, positioned above the Opus tier rather than replacing it. The published numbers back that up, with one result that stands out well beyond the usual single-digit creep:

• Terminal-Bench-Science 0.1 — Fable 5.1 at 52.6%, against 29.0% for Opus 5 and 24.7% for Fable 5. That is not an increment; it is nearly double the previous best.
• Artificial Analysis Intelligence Index — Fable 5.1 at 66, ranked first of 196 models, against 63.1 for Opus 5 and 62.1 for Fable 5.
• Agentic evaluations — Opus 5 remains strong in its own right, reporting 93.2% on GPQA Diamond and 70.57% on OSWorld 2.0.

Anthropic also reports Fable 5.1 costing around 25% less than its predecessor on typical workloads and up to about 45% less on complex coding and highly agentic work — efficiency gains at an unchanged headline price, which is the same story the cache-read cut tells.

The gap is real but it is concentrated. On hard, long-horizon, scientific and agentic problems Fable 5.1 is meaningfully ahead. On ordinary work — summarisation, extraction, routine code, chat — you are paying double for a difference most workloads will never observe.

Six API differences that will break your code

This is where the comparison gets practical, and where most write-ups stop at the price table. Swapping the model string is not sufficient in either direction.

1. Thinking configuration

Fable 5.1 has thinking always on. Omit the thinking parameter or send {type: "adaptive"}; anything else is rejected. Both {type: "disabled"} and the legacy {type: "enabled", budget_tokens: N} return a 400.

Opus 5 also runs adaptive thinking by default, but it will accept {type: "disabled"} — though only at effort high or below; pairing it with xhigh or max is a 400. Disabling thinking on Opus 5 is a bad idea anyway: it occasionally writes tool calls into visible text instead of emitting a tool_use block, which fails silently inside an agent loop. Lower the effort instead.

2. Forced tool use is gone on Fable 5.1

tool_choice: {type: "any"}
tool_choice: {type: "tool", name: "..."}

Both return a 400 on Fable 5.1, including through count_tokens and the Batches API. Opus 5 accepts them. If you force a tool call today, moving to Fable 5.1 means switching to {type: "auto"} with an explicit instruction naming the tool, adding strict: true to keep arguments schema-valid, or using structured outputs if the forced call only ever existed to get JSON back. {type: "none"} is unaffected.

3. The refusal stop reason

Fable 5.1 runs safety classifiers that can decline a request. You get HTTP 200 with stop_reason: "refusal" and a category in stop_details — not an exception. Any code that reads content without checking stop_reason first will silently process an empty response.

The mitigation is server-side fallbacks: with the fallback beta enabled, a declined request is automatically re-run on a fallback model inside the same call. A decline before any output is not billed, and the rescue bills at the fallback model's own rates. Opus 5 supports the same mechanism — enable it on both.

4. Preserved thinking and history editing

On Fable 5.1, thinking blocks are bound to the model that produced them, and editing earlier turns invalidates them. Accounts created on or after 31 August 2026 get a 400 for edited history rather than a silent degradation. If your harness rewrites, compacts, or deletes prior turns — and most agent harnesses do — it needs to become append-only before you migrate.

This one catches people because it is not a parameter change. It is an architectural constraint on how your conversation store works.

5. Data retention and Priority Tier

Fable 5.1 requires 30-day data retention and is not available under zero data retention unless Anthropic has expressly authorised it; a ZDR org gets a 400 invalid_request_error. If you are on ZDR for compliance reasons, that decides the question outright. Neither model supports Priority Tier.

6. Fast mode is Opus-only — and it costs exactly Fable money

Opus 5 supports fast mode (research preview, Claude API only), running the same model at up to 2.5x higher output tokens per second. It is priced at $10 / $50 per million — identical to Fable 5.1's standard pricing.

That produces a genuinely interesting decision point. At that budget you can have Opus 5 substantially faster, or Fable 5.1 substantially smarter, for the same money. If your bottleneck is latency, that is an easy call in Opus 5's favour. If it is capability on a hard problem, it is an easy call the other way.

Effort is the lever that cuts across both

Both models take output_config: {effort: ...} across all five levels — low, medium, high, xhigh, max — with high as the default.

Before concluding you need Fable 5.1, try Opus 5 at a higher effort. And before concluding Fable 5.1 is unaffordable, try it at a lower one: on the newest models, lower effort frequently matches or beats the previous generation at high effort. Effort is also the cheaper experiment — one model means one cache namespace, whereas a two-model cascade forfeits cache reuse between them, which given everything above is precisely the economics you do not want to break.

One Fable 5.1 nicety for cost control: it supports changing effort mid-conversation via a system message with empty content, so you can drop to low effort for routine turns without invalidating the cached prefix.

Which should you use?

Use Opus 5 when

The work is ordinary — most coding, most writing, most reasoning. Latency matters, either at default speed or through fast mode. You need forced tool use, disabled thinking, or zero data retention. Your context is small relative to output, which is the shape of most chat and generation traffic. For the large majority of production workloads this is the correct default, and it is half the price.

Use Fable 5.1 when

The problem is genuinely at the frontier — long-horizon agentic runs, hard scientific and research work, complex multi-file refactors, anything where the Terminal-Bench-Science gap reflects your actual task. Or when your workload is cache-dominated: a large stable context re-read across many turns with modest output, where the $0.25 cache read makes it the cheaper option outright.

Do not choose on the headline rate alone

The single most common mistake here will be reading "$10 versus $5" and stopping. For a cache-heavy agent that is simply the wrong conclusion — and for a chat product, the 2x is real and you should take it seriously. Work out your own cached-to-output ratio, put it through the formula above, and let the arithmetic decide.

Migration checklist

Moving an existing Opus 5 integration to Fable 5.1, in the order things will break:

• Remove any thinking: {type: "disabled"} and any lingering budget_tokens.
• Replace forced tool_choice with auto plus an instruction, strict: true, or structured outputs.
• Add a stop_reason === "refusal" branch before you read content, and enable server-side fallbacks.
• Audit your conversation store for history edits and make it append-only.
• Confirm your org is not on zero data retention.
• Drop assistant prefills if any remain — both models reject them.
• Re-tune effort. Prompts written for earlier models are often too prescriptive for Fable 5.1 and can reduce output quality.
• Re-measure cost per completed task, not per token. That is the only number that settles this.

A note on these figures

Fable 5.1 is eight days old at the time of writing, and prices, benchmark indices and beta flags in this space move quickly. Everything above reflects Anthropic's published rates and API behaviour as of 9 September 2026. The cost table is arithmetic on list prices rather than measured invoices — useful for the shape of the decision, not as a quote. Verify against the current pricing and model documentation before committing budget.