Is Claude Fable 5.1 actually cheaper to use?

What exactly got cheaper with Claude Fable 5.1?

Claude Fable 5.1 is cheaper than Fable 5 in one specific part of the bill: rereading cached context.

Anthropic kept Fable’s normal API prices at $10 per million fresh input tokens and $50 per million output tokens. Five-minute cache writes also remain $12.50 per million tokens, while one-hour cache writes remain $20.

The big change is the cache-read price. Fable 5 charged $1 per million cached tokens. Fable 5.1 charges $0.25, a 75% cut.

That distinction explains most of the confusion around the launch. Someone sending a completely fresh prompt gets essentially the same Fable price as before. Someone running an agent that keeps rereading the same repository, instructions, tools and conversation history can see a much bigger reduction.

Anthropic currently estimates that the new pricing reduces a typical Fable workload by around 25%, with some highly agentic workloads reaching roughly 45%. Those percentages describe total workload cost rather than a blanket reduction in every Fable token price.

Claude price per 1M tokens	Fable 5	Fable 5.1	Change
Fresh input	$10.00	$10.00	0%
Output	$50.00	$50.00	0%
5-minute cache write	$12.50	$12.50	0%
1-hour cache write	$20.00	$20.00	0%
Cache read	$1.00	$0.25	-75%

Why can cheaper cache reads cut a Claude Fable 5.1 agent bill so much?

Claude Fable 5.1 can become much cheaper when an AI agent spends most of its time rereading information it has already seen.

A long coding session makes the mechanism easy to see. The agent might load repository instructions, tool definitions, architecture documents, source files and its previous work early in the session. On later steps, much of that context remains unchanged. Claude can reuse the cached prefix instead of treating every token as completely fresh input.

Cognition published an unusually useful real-world example from its Devin coding agent. A typical Fable 5.1 task in its FrontierCode testing read about 3 million cached tokens, while using only around 70,000 uncached input tokens and producing roughly 21,000 output tokens.

In other words, more than 95% of the tokens the agent read were cached.

That is exactly the kind of workload where Fable 5.1’s pricing suddenly looks very different from its $10-per-million headline input rate. Cognition calculated that the same task would have cost about $4.99 using the old Fable cache rate. Under the new pricing, it came to $2.68.

For an ordinary chatbot, a 75% cut to one narrow category of tokens can sound minor. For an agent where millions of old tokens are reread between tool calls, that category can dominate the input bill.

Does Anthropic’s claim that Fable 5.1 is about 25% cheaper hold up?

Anthropic’s 25% estimate looks credible for the kind of Fable workloads people are increasingly running today, although we would treat it as a useful production reference rather than a universal discount.

Anthropic says it calculated the figure from four weeks of actual usage across Claude Enterprise, Claude Code and the API. The company compared what those workloads cost under Fable 5 pricing with what the same token mix would cost under Fable 5.1.

On that production mix, the estimated cost fell by roughly one quarter.

That result makes sense once we compare it with Cognition’s much more cache-heavy Devin workload. Cognition expects users to save around 10% to 25% on real work after moving to Fable 5.1, even though its controlled FrontierCode benchmark produced a much larger reduction.

The gap is revealing. Benchmarks can create ideal conditions for cache reuse, while production traffic includes shorter tasks, fresh context, different output lengths and sessions where caching helps less.

So we would use roughly 25% as a reasonable upper-middle expectation for a well-structured agent workload today. Anyone budgeting on the assumption that every Fable request automatically becomes one quarter cheaper will probably be disappointed.

Is Anthropic’s “up to 45% cheaper” Fable 5.1 claim realistic?

Claude Fable 5.1 can reach savings around 45%, but the workload has to be extremely favorable to caching or the new model has to finish the job with fewer tokens.

The arithmetic sets a high bar.

Imagine total input of one million tokens and 20,000 output tokens. If half of the input comes from cache, Fable 5.1 saves less than 6% compared with Fable 5. At 80% cached input, the saving rises to roughly 16%. Push the cache share to 90% and the saving reaches about 23%.

