Fable 5.1 vs Fable 5: Is Fable 5.1 Cheaper Than Fable 5? We Measured 57 Runs

TL;DR:

• Fable 5.1 cut cache reads 75%, from $1.00 to $0.25 per million tokens. Input stayed at $10 and output stayed at $50, so nothing else on the rate card moved.
• Artificial Analysis measured cost per task rising 18%, from $3.14 to $3.69. Fable 5.1 spent 140M output tokens on their Intelligence Index against Fable 5's 83M.
• Across 57 API-billed runs costing $26.00, Fable 5.1 used more output tokens at every effort level. Ratios were 1.37x at low, 1.12x at high, and 1.30x at max.
• At max effort the extra tokens are reasoning, not text. Reasoning went 4,205 to 6,725 while visible output fell from 3,522 to 3,301, so Fable 5.1 wrote 6% less text for 30% more billed tokens.
• On six sandboxed agentic builds the discount showed up on the invoice. One Fable 5.1 build re-read 1.69M cached tokens for $0.42. A Fable 5 build re-read 1.34M and paid $1.34.
• The saving was 15% to 30% of the bill, not 25% to 45%, because cache writes cost $20 per million and are not discounted.
• The variable neither party measured is how tightly you specify the task. Tight spec, Opus 5 won on cost every time. Open brief, Opus 5 averaged $11.83 against Fable 5.1's $7.00.

Anthropic says Fable 5.1 is cheaper than Fable 5, by 25% and sometimes 45%. Artificial Analysis measured it costing 18% more. Both measured correctly.

Fable 5.1 shipped September 1, 2026, less than three months after Fable 5's June 9 release. It is a tuning pass over the same architecture, not a new model generation, which is why the context window, max output, and headline input and output prices are all unchanged.

The disagreement is not about arithmetic. Fable 5.1 vs Fable 5 depends on which kind of token dominates your bill, and the two of them looked at different workloads.

Three things moved between Fable 5 and Fable 5.1, and everything else on the spec sheet held. Cache reads got 75% cheaper, the reliable knowledge cutoff moved forward five months, and the model got measurably steadier on long, multi-step work. The window, the output ceiling, the effort dial, and the input and output prices all stayed put.

Read the "cache read" and "long-horizon" rows together and the shape of the update falls out. Anthropic sharpened Fable 5.1 for the exact workload where re-reading a large context many times drives the bill: long agent sessions. Everything you would notice on a one-shot prompt was left alone.

Fable 5.1 vs Fable 5 comes down to one row on the rate card.

• Fable 5.1 is cheaper than Fable 5 only for cache-heavy work, meaning long sessions that re-read the same context over and over. Its cache reads cost $0.25 per million tokens against Fable 5's $1.00, a 75% cut.

Everything else costs the same. Fable 5.1 also generates more output tokens for the same task, so cache-light work pays more per finished result, not less.

Both headline claims about Fable 5.1's cost, Anthropic's "25% cheaper" and Artificial Analysis' "18% more expensive", are accurate measurements of different things.

Both claims rest on the same rate card, and the rate card itself is not in dispute.

Anthropic bills in tokens: chunks of text worth roughly three quarters of a word each, counted for everything a model reads and writes. Four kinds get billed at four different prices, and only one of those prices changed.

Three of those four rows are identical between the two models. Every argument about Fable 5.1's cost is really an argument about how much of your bill sits in the bottom row.

Also read: what AI tokens are and how they get counted.

Every number in this post comes from 57 runs on a Claude Team API account, billed at $26.00. Prompts ran through claude -p --output-format json with web tools switched off, so no model could get ahead by looking things up. The agentic builds ran under sandbox-exec with writes confined to the build directory, at --effort high to override the effortLevel in settings.json.

Costs come from the usage fields the API returns, priced at each model's published rates. Per million tokens that is $10 for input_tokens, $20 for cache_creation_input_tokens, $0.25 for cache_read_input_tokens, and $50 for output_tokens. Comparing the last two in a single run tells you which side of this argument your own workload sits on.

Sources were gathered with Firecrawl's /search endpoint and /scrape, working from Anthropic's Fable and Mythos 5.1 announcement and Artificial Analysis' Fable 5.1 model page.

A model has no memory between turns. Everything it needs gets sent again every time: the system prompt, the files you opened, the whole conversation so far. Send a message twenty turns into a session and you pay to ship all of it a twenty-first time.

Prompt caching stores that text on Anthropic's side after the first send. Later turns point at the stored copy. They pay the cache-read rate instead of full input price.

The discount barely registers on a one-off prompt. It matters enormously to a coding agent that has been running for an hour.

Storing it in the first place is a separate charge, and that one was not discounted. Cache writes cost twice what input costs, which sets the ceiling on the saving.

