On July 13, Claude Fable 5 leaves subscription plans and goes on a meter: $10 per million tokens in, $50 out. That is twice Opus 4.8, and it sits outside your usage limits entirely. No credits enabled, no Fable.
The instinct is to treat this as a price problem: budget more, or use Fable less. Both miss what the meter is actually telling you. Fable is not expensive. Un-routed workflows are expensive. A team that pipes every token through the frontier model pays frontier prices for grep. A team that routes pays Fable rates only for the tokens that decide the outcome, and executor rates for everything else.
The strange part: Anthropic has quietly published most of the playbook itself. Here it is in five moves, numbers checked against their own pricing docs.
Move 1: Let Fable advise, not type
The single biggest saver is a pattern Anthropic ships as a product. The advisor tool, in beta since March, pairs a cheap executor model with an expensive advisor. The executor does the task. Mid-generation, when it needs a plan or a course correction, it calls the advisor, gets guidance, and keeps going. The advisor reads everything but writes little. And output is where Fable hurts: $50 per million tokens.
Devs
"Use Fable 5 as an 'advisor.' An executor (Sonnet 5) calls Fable 5 for guidance. Most tokens are billed at the lower executor rate."
The number attached to it in the coverage: Sonnet 5 as executor with Fable 5 as advisor reached roughly 92% of Fable-solo performance at 63% of the cost on SWE-bench Pro. Treat it as reported rather than gospel, but the direction is not subtle. You keep most of the intelligence and skip most of the bill.
You do not need the API to run this shape. In Claude Code, keep the session on Sonnet or Opus and pull Fable in only for the plan, the gnarly bug, or the final review: switch with /model, or point a single subagent at it. The advisor pattern is a workflow, not a feature flag.
Move 2: Route by phase, not by task
The community version of the same idea is being called 10-80-10. Fable owns the first 10%: structure, approach, success criteria, what could go wrong. Cheaper models own the 80% in the middle: the implementation loop, the mechanical edits, the retries. Fable comes back for the last 10%: review the output against the plan it wrote. One widely shared example prices a 30-step refactor agent at ~$25 per run on all-Fable and ~$1.40 with Fable planning and a budget executor doing the middle. Single-source numbers, so hold them loosely. The ratio is the point.
Willison
"I told it 'For all coding tasks use your judgement to decide an appropriate lower power model and run that in a subagent' and it seems to be saving a lot of tokens."
Anthropic's multi-agent docs encode the same economics at the architecture level: a coordinator delegates to a roster of agents, and each agent runs its own model. Their own example puts a Haiku researcher under an Opus coordinator. If you are not on the SDK, the translation is direct: in Claude Code, subagents take a per-agent model override. Search agents on Haiku at $1 in, review agents on Opus, and the frontier model only where the decision lives.
Move 3: Bank skills while it is still in your plan
Until Sunday night you have Fable at up to half of your weekly limits, included. The race-the-window crowd is spending that on one last giant refactor. The smarter spend, and the one the community keeps converging on, is skill distillation: have Fable write down its own discipline as skills, then run those skills on cheaper models all year.
The name came out of a viral Reddit thread during the included window, and the cleanest data point so far comes from a practitioner who blind-graded it: fourteen tasks on Opus 4.8, with and without Fable-authored skills. 12 wins, 0 losses, 2 ties, for about 7% more tokens. A skill cannot make a small model reason like a frontier model, but it reliably moves the model from its lazy default to its careful mode. The lesson: let the smartest model you can rent write the habits your daily model runs. And skills are an open standard now: the same folder runs in Claude Code, Codex CLI, and Gemini CLI. Discipline written once, portable across every meter.
Move 4: Codex types, Claude thinks
The most aggressive version of routing crosses vendor lines. Peter Steinberger's codex-first skill routes all hands-on-keyboard work to Codex, which runs flat-rate, and keeps Claude for everything that requires judgment.
Steinberger
"Claude (Fable/Opus) tokens metered + expensive; Codex flat-rate. So Codex types, Claude thinks and verifies."
The contract is strict, and that is why it works. Fable writes a frozen spec: goal, paths, constraints, non-goals, the exact test that proves it done. Codex implements it. Fable reads the full diff and judges it like a contributor PR. Generation and exploration tokens, the bulk of any coding session, move to the flat-rate meter. Claude spends only on the spec and the review, which is exactly where it is worth $50 a million.
Move 5: Stack the boring discounts
Everything above is workflow. There is also plain arithmetic, straight from the pricing page, that most teams never touch.
- Prompt caching. Cache hits bill input at $1 per million, 90% off. Agent loops re-read the same system prompt and codebase context on every turn; if you are not caching, you are paying list price for the same tokens hundreds of times.
- Batch API. $5 in, $25 out, half price, for anything asynchronous: evals, audits, backfills, overnight report runs. If nobody is watching the cursor blink, batch it.
- Terse output. Output is 5x the price of input, so verbosity is the tax. Community skills like Caveman cut roughly 65% of output tokens by stripping filler while keeping code and commands byte-exact.
- Know your cheap seats. Sonnet 5 is at intro pricing, $2 in / $10 out, through August 31. Haiku 4.5 is $1 / $5. And a detail worth knowing: Opus 4.8 in fast mode costs exactly Fable's standard rate, $10 / $50. If you are paying that anyway, know which one you actually need.
everything at $10 / $50
15% Fable + 85% Sonnet
20% Fable + 80% Haiku
The trap: cheap tokens that cost hours
One warning before you route everything to the cheapest model. Per-token price is not per-task price. Developers Digest ran the comparison on a real feature build, and the cheap model won the rate card while losing the job.
Sonnet 4.6 in tokens, plus about two hours of cleanup on the other side.
Fable 5 in tokens, often production-ready on the first pass.
The breakeven. If your time is worth more than this, the Fable premium pays for itself in saved cleanup.
This is why the answer is routing and not abstinence. Uber learned it the loud way: agentic workflows without cost controls burned its entire 2026 AI budget in four months, and the company now caps coding tools at $1,500 per employee per month. The cap is not the lesson. The lesson is that neither "all frontier" nor "all cheap" survives contact with a real workload. Fable one-shots the task that would cost a cheaper model three retries and your afternoon; the cheaper model handles the 80% where one-shot quality is wasted.
Before Sunday night
The included window runs through July 12, 11:59pm PT, at 50% of your weekly limits. Four things worth doing with it:
- Enable usage credits now, with a cap. Settings, load a balance, set the ceiling. Access dies mid-session on July 13 otherwise, and there is no grace period.
- Have Fable write your skills. Point it at the workflows you repeat: reviews, migrations, release checklists. Its discipline, written down, runs on every cheaper model you own.
- Benchmark it on one real ticket. Not a toy. Run Fable and your current default on the same task and compare cost per finished task, cleanup included. Now you know your own breakeven, not Reddit's.
- Pick your routing default and write it down. Advisor pattern, 10-80-10, codex-first, or your own blend. The teams that decide this before the meter starts will not notice July 13. The teams that do not will discover it on an invoice.
We covered what the outage taught about renting frontier models: build so the model can disappear, because sometimes it does. The meter is the gentler version of the same lesson. The model is a tenant, and now the tenant charges by the token. Own the loop around it, route the loop deliberately, and the frontier stays affordable at any list price.
Fable thinks. Sonnet types.
Route the loop, not the budget.
Book a free Diagnostic: 30 to 45 minutes, no deck, no pitch. We map where your AI spend actually goes, which of your workflows deserve frontier tokens, and what an operator layer with deliberate routing would save you per month.
Book the Diagnostic →Questions, answered
How much does Claude Fable 5 cost after July 12?
From July 13, Fable 5 no longer draws from Claude subscription limits. It bills only through usage credits at $10 per million input tokens and $50 per million output tokens, twice the rate of Opus 4.8. You enable credits under Settings, redemptions cap at $2,000 a day, and without credits enabled access simply stops. The API and consumption-based Enterprise plans are unchanged.
How do I use Fable 5 as an advisor to save tokens?
Run a cheaper executor model (Sonnet 5) on the task and let it call Fable 5 only for the plan, the dead end, and the review. Most tokens then bill at the executor rate. Anthropic ships this as the advisor tool (beta) on the API; reported results are roughly 92% of Fable-solo quality at 63% of the cost on SWE-bench Pro. In Claude Code, keep the session on a cheaper model and switch to Fable with /model, or route a single subagent to it.
What is skill distillation?
Having Fable 5 write skills (SKILL.md files encoding its working discipline) that cheaper models then execute. In a fourteen-task blind test on Opus 4.8, Fable-authored skills won 12, lost 0, and tied 2, at about 7% more tokens. Skills follow an open standard, so the same files run in Claude Code, Codex CLI, and Gemini CLI.
What is the cheapest way to run Fable 5 on the API?
Stack the built-in discounts: prompt caching bills repeated context at $1 per million input tokens (90% off), the Batch API halves everything to $5 in and $25 out for asynchronous work, and a terse-output skill cuts roughly 65% of output tokens. Budget for the tokenizer too: Fable's tokenizer produces about 30% more tokens for the same text.