Output makes the 45% figure harder to reach because Fable still charges $50 per million output tokens. Every dollar spent generating an answer sits outside the cache discount.

If we isolate the pricing change and assume zero output, cached tokens would need to account for roughly 94% of all input before the total bill falls by about 45%. Once the model starts producing meaningful output, the required cache share rises further.

The upper-end claim becomes more plausible when Fable 5.1 also works more efficiently. Early deployments have reported fewer tokens or fewer agent steps on some tasks, which gives the model a second way to reduce total spending.

For now, 45% should be read as an excellent result for a highly optimized workload, rather than the number a normal Fable customer should put into a budget.

Example: 1M input + 20K output	Fable 5	Fable 5.1	Saving
50% of input cached	$6.50	$6.13	5.8%
80% of input cached	$3.80	$3.20	15.8%
90% of input cached	$2.90	$2.23	23.3%

Can Claude Fable 5.1 actually cost more than Fable 5?

Yes. Claude Fable 5.1 can end up costing more per completed task when it uses enough extra reasoning and output tokens to eat through the savings on cached input.

Artificial Analysis found exactly that in its independent pre-release evaluation.

At maximum effort, Fable 5.1 scored 66 on the Artificial Analysis Intelligence Index, up from 62 for Fable 5. Yet the new model cost about $3.76 per benchmark task compared with $3.14 for Fable 5, roughly 20% more.

Artificial Analysis traced the increase mainly to output consumption. Fable 5.1 used around 1.7 times as many output tokens as Fable 5 at maximum effort.

The cheaper cache still had a big impact. Artificial Analysis calculated that it saved roughly $1.40 per task; without the reduction, the same Fable 5.1 workload would have cost around $5.16.

But the benchmark exposes the flaw in saying “Fable 5.1 is 25% cheaper” without describing the workload. Fable’s output costs $50 per million tokens. A model that thinks or writes substantially more can burn through a large cache saving very quickly.

This is also one of the strongest pieces of independent evidence we have currently because Artificial Analysis tested the model before release rather than simply repeating Anthropic’s pricing estimates.

Why did Cognition find Fable 5.1 much cheaper when Artificial Analysis found it more expensive?

Cognition and Artificial Analysis reached opposite conclusions because they tested very different ways of using Claude Fable 5.1.

Cognition tested Fable 5.1 inside Devin on FrontierCode 1.1 Extended at medium effort. Fable 5 cost $5.84 per task. Fable 5.1 came in at $2.68, a 54% reduction, while slightly improving the benchmark score from 62.8 to 63.6.

Artificial Analysis tested a broad mix of reasoning, coding, knowledge-work and agentic benchmarks at maximum effort. There, Fable 5.1 cost around 20% more per task than Fable 5.

The biggest difference is token shape.

Devin’s coding sessions are spectacularly cache-heavy. Cognition says more than 95% of the tokens its agents read on a typical FrontierCode task are cache reads. Artificial Analysis also benefited from cheaper cache, especially on its agentic evaluations, but Fable 5.1 generated far more expensive output at maximum effort.

Effort level matters too. Cognition used medium effort. Artificial Analysis’s expensive comparison used max.

Put together, the two results are more useful than either one on its own. There is no honest single answer to “How much cheaper is Fable 5.1?” A long coding agent at medium effort can save a lot. A reasoning-heavy benchmark running at max can cost more.

The model name stays the same while the economics change dramatically underneath it.

Does Fable 5.1 use fewer tokens than other Claude models?

Claude Fable 5.1 has shown strong token efficiency in several real agent deployments, but we have also seen the opposite behavior at maximum reasoning effort.

Cognition found that Fable 5.1 used about 33% fewer tokens than Opus 5 to finish the same FrontierCode tasks. Its typical Fable 5.1 task read roughly 3 million cached tokens and generated around 21,000 output tokens, while Opus 5 read around 4.5 million cached tokens and generated about 26,000 output tokens.

Every saw an even bigger difference in its internal Slack agent. At medium effort, Fable 5.1 completed comparable work to Opus 5 using less than half as many tokens and in around 60% of the time.

