Our own measurements · run Sep 2, 2026

We benchmarked Fable 5.1 ourselves

Every number on this page came out of our own terminal. Nothing here is copied from a third-party leaderboard. We ran the same prompts through Claude Fable 5, Claude Fable 5.1 and Claude Opus 5 at three effort levels, recorded what the API reported, and paid the bill. The method is written out in full below so you can disagree with it, or run it yourself.

The short version. Fable 5.1 costs less per token than Fable 5, because cache reads dropped 75%. It costs more per finished task than either Fable 5 or Opus 5, because it generates more tokens to get there - and at high effort those extra tokens are mostly reasoning, not text. It is also not faster than Opus 5: at max effort it took 1.6× as long to finish the same three tasks, for 2.75× the money.

How we ran the tests

Everything went through Claude Code's headless mode, which reports token usage and cost per call as JSON:

claude -p "<prompt>" --model <model> --effort <low|high|max> --output-format json

Models. claude-fable-5, claude-fable-5-1 and claude-opus-5, on the same account, same machine, same session conditions.
Effort pinned explicitly. Every run passes --effort. This matters: our first attempt inherited a global "effortLevel": "low" from settings.json without us noticing, which invalidated the labels on an earlier version of this page. Never trust the default.
Three prompts, chosen to span task types rather than to flatter anyone: a light reasoning problem (count the domino tilings of a 2×10 rectangle), a code-generation task (a self-contained HTML file with an SVG bar chart), and a plain-English explanation (what prompt caching is and why it saves money). A fourth, harder prompt - deriving a closed form for a central-binomial series - is used in a separate repeated test.
Tools disabled. Each prompt ends "Do not use any tools", so every run is pure generation. No tool loops, no file reads, no web calls muddying the token counts.
What we count. usage.output_tokens from the API response, which is everything the model generates: the visible answer plus its reasoning tokens. Both bill at $50 per million on Fable. Where the API reports thinking_tokens we split the two apart. Input and cache tokens are excluded from the token figures but included in the cost figures.
Speed is duration_api_ms, wall clock for the request, and throughput is output tokens divided by that. Time spent reasoning counts, because you wait for it.
Cost is total_cost_usd as reported per call, on an API-billed account. Note this includes Claude Code's own system-prompt cache write of roughly $0.25-0.35 per fresh session, which is overhead of the harness rather than of the task.
One run per cell for the three-prompt suite below. That is not enough to be a benchmark, and we say so plainly in the reliability section - it is the first thing you should hold against these numbers.

Where the tokens actually go

Output tokens for the whole three-task suite, split into visible text and reasoning. This is the finding that reframes everything else.

visible text reasoning

At low and high effort, reasoning is a rounding error and the difference between models is real visible verbosity. At max effort the picture inverts: reasoning becomes the majority of Fable 5.1's output, and its visible text is actually shorter than Fable 5's. "More verbose" is the wrong mental model - it thinks more, and thinking is billed as output.

Model	Effort	Output tokens	Reasoning	Visible	Reasoning share
Fable 5	low	2,771	34	2,737	1%
Fable 5.1	low	3,809	90	3,719	2%
Opus 5	low	3,176	58	3,118	2%
Fable 5	high	3,444	190	3,254	6%
Fable 5.1	high	3,869	182	3,687	5%
Opus 5	high	4,819	277	4,542	6%
Fable 5	max	7,727	4,205	3,522	54%
Fable 5.1	max	10,026	6,725	3,301	67%
Opus 5	max	6,201	1,453	4,748	23%

One run per cell, three prompts summed. Cells where the API reported thinking_tokens: 0 for Fable 5.1 at low and high effort are suspicious, since 5.1 has reasoning permanently enabled - we treat the max-effort rows as the trustworthy ones and flag the rest.

Speed: is 5.1 faster than Opus 5?

No. Not on either measure, at any effort level we tested. The claim circulating that 5.1 is roughly twice as fast as Opus 5 is, on our numbers, close to exactly backwards.

Fable 5 Fable 5.1 Opus 5

Left: seconds to complete all three tasks. Right: output tokens per second. Throughput is roughly comparable across all three models - within about 20% - but wall clock is not, because Fable 5.1 spends far longer reasoning before and between its answers.

Effort	5.1 wall clock vs Opus 5	5.1 throughput vs Opus 5	5.1 cost vs Opus 5	5.1 reasoning vs Opus 5
low	1.36×	0.88×	2.05×	1.6×
high	1.04×	0.77×	1.75×	0.7×
max	1.61×	1.01×	2.75×	4.6×

