Fable 5 + Sonnet 5: What Anthropic's Own Benchmark Data Says About Claude Code Costs

Anthropic doesn’t usually publish head-to-head cost data on its own models. So when a benchmark comparing Fable 5 running solo against Fable 5 paired with Sonnet 5 started circulating — first as an Instagram post, then as a LinkedIn share with a slightly more sober write-up — it was worth checking the actual numbers instead of the paraphrase. They hold up, and they’re more specific than the “use cheaper models for simple tasks” advice that usually passes for cost optimization.

Two patterns, two benchmarks, one conclusion: the expensive model should be doing less work, not less thinking.

Pattern 1: Fable 5 orchestrates, Sonnet 5 executes

In this setup, Fable 5 never touches the raw task. It reads the request, breaks it into subtasks, and hands each one to a Sonnet 5 subagent — the equivalent of a tech lead who writes the ticket and reviews the diff, but never opens the file itself. On Anthropic’s BrowseComp benchmark (an agentic web-research eval), that structure scored:

• 86.8% accuracy at $18.53 per problem (orchestrator pattern)
• 90.8% accuracy at $40.56 per problem (Fable 5 running solo)

That’s 96% of the solo score at 46% of the cost — a 54% price cut for giving up four accuracy points. For research and fan-out tasks, where the bulk of the token spend is reading pages and cross-checking sources rather than making judgment calls, that trade is close to free.

Pattern 2: Sonnet 5 executes, escalates to Fable 5 only when stuck

The second pattern inverts who’s in charge. Sonnet 5 runs the whole task by default and calls Fable 5 in only when it hits a decision it can’t resolve on its own confidence — Anthropic’s data puts that at roughly once per task. Think of it as Sonnet doing the work and pinging a senior engineer for a second opinion on the one genuinely hard call, instead of having that senior engineer sit in on every step.

On SWE-bench Pro — Scale AI’s harder, contamination-resistant successor to the original SWE-bench, built from long-horizon tasks across real production repos — that setup reached:

• ~92% of Fable 5’s solo score at ~63% of the cost

The number worth sitting with is the baseline comparison Anthropic ran alongside it: an all-Sonnet 5 run, no escalation at all, cost $16.01 — barely $2.50 less than the hybrid setup — but accuracy fell to 77.8%. Skipping Fable 5 entirely doesn’t save much money; it just quietly gives up the accuracy the hybrid pattern was paying for in the first place. Anthropic’s framing was blunter than most of its usual copy: you’re buying roughly nine points of accuracy for the price of a coffee.

Why this works: Fable’s price tag makes the split rational

Fable 5 runs $10 per million input tokens and $50 per million output tokens on Anthropic’s pricing page — double Opus 4.8’s rate and roughly 5-10x Sonnet 5’s, depending on which pricing window you’re in. Output tokens are where that gap actually bites: every paragraph of planning or explanation Fable writes costs 5x what the same text would cost coming out of Sonnet. Neither pattern tries to make Fable cheaper. Both just shrink how much of the task Fable ever sees, and let Sonnet absorb the token-heavy, low-judgment volume at a fraction of the rate. Fable spends its budget on the handful of moments where model quality actually shows up in the output — the plan, the escalation call — not on the boilerplate around it.

Setting up the pattern in Claude Code

Both patterns run on the same primitive: subagents, which are just markdown files that pin a model and a role.

mkdir -p .claude/agents

<!-- .claude/agents/fast-worker.md -->
---
name: fast-worker
description: Executes well-scoped implementation tasks handed off by the orchestrator.
model: sonnet
---

You implement exactly what's specified in the task description. Don't
re-plan or second-guess the approach — if the task looks wrong, say so
and stop instead of improvising a different one.

For the orchestrator pattern: run /model and select Fable 5 as your main session model, then add a line to CLAUDE.md telling it to delegate implementation work to fast-worker subagents and reserve its own turns for planning and review.

For the escalation pattern: flip it — run the session on Sonnet 5, and create an advisor subagent pinned to Fable 5 that Sonnet is instructed to consult only when it’s genuinely unsure, not as a first resort:

<!-- .claude/agents/deep-reasoner.md -->
---
name: deep-reasoner
description: Consult only for architecture decisions or when genuinely stuck — not for routine implementation.
model: fable
---

You're being consulted because the executor hit a decision it couldn't
resolve confidently. Give a direct recommendation, not a menu of options.

Restart the session after adding new agent files — Claude Code loads subagent definitions at startup. Both patterns run through the same underlying mechanism the site covers in 9 Ways to Reduce Token Usage in Claude Code: sub-agent delegation keeps token-heavy work out of the expensive model’s context window, whichever direction the delegation runs.

The gap in this benchmark that matters for your bill

Every write-up of these numbers — including this one, up to this point — treats the cost figures as fixed. They aren’t. The escalation pattern’s savings assume Sonnet 5 is doing cheap, high-volume execution; that assumption only holds if what Sonnet is actually processing is cheap. A Sonnet subagent asked to debug a layout issue from a full-page screenshot is paying visual-token rates — up to roughly 2,691 tokens for a single 1920×1080 capture — to do parsing work a structured DOM selector would hand it as 30 tokens of text, the same markup covered in 10 Tips to Stop Burning Your Tokens in Claude Code. Run enough of those through a Sonnet executor and the $18.53-per-problem or $16.01-per-run numbers stop being what you actually pay.

This is exactly the gap UICuts closes: point at any element on a live page and it hands your Sonnet subagent the real selector, computed styles, and DOM structure as text — no screenshot, no vision-token markup, no guessing which element you meant. If you’re setting up either pattern above specifically to cut costs, feeding the cheap model expensive images undoes a chunk of the savings you just engineered.

If you’re writing your own subagent instructions or Claude Skills to codify this delegation logic, the same conditional-loading discipline applies on both sides of the split — a bloated advisor prompt costs Fable-rate tokens on every escalation, and a bloated worker prompt costs Sonnet-rate tokens on every single subagent call, just with a lower price tag per mistake.

Key lessons learned

• Anthropic’s own data argues for using its most expensive model less, not smarter in the abstract — both patterns work by shrinking how much of the task Fable 5 ever touches, not by making Fable cheaper.
• The all-Sonnet baseline is the most useful number in the whole benchmark: skipping the expensive model saves barely 15% of cost but gives up roughly 14 accuracy points on SWE-bench Pro. Cheap-only isn’t the free win it looks like.
• The savings these patterns advertise assume the cheap model’s execution stays cheap — screenshots and raw dumps handed to a Sonnet subagent erode the exact cost gap the benchmark is measuring.

Related reading

This post extends the cost-accounting approach from 10 Tips to Stop Burning Your Tokens in Claude Code to a multi-model setup instead of a single session, and builds on the sub-agent delegation habit from 9 Ways to Reduce Token Usage in Claude Code. If you’re scripting the delegation rules themselves, Using Claude Skills to Reduce Token Usage covers the same conditional-loading principle for whatever instructs the handoff. And if you’re wiring up similar prompt-routing outside of Claude Code entirely, Prompt Engineering to Reduce Token Usage covers the API-level version of the same idea — the model-tiering instinct behind both patterns above is the same one that makes reducing token usage in Cursor or OpenCode come down to picking the right model for the step, not just the right prompt.

Install UICuts free if screenshots are still how UI context reaches your Sonnet subagents — it’s the one line item in this setup that’s worth fixing once, whichever pattern you land on.