Rogo reported another version of the same pattern on finance work: Fable 5.1 matched Fable 5’s accuracy on its internal benchmark while using about 20% fewer tokens.

Then there is Artificial Analysis, where maximum-effort Fable 5.1 became extremely verbose. Across its Intelligence Index evaluation, max Fable 5.1 produced roughly 140 million output tokens compared with only about 13 million at low effort.

So we should avoid describing Fable 5.1 as inherently token-efficient. At sensible effort levels inside good agent harnesses, it can be remarkably efficient. Turn it loose at maximum effort and the model can consume tokens very aggressively.

That makes configuration part of the price.

Is Claude Fable 5.1 cheaper than Claude Opus 5 for real work?

Claude Fable 5.1 can now beat Opus 5 on cost in highly cached agent workloads, although Opus 5 remains cheaper when both models consume similar amounts of ordinary input and output.

The rate cards initially make the comparison look easy. Fable 5.1 charges $10 per million fresh input tokens and $50 per million output tokens. Opus 5 charges $5 and $25.

For identical fresh-token consumption, Fable costs twice as much.

Caching changes that relationship because Fable 5.1 now charges $0.25 per million cache reads while Opus 5 charges $0.50. An agent that constantly rereads its working context can therefore spend less on its largest input category with Fable.

Cognition has already measured this reversal in Devin. On FrontierCode 1.1 Extended, Fable 5.1 cost $2.68 per completed task versus $3.51 for Opus 5. Cognition also found that Fable used fewer tokens to finish the work.

That result is strong enough that Cognition said it was moving some Devin workloads previously kept on Opus to Fable 5.1.

Artificial Analysis found a different result on its broader benchmark suite. Fable 5.1 at maximum effort cost more than Opus 5 while scoring somewhat higher. The cheaper-per-task advantage has clearly appeared in production-style coding agents, but we cannot generalize it to every kind of work.

Right now, Opus remains the safer cost choice for ordinary workloads. Fable becomes economically interesting when heavy cache reuse and stronger task efficiency work together.

Claude model	Fresh input / 1M	Cache read / 1M	Output / 1M
Fable 5.1	$10.00	$0.25	$50.00
Opus 5	$5.00	$0.50	$25.00
Sonnet 5	$2.00	$0.20	$10.00
Haiku 4.5	$1.00	$0.10	$5.00

Is Claude Fable 5.1 cheaper than Sonnet 5?

Claude Sonnet 5 is still much cheaper than Fable 5.1, so Fable only makes financial sense when the harder model materially improves the chance of finishing the task.

Sonnet 5 costs $2 per million fresh input tokens and $10 per million output tokens, one fifth of Fable 5.1’s rates. Sonnet also has a slightly cheaper cache-read rate at $0.20 per million tokens versus $0.25 for Fable.

That gives Sonnet an advantage across every major token category.

The case for Fable therefore has to come from the result rather than the rate card.

Anthropic reports that Fable 5.1 scored 55.8% on Terminal-Bench 4.0 compared with 42.0% for Fable 5. On AutomationBench, which tests end-to-end business workflows, it reached 31.4% compared with 17.1% for Fable 5. Terminal-Bench-Science jumped from 24.7% to 52.6%.

Those gaps are large enough to matter on difficult tasks. Browserbase provides a more practical example: on its hardest browser-agent benchmark, Fable 5.1 completed 82% of tasks, compared with 74% for Opus 5 and 57% for Fable 5, while reportedly using fewer tokens than either.

A cheap failed run is still a failed run. If Sonnet completes the task reliably, we would choose Sonnet on cost almost every time. Fable starts earning its premium when the cheaper model fails often enough to require retries, escalation or human help.

Is Fable 5.1 actually cheap compared with other frontier AI models?

Claude Fable 5.1 remains an expensive frontier model today despite its much better economics for cached agents.

Artificial Analysis currently describes Fable 5.1’s standard $10 input and $50 output rates as expensive relative to other proprietary reasoning models in its database. Its comparison set has a median around $2 for input and $10 for output.

