What changed, and what Anthropic has not told you
Anthropic released Claude Fable 5.2 and Claude Mythos 5.2 on November 9, 2026. It describes them as the same underlying model, with Fable open to all users and Mythos limited to verified organizations.1 The headline claims are an output speed up to 30% faster than Fable 5.1, a lower price, and an optional fast mode.1
Those are vendor claims on vendor benchmarks. They tell you where to look. They do not tell you what happens on your prompts, your tools and your success criteria. The rest of this article is the order in which to check.
| Item | Fable 5.1 | Fable 5.2 |
|---|---|---|
| Input | $10 | $8 |
| Output | $50 | $40 |
| 5-minute cache write | $12.50 | $10 |
| 1-hour cache write | $20 | $16 |
| Cache read | $0.25 | $0.20 |
| Fast mode input / output | not listed | $16 / $80 |
The standard rows come from the pricing page2 and the fast mode row from the announcement.1 Context (1M tokens), maximum output (128K) and always-on adaptive thinking are unchanged, and Fable 5.2 is not retired sooner than November 9, 2027.3 These are list rates. If your contract carries different rates, test against those.
Step 1: run the checks that fail requests
Cost comparisons are meaningless if requests return 400. Anthropic's migration guide calls the move from 5.1 mostly drop-in, then lists four changes that can break code.4 Test each before you shift any traffic.
- Prefix check on every account. Editing the system prompt, the tools or an earlier message after a thinking block was produced now returns a 400 on every account. On Fable 5.1 the same error applies by default only to accounts created on or after August 31, 2026, so older accounts can pass on 5.1 and fail on 5.2.5 Retrying the same body does not clear it.4
- Thinking blocks are model-bound. Fable 5.2 reads Fable 5.1's blocks, but Fable 5.1 cannot read 5.2's. A router switch, client retry or refusal fallback away from 5.2 drops the blocks the next model cannot read. The request succeeds and dropped blocks are not billed, but the model works without that reasoning, which can raise cost and latency on the first turn after the switch.4
- Computer use. The earlier
computer_20251124tool returns a 400 on every platform except Amazon Bedrock; use thecomputer_toolset_20260801toolset.5 - Advisor pairing. A Fable 5.2 executor accepts only Fable 5.2 or Mythos 5.2 as advisor.5
Three constraints carry over from 5.1 and matter if you arrive from Opus: forced tool use (tool_choice of any or tool) returns a 400, sampling parameters such as temperature must be omitted, and the model requires 30-day data retention and is unavailable under zero data retention unless Anthropic authorizes it.3 Neither model is supported on Priority Tier, and Fable 5.2 has its own rate limit, separate from the pool that Fable 5.1 and Fable 5 share.4
Step 2: measure output length at the effort you send
The announcement says Fable 5.2 can finish challenging tasks with fewer tokens than 5.1 at Medium effort, and that at High effort on FrontierCode 2.0 it scored about level with Opus 5.5 at Max effort (45.3% against 45.5%) for roughly half the cost per task.1 Read the qualifier: Medium is the default in Claude apps and Claude Code. The API default for Fable 5.2 is high, and Anthropic advises starting there and stepping up to xhigh only where you have measured a gain.5
So an efficiency claim made at medium may not describe your API traffic. Replay the same fixed task set against each candidate at each effort level you would actually ship, and record, per task:
usage.output_tokens, split by task type and by whether the task succeeded.- Stop reason, to count answers cut off by
max_tokens. - Number of tool-use turns for agent tasks, since a model that finishes in fewer turns changes input cost more than output cost.
- Wall-clock time and time to first token.
Anthropic also says testers found Fable 5.2 communicates more clearly.1 That may change visible answer length in either direction. Anthropic's own guidance for shorter responses is to adjust the prompt toward the length you want,6 so check whether a prompt tuned for 5.1's verbosity still gives the length your UI, parser or downstream token budget expects.
Step 3: check tokens, but do not assume a tokenizer shift
Anthropic's pricing page says Claude 4.7 and later models use a newer tokenizer that produces approximately 30% more tokens for the same text, with Sonnet 4.6 and earlier on the previous one.2 Fable 5.2 uses the tokenizer introduced with Opus 4.7.5 By that wording, Fable 5.1, Opus 5.5 and Fable 5.2 all sit in the "4.7 and later" group, so a tokenizer-driven jump between them is not what the docs describe. The pages I read give no model-by-model token counts, so verify rather than assume.
The check is cheap: count tokens for a sample of your real prompts, including system prompt, tool definitions and a long conversation, on both model ids, and compare against the usage.input_tokens you are billed. If you are coming from a model that predates 4.7, the roughly 30% effect applies and the rate cut will not offset it by itself; switching models changes the tokenizer covers that method.
Step 4: re-price the cache, then test it cold
Cache reads fall from $0.25 to $0.20 per million tokens and writes fall 20% with the input rate.2 Reads are 2.5% of the input price on both models, so the ratio of read to write cost is unchanged. Per the pricing page, a 5-minute write pays back after one read and a 1-hour write after two.2 Your break-even is therefore the same; only the dollar amounts move.
What to test is behavior, not the rate:
- Cold start. Anthropic's caching docs describe the cache as keyed on the prefix of tools, system and messages, in that order.7 Plan for the first requests on a new model id to write the cache from scratch, and watch the write-token share for the first hour of a canary.
- Lifetime. The default lifetime is five minutes, measured from the start of the request that writes or reads the entry, not the end of its response. A four-minute response leaves about a minute for the next request to reuse the prefix.7 Long-thinking agent turns on 5.2 can push you past this; measure hit rate by turn.
- Prefix edits. Mid-conversation tool changes edit
tools, which sits at the front of the prefix. Anything that mutates tools or the system prompt between turns costs you both a cache miss and, on 5.2, the prefix check described above.5 - Mixed speeds. Requests at different speeds do not share cached prefixes.8
Step 5: price fast mode on the whole request, not the headline
Fast mode runs the same model with a faster inference configuration at premium pricing. Anthropic lists $16 per million input and $80 per million output tokens for Fable 5.2,1 twice the standard rate. You opt in per request with speed: "fast", and the gain is up to 2.5x output tokens per second, not time to first token.8 If your latency problem is a slow first token, fast mode does not address it.
Check these before turning it on:
- Fast mode has its own rate limit, separate from standard limits. Exceeding it returns a 429 with
retry-after, and a capacity problem can return a 529; the SDK retries 429s twice by default.8 - Falling back to standard speed is a prompt cache miss, because speeds do not share prefixes.8 A fallback that fires under load re-writes your whole prefix at the standard write rate.
usage.speedreportsfastorstandard. Log it per request, or you cannot tell which requests paid the premium.8- On Microsoft Foundry fast mode is a separate model id,
claude-fable-5-2-fast, and a deployment without-fastrejects aspeedparameter.8
Decide per step, not per product. Fast mode earns its premium where a person or a blocking pipeline waits on a long streamed output; it does not where a batch job runs overnight. Ultrafast mode in an agent loop walks through that split for another provider's tier.
Step 6: decide on cost per successful task
Per-token rates, output length, cache hit rate and success rate multiply together. Only one number combines them: total provider cost for the task set divided by the number of tasks that passed your grader. Anthropic's efficiency figures are cost per task on its benchmarks; yours must come from your grader.1 Cost per successful task covers the metric, and calibrating an LLM judge covers trusting the pass/fail.
# Rates in USD per million tokens, from Anthropic's list prices.
# Fast mode: cache rates not entered on purpose; fill them in before use.
RATES = {
"claude-fable-5-1": {"in": 10, "out": 50, "write": 12.5, "read": 0.25},
"claude-fable-5-2": {"in": 8, "out": 40, "write": 10, "read": 0.20},
"claude-fable-5-2:fast": {"in": 16, "out": 80},
}
def request_cost(model_key, usage):
r = RATES[model_key]
cost = usage.input_tokens * r["in"] + usage.output_tokens * r["out"]
cache_w = getattr(usage, "cache_creation_input_tokens", 0) or 0
cache_r = getattr(usage, "cache_read_input_tokens", 0) or 0
if cache_w or cache_r:
cost += cache_w * r["write"] + cache_r * r["read"] # KeyError if unpriced
return cost / 1_000_000 # assumes 5-minute cache writes
def cost_per_success(rows):
# rows: [(cost_usd, passed_bool), ...] for the whole task set, retries included
total = sum(c for c, _ in rows)
passed = sum(1 for _, ok in rows if ok)
return total / passed if passed else float("inf")Run three arms, not two: Fable 5.1 (your current baseline), Fable 5.2 at the effort you plan to ship, and Opus 5.5 at its own tuned effort. Anthropic still recommends starting with Opus 5.5 for most workloads and moving to Fable when your evaluations on Opus at higher effort fall short.6 Fable 5.2 lists at twice Opus 5.5's per-token rate,2 so the half-the-cost-per-task claim is exactly the one to confirm or reject on your data.
Roll it out as a canary with a rollback you can price
Once the task set favors 5.2, ship it as a weighted split rather than a cutover, and decide the rollback trigger in advance: cost per success, cut-off rate or first-token latency past a threshold. Keep the rollback path honest. Moving a live conversation back to 5.1 loses 5.2's reasoning, so route by conversation and not by request.4
If you route through INFRO, weighted routes over your own Anthropic connection can carry the split, and per-request records of model, token counts and estimated provider cost give you the output-length and cost columns above. Traffic changes flags longer answers, a lost prompt cache and answers cut off by the length limit, with an estimated weekly cost change; it sees request metadata, not answers, so quality still comes from your grader. Negotiated rates entered as custom rates make the estimates use your contract, not the list rates quoted here.
