Fable 5 is the most capable model in the Claude family — and, at $50 per million output tokens, by far the most expensive to run. So here is the counterintuitive rule that saves serious money: the smartest way to use Fable 5 is to barely use it. Not as a workhorse that grinds through every task, but as a head chef — the one who designs the menu, calls the orders, and tastes the final plate, while cheaper models do the actual cooking.
Do that, and you pay premium rates only for planning and judgment, where the quality gap actually shows up, and let low-cost models absorb the bulk of the tokens. This guide shows the pattern, the real (official) pricing that makes it worth it, and the two levers Anthropic gives you to pull it off.
The Problem: Frontier Prices on Grunt Work
Every model in the Claude lineup charges a different rate, and the spread is wide. These are Anthropic's official published prices:
| Model | Input ($/M tokens) | Output ($/M tokens) | Role in the pattern |
|---|---|---|---|
| Fable 5 | $10 | $50 | Head chef — plan, judge, synthesize |
| Opus 4.8 | $5 | $25 | Specialist — hard bugs, design calls |
| Sonnet 5 | $2* | $10* | Line cook — most implementation |
| Haiku 4.5 | $1 | $5 | Prep cook — simple, high-volume tasks |
*Sonnet 5 introductory pricing runs through Aug 31, 2026; standard pricing is $3/$15 from Sep 1, 2026. Always check current rates.
The gap is stark: Fable 5's output costs five times Sonnet 5's and ten times Haiku 4.5's. And most real work — writing boilerplate, formatting, generating tests, applying a known refactor — is mechanical. It needs correctness and volume, not frontier intelligence. Paying Fable 5 rates to churn out that volume is like paying a head chef to peel potatoes. Anthropic's own cost-optimization guidance says as much: "Choose Haiku for simple tasks, Sonnet for most production workloads, and Opus for the most complex reasoning."
The Pattern: Orchestrator and Workers
The structure comes straight from Anthropic's playbook. In its guide to multi-agent coordination patterns, Anthropic describes the orchestrator-subagent approach: "One agent acts as a team lead that plans work, delegates tasks, and synthesizes results. Subagents handle specific responsibilities and report back." It recommends this as the default: "For most use cases, we recommend starting with orchestrator-subagent. It handles the widest range of problems with the least coordination overhead."
Think of the kitchen brigade. The head chef (Fable 5) never plates fifty covers alone — they read the tickets, decide what goes where, and expedite. The line cooks (Sonnet 5) do the volume. A prep cook (Haiku 4.5) handles the simplest repetitive work. And for the one genuinely tricky dish, you call the specialist (Opus 4.8). Everyone works at the level that matches the task — and you are not paying the head chef's wage to dice onions.
The Two Levers: Which Model, and How Hard It Thinks
Here is the part most people miss. You control cost with two dials, not one:
- Which model runs the task — the tiering above.
- How hard that model thinks — Anthropic's
effortparameter.
The effort parameter, in Anthropic's words, "lets you control how eager Claude is about spending tokens when responding." It runs from low to max, and it maps almost perfectly onto orchestrator versus worker roles. Anthropic's docs note that at higher effort a model will "explain the plan before taking action," while at lower effort it will "proceed directly to action" with "fewer tool calls" — exactly the difference between a planner and an executor.
Even more telling: the docs list the typical use case for low effort as "simpler tasks that need the best speed and lowest costs, like subagents." Anthropic is explicitly pointing at this pattern. And for Fable 5 specifically, the guidance is to "start with high (the default) for most tasks… and step down to medium or low for routine work."
So the combined recipe is:
- Orchestrator: Fable 5 at
high(orxhigh) effort — you want it thinking hard, because a good plan makes every downstream step cheaper. - Workers: Sonnet 5 or Haiku 4.5 at
loweffort — fast, cheap, and scoped to the specific task they were handed.
The Three Roles in Practice
- Fable 5 — the head chef (orchestrator). Reads the goal, breaks it into steps, decides what goes to whom, and stitches the results together. Runs at high effort. Never does bulk work itself.
- Sonnet 5 / Haiku 4.5 — the line cooks (workers). Do the high-volume mechanical work at low effort: routine code, tests, docs, refactors. This is where most of your tokens go, at the lowest rates.
- Opus 4.8 — the specialist (reasoner). Called in only for genuinely hard sub-problems: a subtle concurrency bug, an algorithm design, an ambiguous trade-off. Anthropic recommends starting Opus 4.8 at
xhigheffort for exactly this kind of work.
The principle: match the model and the effort to the difficulty of each task, not to the whole job.
Setting It Up
At the API level, the pattern is just a loop: your orchestrator call runs Fable 5 at high effort and produces a plan; each delegated step runs a cheaper model at low effort. In Claude Code, the same idea is built in — its "ultracode" mode pairs xhigh effort with permission to launch multi-agent workflows, and Anthropic documents a full "orchestration mode" example for the API.
Wherever you run it, the setup comes down to four decisions:
- Make Fable 5 the orchestrator and keep its effort high — the plan is the leverage point.
- Create workers on cheaper models (Sonnet 5 for general implementation, Haiku 4.5 for simple high-volume tasks) at low effort.
- Write explicit delegation rules so the orchestrator hands work down instead of doing it all itself. This is the single most important step.
- Prompt at a high level — describe the outcome, not the keystrokes, and let the orchestrator decompose and route.
A minimal delegation instruction (e.g. in a CLAUDE.md or your system prompt) might read:
## Delegation rules
- You (Fable 5) plan, decide, and synthesize. Do NOT write bulk code yourself.
- Delegate routine implementation, tests, and formatting to a worker
(Sonnet 5, low effort). Send simple high-volume tasks to Haiku 4.5.
- Escalate only genuinely hard reasoning — subtle bugs, algorithm design,
concurrency — to Opus 4.8 at xhigh effort.
- After workers report back, review and integrate their output.
If subagents and delegation are new to you, our getting started with AI agents guide covers the fundamentals first.
A Worked Example
The task: "Add a caching layer to our data service, with tests."
- Fable 5 (plan, high effort): decides the cache interface, where it sits, the invalidation strategy, and splits the work — "write the cache module," "wire it in," "write unit tests," "handle the race condition on concurrent writes."
- Sonnet 5 (execute, low effort): writes the cache module, the wiring, and the unit tests. High volume, low difficulty. Most of the task's tokens are spent here, at $10/M output.
- Opus 4.8 (reason, xhigh effort): is handed only the concurrency race condition — the one part where a cheaper model might be subtly wrong.
- Fable 5 (synthesize): reviews everything, resolves conflicts, confirms the pieces fit.
Fable's expensive tokens went to two small things — the plan and the final review. The bulky middle ran cheap.
How Much You Actually Save
The savings come from where the volume lands. Say a feature produces 60,000 tokens of mechanical output plus about 8,000 tokens of planning and judgment:
- All-Fable approach: ~68,000 output tokens at $50/M ≈ $3.40.
- Orchestrated (Sonnet workers): 8,000 planning tokens on Fable ($50/M ≈ $0.40) + 60,000 mechanical tokens on Sonnet ($10/M ≈ $0.60) ≈ $1.00 — a ~70% cut.
- Orchestrated (Haiku for the simplest work): the same 60,000 tokens on Haiku ($5/M ≈ $0.30) drops the total to ~$0.70 — closer to an 80% cut.
The mechanical tokens fell from the $50 tier to the $10 or $5 tier; only the 8,000 tokens that genuinely benefit from Fable stayed premium. (Figures are illustrative; your ratio of thinking to mechanical work sets the exact number.)
Two bonus levers from the same pricing page stack on top: prompt caching makes cache hits cost just 10% of the input rate (reuse a big system prompt across delegated calls), and the Batch API gives a 50% discount on non-interactive work.
A Quick Delegation Checklist
When the orchestrator hits a sub-task, route it by asking:
- Mechanical and well-specified? (known code, tests, formatting, standard refactor) → Sonnet 5, low effort. Simple and high-volume? → Haiku 4.5.
- Genuinely hard reasoning? (subtle bug, concurrency, algorithm design, a consequential trade-off) → Opus 4.8, xhigh effort. Don't cheap out here — a wrong answer costs more than the tokens you saved.
- Planning, decomposition, or final integration? → keep it on Fable 5, high effort. This is the orchestrator's actual job.
- Tiny task? (one-line fix, single file) → skip orchestration and just do it. The coordination overhead isn't worth it.
Cost efficiency is about matching difficulty to capability — not blindly reaching for the cheapest model every time.
Beyond Coding: The Same Pattern for Research and Writing
The structure is not coding-specific. The same economics apply to any high-volume language task:
- Research: Fable 5 plans the questions and synthesizes findings; a cheaper model reads and summarizes each source in parallel.
- Content production: Fable 5 sets the outline, angle, and editorial judgment; Sonnet 5 drafts sections; Fable 5 does the final edit.
- Data and analysis: Fable 5 decides what to compute and how to interpret it; cheaper models handle the repetitive extraction and transformation.
In every case the shape is identical: a thin layer of expensive thinking wrapped around a thick layer of cheap doing.
The Bottom Line
Fable 5 earns its premium exactly where thinking is hard — planning, judgment, and synthesis. It is a poor use of money as a bulk executor. The orchestrator-worker pattern lets you have both: frontier-quality decisions from Fable 5, and frontier-cheap execution from Sonnet 5 or Haiku 4.5, with Opus 4.8 on call for the genuinely hard parts. Pull the two levers together — the right model, at the right effort — and you keep the quality of the best model in the lineup while paying its rate only for the small slice of work that truly needs it.
The models differ in more than price, of course — for how they behave, see Claude vs. ChatGPT in 2026, browse our AI agents topic hub, or read why Fable 5's return from a government shutdown made headlines.
Frequently Asked Questions
What does it mean to use Fable 5 as an orchestrator?
Fable 5 acts as a "head chef": it reads the goal, plans the steps, delegates the mechanical work to cheaper models, and synthesizes the results — instead of doing all the work itself. You pay Fable's premium rate only for planning and judgment.
Why not just use Fable 5 for everything?
Cost. Fable 5's output costs five times Sonnet 5's and ten times Haiku 4.5's per token. Most real work (boilerplate, tests, formatting) is mechanical and doesn't need frontier intelligence, so running it on Fable wastes money without improving quality.
What is the effort parameter and how does it help?
Anthropic's effort parameter controls how many tokens a model spends, from low to max. Running your orchestrator at high effort (good plans) and your workers at low effort (fast, cheap execution) is a second cost lever on top of model choice. Anthropic's docs even list "subagents" as a typical low-effort use case.
Which model should do the actual coding?
For routine, high-volume implementation, Sonnet 5 at low effort is ideal; for the simplest repetitive tasks, Haiku 4.5 is cheaper still. Reserve Opus 4.8 (at xhigh effort) for genuinely hard sub-problems, and keep Fable 5 on planning and integration.
How much can this actually save?
It depends on your ratio of thinking to mechanical work, but shifting the bulk of output tokens from the top tier to Sonnet or Haiku can cut output costs by 70–80% on a typical feature. Prompt caching (90% off cache hits) and the Batch API (50% off) can reduce it further.
When should I not use the orchestrator pattern?
For small, single-file tasks, the coordination overhead of subagents can cost more than it saves. Anthropic recommends starting with the simplest approach that works and adding orchestration only when a simpler setup starts to struggle.
