Claude Fable 5.1 Is Cheaper. Here's the Real Math

Claude Fable 5.1 did not cut its headline API prices.

Input still costs $10 per million tokens.

Output still costs $50 per million tokens.

Yet Anthropic estimates Fable 5.1 can reduce the cost of a typical workload by roughly 25%, with savings reaching about 45% for highly agentic workloads.

The reason is easy to miss on a pricing table:

cache reads fell from $1.00 to $0.25 per million tokens.

That is a 75% reduction on a part of the bill that can become disproportionately important in long-running agents, Claude Code sessions, tool loops, and other workloads that repeatedly reuse large amounts of context.

But "Fable 5.1 is 45% cheaper" is not a universal statement.

Your actual savings depend on:

• how much context gets cached;
• how frequently that cache is read;
• how many fresh input tokens you send;
• how much output and thinking the model generates;
• your effort setting;
• whether you use Batch;
• and whether cheaper cache reads are offset by the model doing more work.

So instead of repeating the headline percentage, let's work through the actual economics.

What Anthropic Released

Anthropic released Claude Fable 5.1 and Claude Mythos 5.1 on September 1, 2026.

Fable 5.1 is Anthropic's most capable generally available model and uses the API model ID:

claude-fable-5-1

It has:

• a 1 million-token context window;
• up to 128K output tokens;
• always-on adaptive thinking;
• five effort levels: low, medium, high, xhigh, and max;
• high as the default effort;
• text and image input;
• text output;
• a June 2026 reliable knowledge cutoff.

It is available through the Claude API, Amazon Bedrock, Google Cloud, Microsoft Foundry, and Claude Platform on AWS. Anthropic also makes it available to Pro, Max, Team, and Enterprise users in its Claude products.

Claude Mythos 5.1 uses the same underlying model but is offered under a different safeguard and access regime for vetted cybersecurity and life-sciences organizations.

That distinction matters, but the pricing change is where Fable 5.1 becomes particularly interesting for ordinary agent builders.

Claude Fable 5 vs Fable 5.1 Pricing

Here is the part of the pricing table that matters.

Anthropic confirms that cache reads on Fable 5.1 now cost only 2.5% of the standard input-token rate, compared with 10% on most other current Claude models.

Notice what did not get cheaper.

Writing content into the cache still costs the same.

Fresh input still costs the same.

Output still costs the same.

The savings appear only when the application successfully reuses cached context.

That is why the shape of your workload matters more than the headline price.

The Real Math Behind the 25% to 45% Claim

We can demonstrate the effect with a simplified example.

Assume a workload consumes:

• 1 million fresh input tokens;
• 20 million cache-read tokens;
• 500,000 output tokens.

To keep the comparison simple, we'll leave cache-write costs out because those rates are unchanged between Fable 5 and Fable 5.1.

On Fable 5

Fresh input:

1M × $10 = $10

Cache reads:

20M × $1 = $20

Output:

0.5M × $50 = $25

Total = $55

On Fable 5.1

Fresh input:

1M × $10 = $10

Cache reads:

20M × $0.25 = $5

Output:

0.5M × $50 = $25

Total = $40

That is roughly a 27% reduction.

Now make the workflow more agentic.

Suppose the same job involves 50 million cached tokens being reread through a long-running agent loop.

Fable 5

$10 fresh input + $50 cache reads + $25 output = $85

Fable 5.1

$10 fresh input + $12.50 cache reads + $25 output = $47.50

That works out to approximately 44% lower cost.

Suddenly Anthropic's claimed range makes sense.

The cache discount has a modest effect when cache reads are a small part of the workload.

It has a much larger effect when the model repeatedly carries and rereads a substantial context.

Anthropic's published estimate—about 25% savings for typical workloads and up to approximately 45% for highly agentic ones—is therefore plausible from the rate structure alone.

But those percentages still describe Anthropic's estimates, not a guarantee about your invoice.

Why Agent Workloads Benefit More

Consider what happens during a long Claude Code or API agent session.

The model might:

1. inspect a repository;
2. plan a change;
3. read several files;
4. modify code;
5. run tests;
6. inspect failures;
7. revise the implementation;
8. run the suite again;
9. examine another file;
10. continue until the task is complete.

