Claude Fable 5.1: Same Prices, Fewer Tokens — What the Release Means for Agent Costs

Q: Do I have to migrate all workloads to Fable 5.1 now?

No — and "all" is the wrong framing anyway. Existing Fable 5 prompts will continue to run without changes according to Anthropic, so there's no forced migration. Upgrading makes the most sense where agents heavily reuse context: coding loops, cron jobs with static system prompts, and multi-agent systems. For zero-shot, low-context applications, the cache savings are too small to justify switching for that reason alone.

Q: How do I measure Cost-per-Task without digging deep into the API?

Almost every agent framework or UI outputs the usage fields (input_tokens, output_tokens, cache_read_input_tokens) in the response — via Python SDK, CLI, or log files. You just need to append them (e.g., to a usage.jsonl) and sum them up per task. For tools without clean data exports, simply noting the start and end token counters per task is enough. The conversion is simple math against the pricing table; the Python snippet above does exactly that.

Q: What does the Effort Level actually mean for my bill?

Effort controls how many reasoning tokens the model invests per answer — at the exact same price per token. High is Anthropic's default and is overkill for most routine tasks; Medium to Low deliver the exact same quality for summaries, formatting, and simple refactors at a fraction of the token cost. The catch with Low: The model relies less on search and retrieval tools, making it the wrong choice for deep research tasks. Rule of thumb: start on High, test one level lower against the same spec,

Q: Is Fable 5.1 ultimately cheaper than Fable 5?

In total, almost certainly. But strictly based on the price list, absolutely not — the rates are identical. It gets cheaper through three side channels: fewer tokens per task (Anthropic says 25 to 50 percent), cache reads at a quarter of the old price, and effort granularity that allows you to accurately scale reasoning overhead for the first time. If you were already running everything at the lowest viable effort and maximizing cache, you will save less than the average user — whose savings wil

Q: What does the price parity with GPT-6 Astra mean for my vendor choice?

It means that the price question falls out of the equation and is replaced by a product-market fit question. Artificial Analysis sees Astra five points behind Fable 5.1 on the Intelligence Index, but ahead of Fable 5 on the coding-agent cost curve — depending on the task, a different capability/price-per-task pairing wins. The practical takeaway: base your vendor swappability purely on your cost-per-task audit, not on brand labels. Without a pricing gap, switching models is now purely a question

Q: Should we rewrite all our prompts and skills immediately?

Don't rewrite — declutter. Anthropic explicitly warns that skills built for older models are too prescriptive for Fable 5/5.1 and cost efficiency rather than generating it. A prompt audit (Peter Yang: run a prompt audit command across all skills) will spot redundancies in minutes. Keep anything that works and is objectively verifiable; delete anything that tries to micro-manage the model's reasoning process.

TL;DR: Claude Fable 5.1 costs exactly the same as Fable 5: $10 per million input tokens, $50 per million output tokens. The price tag stayed the same — the final bill won't. Cache reads dropped from $1 to $0.25 per million tokens, the context window expands to 1 million tokens, and Anthropic estimates a 25 to 50 percent reduction in token usage per task. For anyone running agents, the cost question shifts from "which model?" to "how many tokens per task?". This article breaks down the math — and provides a copyable cost-per-task audit for your own stack.

What actually landed

In early September, Anthropic released Claude Fable 5.1 — no new price, no new pricing model, but a successor with the same price list and different behavior. The changes that matter for production:

Variable	Fable 5	Fable 5.1
Input per 1M tokens	$10	$10 (unchanged)
Output per 1M tokens	$50	$50 (unchanged)
Cache reads per 1M tokens	$1	$0.25 (−75%)
Context window	< 1M tokens	1M tokens
Token usage per task	Baseline	−25 to −50% (Anthropic estimate)

Our first glance usually goes to the benchmarks — Terminal-Bench 4.0: 55.8 percent compared to 42 percent for Fable 5 and 52.3 percent for Opus 5; on the Research-Benchmark 52.6 versus 24.7 percent. Cursor calls Fable 5.1 on CursorBench 3.2 (scoring 73.4 percent at Max-Effort) the "most capable model we've ever tested," and Artificial Analysis places Fable 5.1 on the Intelligence Index at 61 points — five points ahead of GPT-6 Astra and GPT-5.6 Sol.

However, for your monthly invoice, that's the wrong number in the wrong place. The relevant line item isn't found in any benchmark table: fewer tokens per completed task at the exact same rate.

Same price list, different math

Agent production costs are calculated by multiplying two variables: the rate per token and the volume of tokens consumed by a task. Until now, cost reduction almost always targeted the first variable — smaller model, cheaper rate, lower quality. Fable 5.1 attacks the second variable.