Above 1.00× means Fable 5.1 is slower, dearer, or more reasoning-heavy than Opus 5. The one place they are close is wall clock at high effort. At max effort 5.1 took 1.6× as long and cost 2.75× as much, and generated over four times the reasoning tokens.

Pricing: per token versus per task

This is the whole story in one line, and it applies to both cost and speed: Fable 5.1 is cheaper per token and competitive per token of throughput. It is more expensive per task and slower per task. The difference is reasoning.

Model	Effort	Wall clock	Tokens/sec	Measured cost
Fable 5	low	43s	64	$0.95
Fable 5.1	low	58s	66	$0.98
Opus 5	low	42s	75	$0.48
Fable 5	high	51s	68	$0.98
Fable 5.1	high	65s	59	$0.91
Opus 5	high	63s	77	$0.52
Fable 5	max	106s	73	$1.19
Fable 5.1	max	122s	82	$1.22
Opus 5	max	76s	82	$0.44

Cost is what the API actually billed for the three-prompt suite, including Claude Code's per-session cache-write overhead. Opus 5 lists at $5/$25 per million input/output against Fable's $10/$50, and the measured bills line up with that: Opus 5 came in at roughly half to a third of Fable 5.1 for the same work.

Where Fable 5.1's price cut is real. Anthropic cut cache reads 75%, from $1.00 to $0.25 per million tokens, leaving input and output unchanged at $10 and $50. That is a genuine saving and it lands hardest on cache-heavy agentic work, where re-read context dominates the bill. It does not help the runs on this page, which are single-shot generations with almost nothing to cache - which is exactly why our measured costs went the other way. Use the cost calculator to see which side of that line your own workload falls on.

Quality: does the extra spend buy better output?

We took the six HTML charts produced by the code-generation prompt, stripped every trace of which model wrote which, shuffled them, and had Grok grade them blind on a five-part rubric out of 50.

Blind grades. All three Fable 5 submissions outscored all three Fable 5.1 submissions - perfect separation, means 45.7 against 41.3. The deductions were specific rather than impressionistic: 5.1's max-effort file was the only one missing a y-axis spine, and its low-effort file shipped an unrequested dark mode, an unused CSS rule, and a document title that contradicted the chart heading. Where 5.1 lost most ground was the over-engineering criterion.

Caveats: one grader, one run per cell, and a five-bar SVG chart is not representative of real engineering work. "Over-engineering" is precisely the axis where a judge's own taste does the most work.

Second task type: a plain-English explanation

To check whether that result was an artefact of one toy task, we graded a second, completely different output type - the nine answers to "explain what prompt caching is, in plain English for a working developer" - on a rubric built for prose rather than code: technical accuracy, clarity to a developer, conciseness, and scope discipline. Nine answers, three models, three effort levels, blind and reshuffled.

Fable 5 Fable 5.1 Opus 5

Out of 40. The model ordering replicates: Fable 5 mean 35.0, Fable 5.1 32.7, Opus 5 27.7. Two different task types, two different rubrics, same ranking - which is more than we expected, and the strongest quality signal here.

The twist: Opus 5 came last, and lost on scope. Opus 5 scored 5-7 on conciseness and 5-6 on scope discipline against Fable's 8-9 on both, producing the two longest answers in the set (5,465 and 4,831 characters against Fable 5's 2,588). That is the same over-exploration that made Opus 5 the expensive option on the open-ended design brief below - and it shows up here as padding in prose. The trait travels across task types.

Effort again bought nothing: means by effort were low 32.3, high 31.0, max 32.0. Across both grading passes and both rubrics, higher effort never produced better-judged output. Still one grader on both passes - a second judge failed on a configuration error - so the ranking is replicated across tasks but not across graders.

Third task type: an open-ended brief, and the gap collapses

Both tests above share two features that work against Fable 5.1: the task has a clear finish line, and the rubric contains an over-engineering criterion, which makes doing more than asked a defect by definition. So we ran a third pass designed to remove both. An open brief with no required structure ("present this data as compellingly as you can, make your own choices"), n=2 per model, graded on information design, editorial judgment, visual craft, restraint and would-ship. No scope-compliance criterion at all.