The conversation keeps accumulating information.

There may be:

• system instructions;
• tool definitions;
• project guidance;
• repository context;
• previous tool results;
• earlier messages;
• thinking blocks;
• task state.

With prompt caching enabled, reusable prefixes can be read from cache rather than priced as normal input every time.

That is why agent economics differ from one-shot chat economics.

A user who sends one 3,000-token prompt and receives a response will see comparatively little benefit from a cache-read reduction.

An agent that operates for an hour against hundreds of thousands of tokens of recurring context can see substantially more.

But Cache Reads Are Not Automatically Your Biggest Cost

This is one place I would correct the strongest version of the launch narrative.

It is tempting to say:

Cache reads are the largest cost in every Claude Code session.

That is too broad.

They can dominate token volume in persistent agent loops. But output on Fable 5.1 still costs $50 per million tokens, and adaptive thinking tokens count as output.

A high-effort task that thinks extensively, uses many tools, and produces large outputs can still generate a significant output bill.

Anthropic's newer cost-optimization documentation makes this point indirectly: Fable 5.1 does not win every workload on cost per task, and higher capability can sometimes mean the model simply does more work.

So the metric worth tracking is not:

Which token type looks cheapest?

It is:

What does a successfully completed task cost?

Effort May Be the Bigger Cost Lever

Fable 5.1 supports five effort settings:

low medium high xhigh max

Effort tells Claude how aggressively to spend tokens and computation on the request.

Anthropic's current guidance is clear:

Start at high.

Then move down to medium or low when your own evaluations show that quality still holds. Use xhigh or max for work where additional capability justifies the extra token spend.

This is slightly different from saying everyone should immediately switch Claude Code to Medium.

That would optimize the bill before establishing whether the task still succeeds reliably.

A better workflow is:

Routine Tasks

Try medium or low for:

• straightforward refactors;
• documentation;
• formatting;
• simple code generation;
• repetitive subagent tasks;
• predictable transformations.

Complex Tasks

Keep high for:

• difficult debugging;
• multi-file implementation;
• architecture work;
• unfamiliar codebases;
• complex reasoning;
• agentic tasks where failed work creates expensive rework.

Extreme Tasks

Test xhigh or max when:

• solving unusually difficult bugs;
• conducting deep research;
• running long autonomous work;
• correctness is materially more valuable than speed or token cost.

Anthropic specifically says Fable 5.1 at medium can roughly match Fable 5 at lower cost, while low can be competitive with smaller Claude models on cost per task for some workloads.

The important phrase is for some workloads.

Your evaluation set should decide the setting.

A New Trick: Change Effort Without Breaking the Cache

Fable 5.1 adds a particularly useful capability for agent developers: per-message effort changes.

On supported API requests, a long-running conversation can begin at High, switch to Low or Medium for a routine step, then increase effort again when the task becomes difficult.

More importantly, Anthropic says the per-message mechanism can preserve the existing prompt cache.

That creates a better pattern than choosing one effort level for an entire agent run.

For example:

High: understand the codebase and design the solution.

Medium: implement predictable pieces.

Low: perform routine formatting or summaries.

High: investigate a failing test.

Max: only if the final hard problem justifies it.

This is exactly the kind of routing that can produce larger savings than simply switching model IDs.

One caution: changing the top-level effort setting between requests can restart the cache. For Fable 5.1, Anthropic recommends using its per-message mechanism when changing effort within a cached conversation.

That detail matters if your entire cost strategy depends on the new $0.25 cache-read price.

Prompt Caching Still Has a Write Cost

The cheap read price can make caching look almost free.

It isn't.

For Fable 5.1:

• a five-minute cache write costs $12.50/M;
• a one-hour cache write costs $20/M;
• a cache read costs $0.25/M.

So you still pay a premium when placing fresh content into the cache.

The economics become attractive when that content is reused.

If you cache a giant context and never read it again, the cheaper read price did nothing for you.

If you cache it once and an agent reuses it dozens of times, the new rate becomes much more valuable.

That gives developers a better optimization target:

maximize useful reuse, not merely cache size.

Batch Can Cut Another Part of the Bill

