TL;DR.
Anthropic shipped Claude Fable 5.2 and Mythos 5.2 on November 9 at $8 per million input tokens and $40 per million output, 20% below Fable 5.1. Cache reads dropped the same 20%, to $0.20. There's also a new fast mode: up to 2.5x faster output, at twice the price.
The 20% is real and it applies with no code change beyond a model ID. It's also the smallest lever on the bill. Here's what moves a Fable 5.2 bill more, worked through on one illustrative agent task.
- The cut is 20% on every token type. The same task that cost $2.30 on Fable 5.1 costs $1.84 on Fable 5.2, if it uses the same tokens.
- Effort moves the bill 5.4x. On the same task, low effort costs $1.24 and max costs $6.64, under our assumption that effort scales output tokens 0.5x to 5x. Artificial Analysis puts Fable 5.2 at max effort at $26.54 per Intelligence Index task, against $6.24 for GPT-6 Astra at max.
- Fable 5.2 cache reads cost the same as Opus 5.5's, $0.20 per million. The premium over Opus is in cache writes and output, which is why effort matters so much.
- Fast mode pays only when a person waits. At the full 2.5x speedup, it's worth the extra $1.84 per task only if someone spends more than 38% of the generation time waiting on it, at a $100/hour engineer. At 1.5x, more than 68%.
- Routing by task beats the price cut three times over. Sending half of tasks to Sonnet 5.5 and 30% to Opus 5.5, with Fable 5.2 at high effort on the hardest fifth, costs $1.13 per task against $2.80 for all-Fable at high, 60% less.
Below: the rate card, three charts, a rollout checklist, and effortbill.py, 60 lines that price your own tasks by model, effort and mode.
Prices are Anthropic's list prices as of November 10, 2026. Benchmark figures are as published by Anthropic and Artificial Analysis. Everything labeled "our model" uses one illustrative task (1.2 million cache-read tokens, 40,000 cache-write tokens and 30,000 output tokens at medium effort) and assumed effort multipliers. No figure here comes from Nadir customer data.
The new rate card.
| Per million tokens | Fable 5.1 | Fable 5.2 | Fable 5.2 fast | Opus 5.5 | Sonnet 5.5 |
|---|---|---|---|---|---|
| Input | $10.00 | $8.00 | $16.00 | $4.00 | $2.00 |
| 5-minute cache write | $12.50 | $10.00 | $20.00 | $5.00 | $2.50 |
| 1-hour cache write | $20.00 | $16.00 | $32.00 | $8.00 | $4.00 |
| Cache read | $0.25 | $0.20 | $0.40 | $0.20 | $0.10 |
| Output | $50.00 | $40.00 | $80.00 | $20.00 | $10.00 |
| Batch input / output | $5 / $25 | $4 / $20 | not offered | $2 / $10 | $1 / $5 |
Three details in that table matter for planning:
- Cache reads on Fable are 0.025x input. Most Claude models bill a cache hit at 0.1x input, and Opus 5.5 and Sonnet 5.5 at 0.05x. On Fable 5.2 it's 0.025x, which lands at exactly Opus 5.5's $0.20. For a read-heavy agent session, the step up from Opus to Fable is much smaller than the 2x sticker suggests.
- Fast mode doubles everything, cache included. Anthropic's docs say caching multipliers apply on top of fast-mode pricing, so a fast cache read is $0.40. Fast mode isn't available on the Batch API.
- The 1M context window has no long-context surcharge on Fable 5.2. A 900K-token request pays the same per-token rate as a 9K one. That's a cost trap we covered with Haiku 5.5's 100K cliff; Fable doesn't have one.
The cut is the small number.
On our illustrative task, the price cut saves $0.46. Dropping from medium to low effort saves $0.60. Going from medium to max adds $4.80. Turning on fast mode adds $1.84.
Effort controls how many tokens the model spends thinking and writing, and output is the most expensive token type at $40 per million. Anthropic offers five levels on Fable 5.2: low, medium, high, xhigh and max. Medium is the default in Claude apps and Claude Code, and Anthropic says Fable 5.2 at medium "can accomplish challenging tasks with fewer tokens than Fable 5.1."
The independent numbers point the same way. Artificial Analysis lists Fable 5.2 at max effort at 65 on its Intelligence Index, using 275 million output tokens to run the index and an estimated $26.54 per task. GPT-6 Astra at max scores 57 at $6.24 per task. Fable scores higher, and at max effort it costs about 4.3x more per task. Neither number says what medium effort costs, and that's the setting most traffic should run at.
Anthropic's own comparison is the more useful one for budgeting: Fable 5.2 at high effort scores 45.3% on FrontierCode 2.0 against 45.5% for Opus 5.5 at its best, at "roughly half the cost per task." A model with twice the per-token price can be cheaper per task when it needs fewer tokens to finish. Price per token doesn't tell you price per task, a point we made in Same Sticker, Different Bill and why token price cuts don't lower agent cost per task.
Where the Fable premium lives.
On a typical agent task, 95% or more of tokens are cache reads. On Fable 5.2 those reads are only 13% of the bill in our model. Output is 65% and cache writes 22%.
So two things decide what Fable 5.2 costs you, and neither is the rate card:
- How much it writes. That's the effort setting, plus whatever your harness asks for. Diff-style edits instead of full-file rewrites, and stopping rules that end a task when it's done, cut output directly. We covered both in Patch or Pay and the overthinking ratio.
- How often the cache is rebuilt. Every write is $10 per million on Fable 5.2, 40x the read price. Long idle gaps, tool lists that change order, and switching models mid-session each force a rewrite. Switching from Fable 5.1 to 5.2 is itself one full cache rebuild per live session, since caches don't carry across models.
Fast mode: a price for a person's time.
Fast mode doubles the rate to make output up to 2.5x faster. At Artificial Analysis's measured 102 output tokens per second, our 30,000-token task takes about 294 seconds to generate. At the full 2.5x, fast mode saves 176 seconds and costs $1.84 more.
That trade is good only when someone is actually waiting. At $100 an hour, 176 seconds of an engineer's time is worth $4.90, so fast mode breaks even if they spend 38% of the generation time blocked on it. If the real speedup is 1.5x, the break-even rises to 68%. For a CI job, a nightly review or any background agent, nobody is waiting and fast mode is pure cost.
That gives a simple rule: fast mode on interactive sessions where a person is watching, standard everywhere else, batch for anything that can wait an hour. It's the same per-request tier decision we laid out for OpenAI's Ultrafast tier and the fast/flex/batch ladder.
Routing beats the discount.
The biggest saving is not running Fable 5.2 on work that doesn't need it. Anthropic's own table shows Opus 5.5 within a few points of Fable 5.2 on some benchmarks, and plenty of agent tasks (renames, test fixes, small edits, ticket triage) don't need either.
| Policy, per task | Model and effort | Cost |
|---|---|---|
| All Fable 5.1, high (last week) | Fable 5.1 high | $3.50 |
| All Fable 5.2, high (just the upgrade) | Fable 5.2 high | $2.80 |
| Routed by task | 50% Sonnet 5.5 medium, 30% Opus 5.5 medium, 20% Fable 5.2 high | $1.13 |
In our model, the upgrade alone takes $3.50 to $2.80. Routing on top takes it to $1.13. The split is an assumption, and the quality of each model on your tasks is the thing to test, not assume. Route per task or per session rather than per turn: switching models mid-session throws away the prompt cache, which we priced in the switch penalty.
Tutorial: effortbill.py.
effortbill.py prices one agent task by model, effort and mode, finds the fast-mode break-even, and compares a flat policy to a routed one. Replace the token counts with averages from your own logs. The Anthropic API reports them per response as usage.cache_read_input_tokens, usage.cache_creation_input_tokens and usage.output_tokens.
"""effortbill.py: what one agent task costs on Claude Fable 5.2, by effort, mode and model.
The 5.2 price cut moves every Fable rate by 20%. Effort, fast mode and model
choice move the per-task bill by more. Token counts are assumptions: replace
them with averages from your own logs (usage.cache_read_input_tokens, etc.).
"""
# $ per million tokens, list price, November 2026: cache read, 5m cache write, output
RATES = {
"Fable 5.1": (0.25, 12.50, 50.0),
"Fable 5.2": (0.20, 10.00, 40.0),
"Opus 5.5": (0.20, 5.00, 20.0),
"Sonnet 5.5": (0.10, 2.50, 10.0),
}
FAST = 2.0 # fast mode multiplies every rate, caching multipliers stack on top
READS, WRITES, OUT = 1.2e6, 40e3, 30e3 # one agent task at medium effort (assumed)
EFFORT = {"low": 0.5, "medium": 1.0, "high": 1.8, "xhigh": 3.0, "max": 5.0} # output scale (assumed)
TOK_PER_S, SPEEDUP = 102, 2.5 # standard output speed; fast mode is "up to 2.5x"
ENGINEER_PER_HR = 100.0 # loaded cost of the person waiting
def task_cost(model, effort="medium", fast=False, out_scale=1.0):
read, write, out = RATES[model]
m = FAST if fast else 1.0
o = OUT * EFFORT[effort] * out_scale
return m * (READS * read + WRITES * write + o * out) / 1e6
def fast_breakeven(effort="medium", speedup=SPEEDUP):
"""Share of generation time a person must spend waiting for fast mode to pay."""
gen_s = OUT * EFFORT[effort] / TOK_PER_S
saved_s = gen_s * (1 - 1 / speedup)
extra = task_cost("Fable 5.2", effort, fast=True) - task_cost("Fable 5.2", effort)
return extra / (saved_s * ENGINEER_PER_HR / 3600), saved_s, extra
def report():
old, new = task_cost("Fable 5.1"), task_cost("Fable 5.2")
print(f"price cut, same tokens: Fable 5.1 ${old:.2f} -> Fable 5.2 ${new:.2f} ({new / old - 1:+.0%})")
print("effort dial, Fable 5.2:")
for e in EFFORT:
print(f" {e:<7} ${task_cost('Fable 5.2', e):>5.2f} fast ${task_cost('Fable 5.2', e, fast=True):>5.2f}")
lo, hi = task_cost("Fable 5.2", "low"), task_cost("Fable 5.2", "max")
print(f" low to max spread: {hi / lo:.1f}x")
r, w, o = RATES["Fable 5.2"]
parts = (READS * r, WRITES * w, OUT * o)
print("medium bill split: " + " ".join(f"{n} {p / sum(parts):.0%}"
for n, p in zip(("reads", "writes", "output"), parts)))
for s in (1.5, SPEEDUP):
be, saved, extra = fast_breakeven(speedup=s)
print(f"fast mode at {s}x: saves {saved:.0f}s, costs ${extra:.2f} more, "
f"pays if someone waits >{be:.0%} of it")
mix = [("Sonnet 5.5", "medium", .5), ("Opus 5.5", "medium", .3), ("Fable 5.2", "high", .2)]
routed = sum(share * task_cost(m, e) for m, e, share in mix)
flat = task_cost("Fable 5.2", "high")
print(f"per-task routing: all Fable 5.2 high ${flat:.2f} routed ${routed:.2f} "
f"({routed / flat - 1:+.0%}) vs all Fable 5.1 high ${task_cost('Fable 5.1', 'high'):.2f}")
if __name__ == "__main__":
report()With the defaults it prints:
$ python effortbill.py
price cut, same tokens: Fable 5.1 $2.30 -> Fable 5.2 $1.84 (-20%)
effort dial, Fable 5.2:
low $ 1.24 fast $ 2.48
medium $ 1.84 fast $ 3.68
high $ 2.80 fast $ 5.60
xhigh $ 4.24 fast $ 8.48
max $ 6.64 fast $13.28
low to max spread: 5.4x
medium bill split: reads 13% writes 22% output 65%
fast mode at 1.5x: saves 98s, costs $1.84 more, pays if someone waits >68% of it
fast mode at 2.5x: saves 176s, costs $1.84 more, pays if someone waits >38% of it
per-task routing: all Fable 5.2 high $2.80 routed $1.13 (-60%) vs all Fable 5.1 high $3.50The out_scale argument is there for token efficiency. Anthropic says Fable 5.2 finishes hard tasks with fewer tokens than 5.1, and if your logs show 5.2 writing 30% less on the same work, pass out_scale=0.7 and the saving from the upgrade grows past 20%. We left it at 1.0 because we haven't measured it, and you shouldn't assume it either.
What the model leaves out, on purpose:
- Quality. It prices tasks, not outcomes. A cheaper task that fails and gets retried isn't cheaper.
- Turn count. Higher effort can also change how many turns a task takes, which changes cache reads. Measure it.
- Fallbacks. Anthropic says some blocked cyber, biology and AI R&D queries on Fable 5.2 fall back to Opus models. Those requests bill at a different rate.
Rolling it out.
- Update your price tables before you switch. Any cost dashboard with Fable 5.1 rates hardcoded will overstate the new model's cost by 25%. We wrote about that trap when a cancelled price change broke the same tables.
- Pin `claude-fable-5-2` explicitly. Don't rely on an alias moving under you mid-sprint.
- Shadow it on a slice of traffic. Compare tokens per task, cost per resolved task and pass rate against 5.1 on the same work. Our canary rollout guide has the steps.
- Set effort per workload, not per org. Medium as the default, high for hard tasks, max only where you've measured that it changes the result.
- Gate fast mode on a person being present. Interactive sessions only, never batch or CI.
- Re-check routing. If 5.2 beats Opus 5.5 at half the cost per task on your hard work, some tasks should move up to it. If Opus or Sonnet already passes, those tasks don't need it.
Where Nadir fits.
A 20% cut is the kind of change Nadir is built around: the price of one model moved, and what you should do with each request moved with it.
Send model="auto" and Nadir's trained classifier reads each prompt and picks a model from the ones you've configured, against the quality floor you set on the API key. Each response's metadata reports which model served it and what it cost. That's the routed row in the table above, applied per request instead of by hand.
If you'd rather keep calling Anthropic directly, POST /v1/bucket returns simple, medium or complex with a probability for each, so your own harness can choose the model and effort level and keep Fable 5.2 and fast mode for the work that needs them.
To see what routing would change before it changes anything, Observe mode serves exactly the model you asked for and records what Nadir would have picked. A week of that gives you real tokens per task, the input effortbill.py needs.
On the hosted gateway with your own provider keys, the provider bills you directly and Nadir charges a flat $0.002 per request, with the first 50 requests a month free. Savings depend on your workload, and nothing in this post forecasts yours.
Start with a free key or estimate your savings from your current model spend.
Conclusion.
Fable 5.2 is cheaper than Fable 5.1 on every token type, and switching costs you a model ID and one cache rebuild. Take the 20%. Just don't mistake it for the main lever. On our illustrative task, effort spreads the bill 5.4x, fast mode doubles it, and routing tasks to the smallest model that passes cuts it 60%. The price per token went down by a fifth. The price per task is still mostly up to you.
Sources: [Anthropic, Introducing Claude Fable 5.2 and Claude Mythos 5.2](https://www.anthropic.com/claude-fable-and-mythos-5-2), November 9, 2026: pricing, fast mode, effort levels, FrontierCode 2.0 figures and fallback behavior. [Anthropic, Pricing](https://platform.claude.com/docs/en/about-claude/pricing), retrieved November 10, 2026: full rate card, cache multipliers, fast-mode stacking, batch prices and long-context terms. [Artificial Analysis, Claude Fable 5.2](https://artificialanalysis.ai/models/claude-fable-5-2), retrieved November 10, 2026: Intelligence Index 65 at max effort with default fallback, $26.54 per index task, 275M output tokens, 102 tokens per second. [Artificial Analysis, GPT-6 Astra](https://artificialanalysis.ai/models/gpt-6-astra), as reported by [Kingy AI](https://kingy.ai/blog/fable-5-2-vs-gpt-6-astra/): 57 at max effort, $6.24 per task. Token counts, effort multipliers, engineer cost and the routing split are our illustrative assumptions.