Grading pass	Task shape	Fable 5	Fable 5.1	Opus 5	Gap
Code chart (/50)	tight spec	45.7	41.3	n/a	4.4
Code chart, scope criterion removed (/40)	tight spec	36.7	34.7	n/a	2.0
Explanation (/40)	tight spec	35.0	32.7	27.7	2.3
Open brief (/50)	open	38.0	36.0	35.5	2.0

Two corrections to the result above, both pointing the same way. First, roughly half the original 4.4-point gap was the over-engineering criterion alone: re-scoring the same six chart files without it narrows Fable 5 vs Fable 5.1 to 36.7 against 34.7. Second, on the open brief the three models land within 2.5 points of each other while the within-model spread across two runs is 8 to 9 points (Fable 5 scored 34 and 42; Fable 5.1 scored 33 and 39; Opus 5 scored 31 and 40). When run-to-run variance is four times the between-model difference, the correct conclusion is that these models are not distinguishable on quality by this method, not that one of them is worse.

What the earlier passes actually measured, then, is narrower than it first looked: on tasks with a clear finish line and a rubric that rewards staying inside it, Fable 5.1's extra exploration is scored as a defect. Change either condition and the effect largely disappears. The grader's own summary of the open-brief winner is the useful line: it won because it "foregrounds those comparisons and then stops". Restraint was what scored, not effort or spend, and no model had a monopoly on it. An agentic version of this test, where models can iterate on real files rather than emit one shot, is running now and will be added here.

The axis these prompts miss: how tightly the task is specified

Every prompt above has a clear finish line - count the tilings, draw five bars, explain a concept. That is exactly the regime where a lower per-token rate wins, which is why Opus 5 looks cheap on this page. Our earlier hands-on eval tested the opposite case, and the answer flips.

Cell	Total cost	Blended rate	Objective check	Blind taste
Hard task · Fable 5 high	$1.04	$2.97/M	pass	n/a
Hard task · Fable 5 low	$1.33	$3.26/M	pass	n/a
Hard task · Opus 4.8 high	$0.75	$2.02/M	pass	n/a
Hard task · Opus 5 high	$0.79	$1.66/M	pass	n/a
Design task · Fable 5 high	$1.60	$3.31/M	pass	4.5
Design task · Fable 5 low	$1.12	$3.19/M	pass	4.5
Design task · Opus 4.8 high	$1.96	$1.78/M	pass	4.0
Design task · Opus 5 high	$5.78	$0.73/M	pass	3.5

Two tasks: a narrow algorithmic problem graded by an independent numerical checker, and an open-ended visual-design brief graded by acceptance checks plus a blind taste judge. n=1 per cell. Note this eval predates Fable 5.1 - "Fable" here is Fable 5.

Cost is volume × rate, and on an open brief volume wins. Fable's per-token rate is the highest measured anywhere here ($2.97-3.31/M against Opus's $0.73-2.02/M) and it never improves. But on the narrow task Opus 4.8's exploration stayed close to Fable's (372k tokens against 349k), so its rate advantage held and it came out cheapest. On the open-ended design brief Opus 4.8 explored 2.3× more (1.10M against 482k) and that volume erased the rate advantage - Fable-high was cheaper in dollars. Opus 5 pushes it to an extreme: 7.95M tokens, 16× Fable-high, for $5.78 - the priciest cell measured, despite carrying the lowest per-token rate on the page. Two Opus generations point the same way, which makes this the best-supported result in Fable's favour.

And the taste scores run opposite to spend. The blind judge put Fable-high and Fable-low tied at 4.5, ahead of Opus 4.8-high at 4.0 and Opus 5-high at 3.5. Across all four design cells the taste ordering is the exact inverse of cost, and Opus 5 sits last on both. More spend and more exploration bought worse design judgment, not better. Read alongside the chart-grading result above, the pattern is consistent: the trait that reads as wasteful over-engineering on a tightly specified task reads as good judgment on an open one - and it is the same trait.

So the useful answer to "which model should I use" is not a model name, it is a question: how tightly is the work specified? Tight spec, clear finish line - the per-token rate decides, and Opus wins. Vague brief, no obvious stopping point - the volume decides, and the model that knows when to stop wins. The cost calculator now has that dial on it. The obvious gap: Fable 5.1 was not in this eval, so the open-ended half has not been re-run against it. That test is next.

Where the money actually goes, and the cache cut finally showing up