Fable 5.1 also supports Anthropic's Batch API pricing, which currently provides a 50% discount on input and output for eligible batch workloads.

This matters for asynchronous jobs where nobody needs to wait for an immediate response.

Examples include:

• offline analysis;
• large repository reviews;
• classification runs;
• dataset processing;
• overnight research;
• scheduled evaluation jobs.

Anthropic's pricing documentation says pricing modifiers such as Batch and prompt caching can stack.

So if your workload is both highly cacheable and suitable for asynchronous processing, the model-selection discussion should not stop at the standard $10/$50 rate.

Architecture matters.

Fable 5.1 Is Not Universally Cheaper Than Opus 5

This distinction matters because "Fable 5.1 is cheaper" needs a comparison target.

Compared with Fable 5, the cache-read change gives Fable 5.1 an obvious economic advantage for workloads that reuse cached content.

Compared with Claude Opus 5, the answer is different.

Current list pricing is:

Fable 5.1 costs twice as much for uncached input and output, but half as much for cached reads.

That creates an interesting crossover.

A highly agentic workload with enormous context reuse may benefit disproportionately from Fable 5.1.

A workload dominated by fresh input and output can still be cheaper on Opus.

In fact, Anthropic's current model guidance says:

for most workloads, start with Opus 5 and use Fable 5.1 for demanding reasoning and long-horizon agentic work, or when Opus at higher effort falls short.

That is a much better routing rule than "always use the newest frontier model."

What the Benchmarks Actually Show

Anthropic's launch benchmarks show substantial gains over Fable 5, although the size of the improvement varies dramatically by benchmark.

Selected results:

The standout is Terminal-Bench-Science: Fable 5.1's 52.6% is more than twice Fable 5's 24.7%.

But the CursorBench improvement is much smaller: 73.4% versus 70.5%.

That tells us something useful.

Fable 5.1 is not "twice as capable" in general.

Its largest gains appear in particular forms of long-horizon, scientific, agentic, and workflow-oriented work.

Anthropic also cautions that safeguard interventions affect some of its benchmark results, and its Terminal-Bench-Science scores carry several points of standard error.

Treat benchmarks as evidence about capability direction—not as a prediction of your exact success rate.

AutomationBench Improved Dramatically—and Is Still Hard

AutomationBench is a particularly good example of why percentages need interpretation.

Fable 5:

17.1%

Fable 5.1:

31.4%

That is a huge relative improvement.

It is also a 31.4% pass rate.

Those facts can both be true.

If you are building autonomous business agents, the result does not mean human supervision is obsolete. It means the model became substantially better on a benchmark where the absolute success rate remains low.

That is exactly the kind of nuance launch-day benchmark summaries often lose.

Cybersecurity Safeguards Got More Precise

Fable 5.1 also changed how Anthropic handles cybersecurity workloads.

Anthropic says Fable 5.1 can now be used to identify vulnerabilities in source code, allowing more defensive software-security work through the generally available model.

Its safeguards still restrict or reroute higher-risk activities including:

• penetration testing;
• exploit generation;
• binary-based vulnerability scanning.

For most Claude applications, flagged cybersecurity requests fall back to Opus 4.8, while biology fallbacks use Opus 5. API customers need to configure the fallback behavior appropriately.

Anthropic also reported at launch that its updated cyber safeguards produce roughly 60% fewer false positives, with Claude Code users expected to encounter substantially fewer safeguard interventions than under Fable 5.

For defensive security teams, the practical recommendation is simple:

retry legitimate source-code security workflows that were repeatedly intercepted under Fable 5.

But do not interpret "fewer false positives" as "no safeguards."

Fable 5.1 and Mythos 5.1 Are the Same Underlying Model

Anthropic describes Fable 5.1 and Mythos 5.1 as the same underlying model with different safeguards and access conditions.

Mythos 5.1 remains limited to vetted organizations through Anthropic's trusted-access programs, particularly in cybersecurity and life sciences.

Fable 5.1 is the version designed for broad availability.

That is why certain benchmark gaps between the two should not automatically be interpreted as a different underlying intelligence level. Safeguard intervention can affect which tasks the generally available version completes directly.