In concrete terms: If a task that cost 80,000 output tokens and 400,000 input tokens on Fable 5 now only requires 55,000 and 280,000 respectively on 5.1, the bill drops from $8 to roughly $5.50 — a decrease of about one-third — without you having to book a cheaper model, trim prompts, or sacrifice quality. Anthropic cites a range of 25 to 50 percent, depending on the workload. That is a vendor estimate, not a universal metric — but the mechanics behind it are verifiable, right in your own logs.

The second cost variable is the Prompt Cache. Agentic runs are reading machines: system prompts, repo context, and tool descriptions are fed through the window over and over at each step. With Fable 5, re-reading these blocks cost $1 per million tokens — on a 30-step run reading 150,000 cached tokens per step, the re-reads alone added up to $4.50 per task. At $0.25, it's just $1.13. Early tests in agentic workloads are therefore reporting up to 45 percent lower total costs — not because the model computes less, but because it ingests the same knowledge more cheaply.

The lever almost no one uses: Effort Levels

Anthropic ships Fable 5.1 with Effort Levels — ranging from Low, Medium, and High to X-High and Max, plus an Ultra mode for coding. The default is High. And that is exactly where the money is: Anthropic's docs show that Fable 5.1 on Low roughly corresponds to Fable 5 on Medium or High — with significantly lower token consumption per completed job. Practitioners are already comparing 5.1 on Low to the reasoning levels of previous premium models.

Three details from the official prompting docs determine your final bill:

Focus on the goal, not the tasks: Fable 5.1 works cleaner when you define the objective and the stop condition rather than a step-by-step list. Fewer misunderstandings mean fewer repetitions, which means fewer tokens.
Effort can be toggled per message — and the Prompt Cache is preserved. You can run research turns on High, then summary turns on Low, without losing the cache. With other models, switching effort levels flushes the cache.
Low also means fewer tool calls. On low effort, 5.1 invokes search and retrieval tools less frequently, preferring to answer from context. This is desirable for brainstorming and structural work, but wrong for factual research.

If you run everything on High, you are paying for reasoning overhead that the task never required — at a static price rate, this is the largest single line item you have direct control over.

What Anthropic recommends — and what it costs

The prompting documentation for Fable 5.1 reads like a cost-reduction manual. Anthropic draws four main guidelines, complete with their cost impact:

Declutter old skills. Skills and prompts from the previous model generation are "often too prescriptive" for Fable 5/5.1 — too many instructions constrain the model and produce detours instead of efficiency. Peter Yang recommends running a prompt audit across all skills after upgrading and cutting out redundancy.
Make it prove its work. The documentation explicitly suggests having the model verify its output against the spec — using verifier sub-agents and per-claim audits. This costs tokens upfront, but saves you from the most expensive token type: rework caused by bad first drafts.
Parallelize and delegate. Fable 5.1 reliably dispatches parallel sub-agents and batches independent tool calls. Anthropic notes: parallel sub-agents save time and costs via cache reads, because the shared context is reused cheaply instead of being billed as new per sequential step.
Long tasks without methodology dictation. Given a clear goal, 5.1 can work long stretches without methodological hand-holding — every superfluous "do A, then B" is an instruction the model would build itself anyway, and tokens that you are paying for.

The most radical demonstration of this architecture comes from the community: Teknium let the Hermes agent run with a single goal using 1,320 recursive sub-agents over ~15 hours — stripping 375,000 lines of code from a repo, on a desktop, noting "the model is Fable 5.1 btw". This isn't a cost-saving example, but an architectural proof: The orchestrator holds the context, the workers pull it cheaply from the cache.

First independent numbers — and their limits

Alongside Cursor, WorldofAI reports their own tests on Fable 5.1 (Terminal-Bench, Research-Bench), and Artificial Analysis confirms its top position in the Intelligence Index. Three things you should keep in mind when doing the math:

Benchmark score ≠ your price per completed task. Artificial Analysis places Astra ahead of Fable 5 on the coding-agent cost curve — similar results at about half the cost. If you buy based on leaderboards, you are buying blind to the reality of your own stack.
The harness is part of the score. The Astra puzzle of 62.7 versus 99.9 percent on ARC-AGI-3 depending on the adapter proved again just a week after 5.1's launch: What a model "can do" depends on how the runner handles context and reasoning state. The same rule applies to your token budgets.
25 to 50 percent is a claim. It is plausible, it is verifiable — but it must be verified on your runs. That is exactly where the next section comes in.

Market context: two flagships, one rate