The discount therefore scales with how many times a context gets re-read, not with how big the context is. Build a large cache and read it twice and almost none of it reaches you.

Artificial Analysis prices models by cost per completed task rather than per token. Fable 5.1 needed 140 million output tokens to finish their Intelligence Index, against 83 million for Fable 5. That is 69% more of the most expensive token type. Cost per task rose from $3.14 to $3.69, an 18% increase, and their evaluations use almost no caching.

Their own blended price confirms Anthropic's cut without saying so. Artificial Analysis lists Fable 5.1 at $7.17 per million against Fable 5's $7.70.

They assume a token mix of 7 parts cache read, 2 parts input, 1 part output. Work backwards from $7.17 with that mix and the cache read comes out at exactly $0.25. Two sources that never compared notes land on the same number.

The same mix explains why a 75% cut barely moves the headline number. Output makes up 65% of the blended price, so cutting the cache-read rate only pulls it down 7%.

One detail decides how much weight to give that 18%. Artificial Analysis measured it with both models at max effort, the most expensive setting either one offers.

Anthropic's own launch numbers point the same way on where the gains cluster. On long, tool-using benchmarks the jump is large; on well-scoped reasoning it is modest.

These are vendor-run figures with production safeguards on, so read them as direction rather than proof. Anthropic reports a ±3.5 to 4.5 point standard error on Terminal-Bench-Science, wide enough that any single row inside that band is a wash. The spread across rows is the real signal: Fable 5.1 more than doubles on scientific research and nearly doubles on automation, but moves only three points on a coding benchmark Fable 5 already handled. Independent corroboration comes from Artificial Analysis, whose Intelligence Index put Fable 5.1 at 66 on max effort, ahead of Opus 5 at 63 and Fable 5 at 62.

Effort levels are Claude's reasoning-budget dial, set with output_config: {effort: "low" | "medium" | "high" | "xhigh" | "max"}. Each step up buys accuracy and costs more. Artificial Analysis prices Fable 5.1 at $0.77 per task on low and $3.69 on max, a 4.8x range for eight points of Intelligence Index score. Most cost surprises come from an inherited default, not a model choice.

Defaults differ by product, which is the part worth checking before blaming the model.

Claude Code defaults to High. Claude Cowork and Claude.ai default to Medium. Anthropic's savings figures were measured at default effort, while Artificial Analysis measured at max, so the two headline numbers are not measuring the same thing.

Effort is not a quality slider. It is a budget for how much the model thinks before it answers, and that thinking arrives on your bill as output.

Reasoning tokens are the model's internal thinking, billed at the same $50 per million as visible text. They never appear in the response you read. On Fable 5.1 thinking is permanently enabled, the thinking parameter should be omitted, and budget_tokens is rejected with a 400 error. Effort level is the only control over how much the model thinks.

You cannot prompt your way out of a reasoning bill. Skills and a trimmed global CLAUDE.md cut visible output. Neither one changes how much the model thinks.

Fable 5.1 also tightened a few developer-facing API surfaces around this. Forced tool use behaves differently, thinking is permanently enabled and cannot be toggled, and budget_tokens now returns a 400 error instead of silently clamping. If you call the API directly, Anthropic's migration notes are worth a scan; if you build through Claude Code or a hosted product, the harness handles the changes.

Our own Claude Code token efficiency testing covers the levers that do work on visible output.

Two things show up in user reports that neither the rate card nor the benchmarks fully capture, and both matter more than a single-digit score change.

• Clarity. Readers describe Fable 5.1 as explaining itself in plainer language and grasping tangled topics with less hand-waving. The step up from Fable 5 is real, and the gap over Opus 5 is wider still.
• Follow-through. Power users are running Fable 5.1 through very long agent sessions, some past ten hours, on things like writing solvers or refactoring a codebase across a whole day, and the model holds the plot further into the session than Fable 5 did. That matches Anthropic's own agentic benchmarks, where the widest gains sit on the tasks that punish drift the hardest.

Yes, at every effort level we tested, though by less than Artificial Analysis reported. Three prompts ran through claude -p with tools disabled. Fable 5.1's suite totals came in at 1.37x at low effort, 1.12x at high, and 1.30x at max. The trend is not monotonic, so it does not simply rise with effort.

The composition of those tokens is the more useful finding.

At low and high effort, reasoning is a rounding error and the gap is genuine visible verbosity. At max effort the picture inverts.

Fable 5.1 produced 6% less visible text than Fable 5 for 30% more billed tokens. Code generation at max effort is the clearest single cell. Fable 5.1 burned 2.4x the reasoning tokens and wrote a shorter file: 3,977 characters across 127 lines, against Fable 5's 4,585 across 138.