The API Migration Change That Can Break Agent Harnesses

There is a more immediate issue for developers maintaining custom Claude agents.

Fable 5.1 tightens how preserved thinking blocks are bound to conversation history.

For new API accounts created on or after August 31, 2026, replaying a Fable 5.1 thinking block after modifying the preceding system prompt, tools, or earlier messages can produce a 400 error.

Anthropic's error documentation summarizes the problem plainly: a preserved thinking block must still match the conversation that produced it.

This affects harnesses that do things such as:

• rewrite old conversation turns;
• replace old tool results;
• modify the system prompt during a run;
• compress earlier messages manually;
• preserve thinking blocks while changing their preceding history.

The safest architecture is increasingly append-only conversation history.

If your system must modify history, Anthropic provides beta controls that can drop a mismatched thinking block instead of rejecting the entire request.

Audit this before it becomes a production error.

Another Migration Gotcha: Forced Tool Choice

Fable 5.1 adds another compatibility change that is easier to miss.

The model does not support:

tool_choice: {"type": "any"}

or:

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

Those modes return a 400 error.

auto and none remain supported. Anthropic recommends strict tool use or structured outputs when schema-conformant behavior is required.

If your agent framework assumes it can force a particular tool call, test the integration before simply changing the model ID.

This is a more concrete migration concern than most benchmark improvements.

Enterprise Frontier Safeguards Change the Data-Retention Conversation

Fable-class models normally require 30-day data retention for safety monitoring.

Anthropic's new Enterprise Frontier Safeguards (EFS) is intended to give eligible enterprise customers zero-data-retention-like privacy while maintaining automated safety monitoring.

Under EFS, monitoring data can remain in infrastructure controlled by the customer, under the customer's encryption keys and access policies. Flags go to the customer, and Anthropic human review is not required by default.

Anthropic says EFS was developed with more than 100 customers and is rolling out in phases. Eligible customers can receive zero-data-retention access to Fable 5 and Fable 5.1 during the transition.

For regulated companies, that may matter more than another few benchmark points.

Fable 5.1 Text Is Watermarked

Fable 5.1 also participates in Anthropic's text-watermarking system.

Anthropic says the watermark:

• is invisible to readers;
• adds no hidden characters;
• does not require extra tokens;
• is designed not to affect output quality;
• carries no user, organization, or conversation identifier.

Its purpose is probabilistic detection of whether Claude was involved in producing a passage. Anthropic says Fable 5.1 and Mythos 5.1 text carries the watermark.

The practical consequences depend on your use case.

For code, the impact should be limited because watermarking has less room to operate where tokens have exact functional requirements.

For AI-assisted published prose, regulated communications, education, or environments with AI-disclosure requirements, it is worth knowing that the detection mechanism exists.

So Should You Upgrade From Fable 5?

For someone already paying for Fable 5, Fable 5.1 is a strong migration candidate.

You get:

• the same base input rate;
• the same output rate;
• the same cache-write pricing;
• cache reads at one-quarter the previous cost;
• stronger published performance;
• per-message effort changes;
• more precise safeguards;
• newer agentic capabilities.

But "change the model ID and forget about it" is not enough.

Before production migration:

1. test tool_choice behavior;
2. audit any history rewriting around preserved thinking blocks;
3. rerun your effort-level evaluations;
4. measure actual cache-hit volume;
5. compare cost per successful task, not only cost per million tokens.

Should You Replace Opus 5 With Fable 5.1?

Not automatically.

This is where the article title needs its qualifier.

Fable 5.1 is cheaper than Fable 5 for cache-heavy workloads.

It is not universally cheaper than the Claude lineup.

Opus 5 has half Fable 5.1's uncached input and output rates.

Anthropic's own current documentation recommends starting with Opus 5 for most workloads and moving to Fable 5.1 when demanding reasoning or long-horizon agentic work justifies it.

That suggests a production routing strategy rather than a single-model strategy.

Opus 5

Use when:

• the workload does not require Fable-level capability;
• uncached input/output dominates;
• cost per completed task benchmarks better;
• latency matters more.

Fable 5.1

Use when:

• the task is genuinely difficult;
• the session is long-running;
• context reuse is heavy;
• Opus at higher effort still misses;
• your evaluations show the additional capability reduces retries or human rework.

The model with the lower per-token rate is not necessarily the model with the lower cost per solved problem.

And the model with the highest benchmark score is not automatically the cheapest either.

How I Would Optimize Fable 5.1 in Claude Code

My workflow would start with five rules.

1. Do Not Use Max Effort by Habit

Begin with High on difficult work because that is Anthropic's recommended starting point.

Move routine tasks downward after measuring them.

2. Evaluate Medium and Low

For repetitive or easily verified work, test whether Medium or Low keeps your success rate high enough.

The cost of one failed low-effort attempt followed by an expensive redo may erase the savings.

3. Preserve Cache-Friendly Context

Stable instructions, project context, tool definitions, and recurring reference material are exactly where the new cache economics can help.

Do not restructure prompts randomly between every turn if doing so destroys reusable prefixes.

4. Change Effort Per Message When Appropriate

Fable 5.1 can vary effort during the conversation while preserving cache behavior through its supported per-message mechanism.

Use intelligence where it matters rather than paying for the same reasoning depth on every step.

5. Measure Successful Tasks

Track:

• cache-read tokens;
• cache-write tokens;
• fresh input;
• output;
• effort level;
• task success;
• retries;
• human correction time.

That gives you your real cost curve.

What I Am Measuring in My Own Workflow

I have switched my Claude Code testing to claude-fable-5-1, but the important measurement is not whether the model feels smarter on day one.

I am watching:

• rework rate by effort level;
• successful tasks per dollar;
• cache-read share;
• tool-call count;
• time to completion;
• how often High materially beats Medium;
• whether long sessions remain reliable enough to justify keeping more context.

Those numbers need real usage.

Anthropic's benchmark results tell me which experiments are worth running.

My own tasks decide which settings stay.

That distinction matters.

Vendor benchmarks measure the model under a defined evaluation harness.

Your invoice measures your architecture.

Your rework rate measures whether the architecture was worth paying for.

Three Changes I Would Make This Week

If you already run Fable 5 in production or Claude Code, I would start here.

1. Benchmark Fable 5.1 Against Your Existing Fable 5 Workload

Do not rely only on the 25–45% headline.

Run the same representative tasks and compare:

• task success;
• total tokens;
• cache reads;
• output;
• latency;
• total billed cost.

2. Run an Effort Sweep

Take twenty or thirty representative tasks and compare:

low → medium → high

Only move routine work downward when your own results justify it.

Do not assume Medium is automatically the new universal default.

3. Audit Your Agent Harness

Search for:

• forced tool_choice;
• mutation of previous messages;
• edited thinking blocks;
• system-prompt replacement during active conversations;
• custom conversation compaction.

Those are the areas most likely to turn a simple model migration into a 400 error.

The Bottom Line

Claude Fable 5.1's most important pricing change is hidden in the least glamorous row of the pricing table.

Input did not get cheaper.

Output did not get cheaper.

Cache writes did not get cheaper.

Cache reads went from $1.00 to $0.25 per million tokens.

For a one-shot prompt, that may barely matter.

For an agent repeatedly working over the same large context, it can materially change the cost of the entire session.

But the correct optimization is not simply:

Switch everything to Fable 5.1.

It is:

Use the right model. Use the right effort. Preserve useful cache reuse. Measure retries. Measure successful tasks.

If you are migrating from Fable 5, Fable 5.1 offers a compelling combination of stronger capability and dramatically cheaper cached reads at the same base input/output rates.

If you are choosing across the entire Claude family, the calculation is more nuanced.

That is the real math.

Not dollars per million tokens.

Dollars per problem successfully solved.

Build Better AI Agent Workflows

If you're building production AI agents, Claude Code workflows, API integrations, or automated software systems, you can explore my work here:

• Portfolio: https://www.mejba.me
• Fiverr — AI development & integrations: https://www.fiverr.com/s/EgxYmWD

Related guides:

• How to Cut Claude Fable 5 Usage Costs
• Claude Fable 5 and Mythos 5 Launch Breakdown
• Claude Opus 5 vs Fable 5: Real-Task Testing