Four days after Fable 5.1, GPT-6 Astra landed — priced at 10/50, a blatant copy of Fable's price list. For the first time, price parity exists across the two most important labs at the top tier. The cheap rule of thumb "smaller model = savings" dies in the premium segment: When two flagships cost the same per token, the model choice is no longer the cost decision. The cost decision is how many tokens a task consumes — and that is a combination of both model behavior and your setup.

Copyable: Your Cost-per-Task Audit

The only proof that matters comes from your logs. Instead of trusting benchmarks: measure tokens. You need two building blocks.

First: Track usage fields per call and convert them to dollars — using Fable pricing:

import json

PRICES = {"input": 10/1e6, "output": 50/1e6, "cache_read": 0.25/1e6}

def task_cost_usd(usages):
    """usages: List of response.usage objects for a single task."""
    return sum(
        u["input_tokens"] * PRICES["input"]
        + u["output_tokens"] * PRICES["output"]
        + u.get("cache_read_input_tokens", 0) * PRICES["cache_read"]
        for u in usages
    )

Second: The audit itself — as an assignment for your coding agent, to be run quarterly or after every major model release:

Model Audit, step by step:
1. List every automated AI call: Agents, Cron jobs, Hooks, Defaults.
2. Per call note: Model, Effort Level, Price per 1M tokens (current list),
   Monthly Volume, and Cost-per-Task from the usage log (Before value!).
3. Mark with "?" where model and effort were never consciously chosen.
4. For every "?" entry: test Medium and Low against the same
   functional test. Pick the cheapest tier that passes the test.
5. Document the "After" Cost-per-Task per entry.
Trigger: after every model launch, otherwise quarterly.

The goal isn't just to "save more" — the goal is to attach a dollar figure to a task where none existed before. A Before/After comparison on the exact same task is the only benchmark that actually moves your bottom line.

The honest limit

Anti-hype, in three sentences: Fable 5.1 is and remains a premium model — $10/$50 per million tokens is a lot of money for any application that could be run cheaper. The 25 to 50 percent savings is an Anthropic estimate that only becomes reality (or doesn't) in your own logs. And the sub-agent trick shifts tokens, it doesn't eliminate them: a poorly architected orchestrator will burn more money than it saves. Ultimately, the release doesn't do the work for you — it just unlocks the variables you are allowed to tweak.

FAQ

Do I have to migrate all workloads to Fable 5.1 now?

No — and "all" is the wrong framing anyway. Existing Fable 5 prompts will continue to run without changes according to Anthropic, so there's no forced migration. Upgrading makes the most sense where agents heavily reuse context: coding loops, cron jobs with static system prompts, and multi-agent systems. For zero-shot, low-context applications, the cache savings are too small to justify switching for that reason alone.

How do I measure Cost-per-Task without digging deep into the API?

Almost every agent framework or UI outputs the usage fields (input_tokens, output_tokens, cache_read_input_tokens) in the response — via Python SDK, CLI, or log files. You just need to append them (e.g., to a usage.jsonl) and sum them up per task. For tools without clean data exports, simply noting the start and end token counters per task is enough. The conversion is simple math against the pricing table; the Python snippet above does exactly that.

What does the Effort Level actually mean for my bill?

Effort controls how many reasoning tokens the model invests per answer — at the exact same price per token. High is Anthropic's default and is overkill for most routine tasks; Medium to Low deliver the exact same quality for summaries, formatting, and simple refactors at a fraction of the token cost. The catch with Low: The model relies less on search and retrieval tools, making it the wrong choice for deep research tasks. Rule of thumb: start on High, test one level lower against the same spec, keep the lowest level that passes.

Is Fable 5.1 ultimately cheaper than Fable 5?

In total, almost certainly. But strictly based on the price list, absolutely not — the rates are identical. It gets cheaper through three side channels: fewer tokens per task (Anthropic says 25 to 50 percent), cache reads at a quarter of the old price, and effort granularity that allows you to accurately scale reasoning overhead for the first time. If you were already running everything at the lowest viable effort and maximizing cache, you will save less than the average user — whose savings will largely come from optimizing thoughtless defaults.

What does the price parity with GPT-6 Astra mean for my vendor choice?

It means that the price question falls out of the equation and is replaced by a product-market fit question. Artificial Analysis sees Astra five points behind Fable 5.1 on the Intelligence Index, but ahead of Fable 5 on the coding-agent cost curve — depending on the task, a different capability/price-per-task pairing wins. The practical takeaway: base your vendor swappability purely on your cost-per-task audit, not on brand labels. Without a pricing gap, switching models is now purely a question of the harness and effort levels.

Should we rewrite all our prompts and skills immediately?