Every test above this point is single-shot: one request, nothing to reuse, no caching to speak of. That is the wrong shape of workload to see Anthropic's price cut, which is why measured costs kept moving against Fable 5.1. So we ran the same brief again as a real agentic build - tools on, multiple files, iterating in a sandboxed directory - and broke the bill into its parts.

cache reads cache writes fresh input output

Cost of each agentic build, split by token type, priced at each model's own published rates. The components reconcile with the totals the API reported, to the cent on the Fable 5 runs.

Build	Turns	Output tokens	Cached tokens re-read	Minutes	Cost	Our tests
Fable 5 r1	24	43,311	1,344,512	11	$4.93	7/7
Fable 5 r2	40	74,587	2,922,893	21	$8.84	7/7
Fable 5.1 r1	21	78,352	1,694,554	16	$6.64	7/7
Fable 5.1 r2	43	79,783	2,508,627	19	$7.35	7/7
Opus 5 r1	111	175,960	18,919,435	45	$15.72	7/7
Opus 5 r2	59	130,449	6,873,477	31	$7.94	7/7
Fable 5, mean of 2	32	58,949	2,133,702	16	$6.88	7/7
Fable 5.1, mean of 2	32	79,068	2,101,590	18	$7.00	7/7
Opus 5, mean of 2	85	153,205	12,896,456	38	$11.83	7/7

Six builds, n=2 per model (two runs each from the identical brief), high effort, sandboxed with filesystem writes confined to the build directory and web tools disabled. Every build passed all seven of our independent tests, including the daylight-saving discriminator a fixed-offset implementation fails. The models are separated here by cost and craft, not correctness.

On real agentic work, the two Fable models cost the same. Means over two runs each: Fable 5 took 32 turns, re-read 2.13M cached tokens, cost $6.88. Fable 5.1 took 32 turns, re-read 2.10M, cost $7.00. A 2% difference against a 2x spread between runs of the same model, so the honest statement is that they are indistinguishable. Fable 5.1's cheaper cache reads and its extra reasoning cancel almost exactly. Every other test on this page measured one side of that trade in isolation; this is the first where both act at once.

The clearest evidence for Anthropic's price claim, and its limit. Fable 5.1 r1 re-read more context than Fable 5 r1 (1.69M tokens against 1.34M) and paid $0.42 against $1.34. That is the 75% cut, visible on the invoice, and it only appears in a workload with something to re-read. But cache writes are not discounted ($20 per million on Fable) and ran $1.42 to $2.66 per build, while output was the largest line item on every build. Net saving here: 16 to 20% of the bill, not the 25 to 45% headline.

And Opus 5, the cheapest model per token, was the most expensive to finish the job. It averaged 85 turns against Fable's 32, re-read 12.9M cached tokens against 2.1M, and cost $11.83 against $6.88 and $7.00, roughly 1.7x dearer at half the per-token rate. One run reached 111 turns, 18.9M cache reads and $15.72. It shipped 14 files where Fable 5 shipped 5, and left a .build directory of intermediate scratch behind. An earlier hands-on eval found the same behaviour on an open-ended design brief; the surprise is that it reproduced here on a tightly specified brief with hard acceptance criteria. Over-exploration does not need a vague prompt to trigger it.

Read the variance before the means. Opus 5's two runs cost $15.72 and $7.94. Fable 5's cost $4.93 and $8.84. Identical briefs, same effort, same harness. Treat "85 turns" as "high and wildly variable" rather than a figure, and treat any gap smaller than about 30% as unresolvable at this sample size.

How much to trust any of this

Less than you might like, and here is the specific reason. We ran the identical three-prompt suite twice under identical settings. The first run put Fable 5.1 at 1.10× Fable 5's output tokens; the repeat put it at 1.37×. One individual task swung from 0.90× to 1.62× between runs. Run-to-run variance on a single generation is as large as the effect we are trying to measure, which means every single-run figure on this page should be read as one sample, not a measurement. A repeated test - harder prompt, three runs per cell, low and max effort - is running as this page goes up, and the numbers here will be revised when it lands. We would rather publish that sentence than a tidy number we cannot reproduce.

Raw data

Every prompt, every raw JSON response, the runner scripts and the blind-grading key are kept alongside this page's source rather than summarised away. If a number here looks wrong, the response that produced it is on disk.

Unofficial demo page. Not affiliated with Anthropic. All figures measured locally on Sep 2, 2026 via claude -p on an API-billed account; prices from Anthropic's announcement. Status · Cost calculator · Saving money.