"Very verbose" counts the right thing and gives it the wrong name. That name sends developers off writing prompts that ask for shorter answers, when effort level is the only control that works.

Note: thinking_tokens reads 0 for Fable 5.1 at low and high effort despite reasoning being always on, so only the max-effort split is trustworthy. Cost figures use output_tokens, which is what gets billed.

Trust which way these ratios point rather than how big they are. We ran the same three prompts twice, changed nothing, and got 1.10x then 1.37x. Running one cell three times gave 3,980 tokens, then 3,900, then 2,744, a 45% spread for the same prompt on the same model. Run-to-run variance here is as wide as the difference being measured.

Between 15% and 30% of the bill, well short of the 25% to 45% headline. Six sandboxed builds with tools enabled produced the only workload here that reaches the shape Anthropic's cut targets. One Fable 5.1 build re-read 1.69 million cached tokens and paid $0.42 for them. A Fable 5 build re-read fewer, 1.34 million, and paid $1.34.

Every build passed all seven of our independent tests, including a daylight-saving case that a fixed-offset implementation fails. Correctness did not separate these models.

Add those parts up and they match the totals the API reported, to the cent on both Fable 5 runs. This saving is not something we inferred. It is the model's own token counts, multiplied by its own prices.

Output tokens were still the biggest single line on every build, between $2.17 and $3.99. On three of the four Fable builds, the undiscounted cache writes cost more than the cache reads did.

Neither source measured the thing that decides it: how tightly you specify the task. Your bill is the tokens you use times the price per token. A tight spec keeps the token counts close, so price decides and Opus 5 wins. An open brief lets the token count decide, so the model that stops earliest wins.

A calculator built for the video flips the answer in one click. On short prompts, 94% of the billed tokens are re-read context. Opus 5 comes out cheapest there, at $3.10 against Fable 5.1's $5.67.

Switch the workload to an agentic loop and 98% of the billed tokens are re-read context. The verdict flips on the same page.

The calculator is live at fable-5-news.pages.dev/pricing. Set verbosity to 1.0x and it reproduces Artificial Analysis' published prices exactly, $7.70 down to $7.17.

Our own numbers land on both sides of that split. On tightly specified prompts, Fable 5.1 cost 1.75x to 2.75x Opus 5, and was never cheaper at any effort level. The open-ended half of the build brief went the other way. Opus 5 read six times more cached context and ran to 1.7x Fable 5.1's cost.

Fable 5.1 built the best of the three interfaces on that open brief. Doing more than the task asks for wastes money when the spec is tight. It buys you something when the brief is vague.

No. Fable 5.1 was slower than Opus 5 on the same three prompts at every effort level. It took 1.36x longer at low, 1.04x at high, and 1.61x longer at max. Throughput was comparable to slightly behind, at 0.88x, 0.77x, and 1.01x of Opus 5's output tokens per second. The circulating claim that Fable 5.1 runs roughly 2x faster than Opus 5 is close to inverted.

At max effort Fable 5.1 generated 4.6x Opus 5's reasoning tokens, which is where the wall clock goes.

Fast mode, which raises output speed up to 2.5x, exists for Opus 5 and Opus 4.8 and not for Fable. The model that can be made dramatically faster is Opus, the reverse of the claim.

Note: quote these as ratios, not absolutes. We measured Opus 5 at high effort at 92.5 output tokens per second. Artificial Analysis publishes 47 for the same configuration, so throughput is harness-dependent.

Use Opus 5 when the work has a clear finish line. On every tightly specified prompt we ran, Opus 5 was cheaper and never slower. Use Fable 5.1 for open-ended exploration, deep research, or long agent loops that re-read a large context many times. If cost matters more than peak scores, drop the effort level before switching models.

Anthropic's own guidance lines up with what we saw: start with Opus 5 as the default and only reach for a Fable model when a cheaper one keeps stalling on the hardest steps.

The effort dial is usually the bigger lever. Fable 5.1 at medium outperformed Fable 5 at max on Anthropic's own comparison, so there is rarely a reason to run above high.

Running a different model entirely is also an option. A local proxy lets you use GPT, Gemini, or Grok models in Claude Code. Kimi K3 is an open-weight alternative worth pricing against these three. For a harness comparison rather than a model one, Claude Code versus Codex covers the tradeoffs, and our roundup of the best AI coding agents situates all three against the wider field.

Also read: How Claude Code spends tokens on web research.

Both headline numbers in the Fable 5.1 vs Fable 5 debate are real, and both are close to useless on their own. The thing that decides your bill is how tightly you specify the work, and neither Anthropic nor Artificial Analysis measured that.

Check out the Firecrawl docs to go deeper.