Anthropic’s own lineup tells the same story. Opus 5 charges half as much for fresh input and output. Sonnet 5 charges one fifth as much.

Fable 5.1 becomes unusually competitive only when we look at cached input. Its $0.25 cache-read price is half Opus 5’s rate and sits surprisingly close to Sonnet 5’s $0.20.

That creates a strange cost profile. Fable is very expensive when the model sees information for the first time and extremely cheap when it rereads information already sitting in cache.

For short generation, extraction, classification and isolated prompts, that profile is hard to justify. For long-running agents with massive stable contexts, it can work remarkably well.

Calling Fable 5.1 “cheap” goes too far. Calling it much cheaper to operate as a persistent agent is far closer to what the current evidence shows.

Is maximum effort on Fable 5.1 a waste of money?

Claude Fable 5.1 at maximum effort looks hard to justify for many workloads because current independent testing shows costs climbing much faster than benchmark performance.

Artificial Analysis tested five effort settings. Fable 5.1 scored 58 on its Intelligence Index at low effort, 60 at medium, 62 at high, 65 at xhigh and 66 at max.

The cost curve was much steeper. The same benchmark cost roughly $0.77 per task at low effort, $1.00 at medium, $1.43 at high, $2.65 at xhigh and $3.69 at max.

The final step is especially expensive. Moving from xhigh to max gained only one Index point while increasing measured cost by roughly 39%.

Token consumption explains much of it. Artificial Analysis recorded about 13 million output tokens across the evaluation at low effort versus roughly 140 million at max, an increase of around eleven times.

This is one area where we can be fairly sharp: running Fable 5.1 at maximum effort by default looks financially sloppy unless the task genuinely benefits from that last bit of reasoning.

Medium and high effort currently look much more interesting. They capture a large share of Fable 5.1’s intelligence while keeping output consumption under much better control.

Fable 5.1 effort	Artificial Analysis Index	Approx. cost per task
Low	58	$0.77
Medium	60	$1.00
High	62	$1.43
Xhigh	65	$2.65
Max	66	$3.69

Are long-running coding agents where Fable 5.1 saves the most money?

Long-running coding agents are currently the clearest case where Fable 5.1’s unusual pricing can genuinely beat cheaper-looking models.

Coding agents repeatedly revisit the same material. Repository instructions stay in context. Tool definitions stay in context. Earlier messages stay in context. Source files and plans are often reread while the agent edits code, runs tests, inspects errors and tries again.

That creates enormous cache reuse.

Devin gives us the cleanest measured example because Cognition published both token composition and task cost. Its typical Fable 5.1 FrontierCode task reads millions of cached tokens but only tens of thousands of fresh ones. Under those conditions, Fable 5.1 ended up cheaper per task than Opus 5 despite charging twice as much for normal input and output.

Other launch testing points in the same direction on capability. Shopify reported that Fable 5.1 stayed on track during long unattended workflows while keeping its own records and reprioritizing as conditions changed. MongoDB said one prototype ran for hours unattended after researching its service code and documentation. Ramp reported a machine-learning task that ran for 38 hours, reassessed an earlier result and launched six follow-up experiments.

Those examples come from early customers rather than neutral controlled studies, so we would give the cost measurements from Cognition more weight than the testimonials. Still, they describe exactly the workload pattern that benefits from cheap cache reads: many steps, large persistent context and repeated tool use.

If someone asks today where Fable 5.1’s pricing change is most likely to show up on the invoice, coding agents are the first place we would look.

Does Fable 5.1 save anything on short prompts and normal Claude chats?

Claude Fable 5.1 barely gets cheaper on short, independent prompts because there is little cached context to discount.

Take a fresh request containing 10,000 input tokens and producing 2,000 output tokens. The input costs about $0.10 and the output another $0.10.

That roughly $0.20 bill is essentially unchanged from Fable 5.

A second request can become cheaper if it reuses a large cached prefix, but a short conversation never develops the extreme token mix seen in coding agents such as Devin.

Output also matters disproportionately in ordinary chat. Fable charges fifty dollars per million output tokens, so a long response can easily cost more than all of the cached context feeding it.

This explains why a consumer can hear that Fable has become “25% cheaper” and see little practical difference in a normal session. The launch economics were built around persistent workloads rather than a sequence of isolated questions.

The same distinction applies to developers. If an application mostly sends new prompts, the Fable 5.1 migration offers very little direct saving.

Can developers miss most of Fable 5.1’s savings by caching badly?

Yes. A badly structured application can leave a large share of Fable 5.1’s new savings untouched because cheap cache reads only help when Claude actually finds reusable cached prefixes.

Prompt caching works best when stable material appears early and stays unchanged. System instructions, tool definitions, large reference documents and persistent conversation history are good examples.

Put frequently changing information near the beginning of that prefix and later requests can lose much of the reuse.

Cache lifetime matters as well. Developers can use shorter five-minute caching or pay more to write a one-hour cache. The longer option can make sense when expensive context will be revisited after gaps that would otherwise force another write.

There is also a simple trap: cache writes cost more than ordinary input. Fable 5.1 charges $12.50 per million tokens for a five-minute write and $20 for a one-hour write. Caching a huge block and reading it only once can therefore increase spending.

Cognition’s result shows what good architecture looks like at the other extreme. Its agent rereads a very large amount of context over many steps, allowing the cheaper read rate to compound throughout the task.

So the relevant engineering metric is how often each expensive cached block gets reused before it changes or expires. Teams that never measure that ratio may see much smaller savings than Anthropic’s headline suggests.

Do better Fable 5.1 results matter more than cheaper tokens?

For the hardest work, Claude Fable 5.1’s higher success rate can be worth much more than the reduction in token spending.

Consider the difference between saving $1 on an agent run and avoiding a failed run entirely.

Anthropic’s current benchmarks show some large improvements over Fable 5. Terminal-Bench-Science rose from 24.7% to 52.6%. AutomationBench increased from 17.1% to 31.4%. Terminal-Bench 4.0 moved from 42.0% to 55.8%.

Early customer tests also include unusually difficult cases. Millennium said Fable 5.1 traced a rare software crash to an external vendor library after engineers and other models had failed to identify the problem for four to five years. Browserbase measured a 25-point improvement over Fable 5 on its hardest browser-agent benchmark. Rogo reported matching Fable 5’s finance accuracy with fewer tokens.

The financial logic becomes straightforward when failure is expensive. A $3 run that succeeds can beat a $1 run that fails twice, requires escalation and eventually needs a human engineer.

That is why cost per million tokens is becoming a weaker metric for agents. Cost per accepted task tells us much more.

Fable 5.1’s cheaper cache helps that equation, but better task completion can move it by far more.

So, is Claude Fable 5.1 actually cheaper to use?

Yes, Claude Fable 5.1 is genuinely cheaper to use than Fable 5 for persistent, cache-heavy agents, but the broader claim that Fable itself has become cheap is exaggerated.

The clearest evidence comes from real agent economics. Anthropic’s production mix suggests savings around 25% for typical Fable workloads. Cognition’s heavily cached Devin benchmark went much further, cutting cost per coding task from $5.84 with Fable 5 to $2.68 with Fable 5.1.

We also have solid evidence in the other direction. As seen above, Artificial Analysis measured maximum-effort Fable 5.1 at roughly 20% more per task than Fable 5 because the new model generated far more expensive output tokens.

The apparent contradiction is the answer.

Fable 5.1 works best economically when three things happen together: most of the context is being reused, the model runs at a sensible effort level, and its stronger reasoning reduces the tokens, tool calls or failed attempts needed to finish the job.

Long-running coding agents can hit all three conditions. Short prompts usually hit none of them. Ordinary workloads that Sonnet 5 handles reliably will still be much cheaper on Sonnet, while Opus 5 remains cheaper whenever Fable’s cache and task-efficiency advantages are small.

So we would call Anthropic’s cheaper-Fable claim mostly true, with an important boundary around it. The company has made Fable-class intelligence dramatically more economical for the agent workloads that repeatedly consume huge contexts. It has barely changed the economics of a fresh prompt.

That difference is the whole story.