# Saving money with Fable 5

Source: https://fable-5-news.pages.dev/savings.html
Unofficial field notes from two hands-on evals (2026-07-06); not benchmarks; not affiliated with Anthropic.
All numbers come from two eval reports: a solo-vs-delegation orchestration test and a four-model coding-subagent shootout.
Sample sizes are small throughout (n=1-3 per cell).

## Headline numbers

- Flat delegation cut Claude-plan burn to roughly 1/3 of solo (the agentic grind lands on Z.AI/OpenAI plans instead).
- Opus-as-flat-manager cost $2.13 in Claude usage - cheaper than Opus doing the work solo ($4.69-$5.23).
- Solo was ~40% faster than flat delegation at this task size (614s vs 1044s avg) and ~55% faster than nested.

## The three setups

- Solo: one strong Claude model (Opus 4.8) does everything itself - reads the spec, writes the code, runs tests, commits.
- Flat delegation: a Claude manager (Fable 5 or Opus 4.8) splits the task and hands pieces directly to cheaper workers, then integrates and verifies. One hop.
- Nested delegation: Fable 5 delegates to Opus middle managers, who delegate to workers. Two hops between spec and code.

Workers throughout: GPT 5.5 (via codex, on a ChatGPT plan) and GLM 5.2 (via opencode, on a Z.AI plan) - their token grind lands on those subscriptions, not the Claude plan.

Headline comparison: the same feature, managed through the same worker pool, cost $6.42 in Claude spend with Fable 5 as manager vs $2.13 with Opus as manager (-67%), with every quality check still passing (n=1 for the Opus-manager cell).

## Five ways to spend less

1. Don't make Fable 5 your manager - Opus is cheaper at the same job.
   Per 1k output tokens (including input and cache costs), Opus-as-manager ran $0.12-0.13 while Fable-at-high-effort ran $0.19-0.25.
   Swapping the flat manager from Fable to Opus dropped management cost from $6.08-$6.76 to $2.13 with the same delegation shape and all acceptance checks passing.
   The flat-vs-solo dollar penalty was entirely "Fable tax," not delegation overhead.
2. Protecting your Claude plan? Delegate flat.
   Flat delegation cut Claude-plan throughput to roughly a third of solo (~30k output tokens vs ~39k, ~2.3M cache reads vs ~6.1M) by landing the workers' 1.1-1.6M uncached input plus tool loops on the Z.AI and OpenAI plans.
   Cost: about 50-70% more wall clock at this task size.
3. Optimizing for speed at small task sizes? Go solo.
   One strong model alone was ~40% faster than flat and ~55% faster than nested, despite the delegated shapes running workers concurrently.
   Prompt-writing, verification, and integration overhead exceeded the parallelism win; the break-even for delegation sits above this task's size.
4. Skip nested orchestration entirely.
   Nested won under no objective measured: most expensive ($7.87), slowest, 2.6x the management output tokens of flat, put the grind back on the Claude plan, and produced the one verified second-hop defect (a worker with no project context hardcoded its sandbox path into committed test code).
   Also operationally fragile. n=1.
5. Route subagent work by regime, not by one "best model."
   Opus 4.8: only reliable end-to-end executor (9/9 tests green, 9/9 commits, fastest edit median).
   GPT 5.5: best all-round on judged quality and code review, but its sandbox physically can't commit in git worktrees - the orchestrator must commit for it.
   GLM 5.2: won the API-design taste task 3/3 against pricier models, with one catastrophic lazy run in nine - verify its output.

## So where does Fable 5 fit?

In these two evals, Fable 5 never won a measured category - but it was only ever tested as a manager, the one place its extra capability can't pay for itself.
Routing work doesn't need the smartest model; it needs a cheap, reliable one.
At a glance:

- The task is genuinely hard (deep reasoning, huge context, everything else failed) -> Fable 5 working alone. Untested in these evals; they never ran Fable solo.
- Normal task, you want it fast -> Opus 4.8 working alone (fastest measured shape at this task size).
- Normal task, protect your Claude plan -> Opus manages cheap workers (cheapest Claude spend measured, $2.13; the grind lands on other plans).
- Never -> Fable as manager, or managers-of-managers (won nothing in either eval).

## Evidence 1: solo vs flat vs nested

Method: one real feature (a preset pack/unpack command plus UI) built under each orchestration shape, from frozen prompts in isolated git worktrees, with identical acceptance checks (test suite, typecheck, byte-identical CLI round trip, UI render check).
Every cell passed all four.
A blind GPT 5.5 judge scored each diff against the spec.
Solo ran twice, Fable-managed flat twice, Opus-managed flat once, nested once.

| Cell | Wall clock | Claude cost (mgmt) | Workers | Fidelity (blind, 1-5) |
| --- | --- | --- | --- | --- |
| Solo (Opus, avg of 2) | 614s | $4.96 | none | 5 |
| Flat (Fable manager, avg of 2) | 1044s | $6.42 | 2 gpt + 2 glm | 4 |
| Flat (Opus manager, n=1) | 904s | $2.13 | 2 gpt + 2 glm | 4 |
| Nested (Fable -> Opus x2, n=1) | 1353s | $7.87 | 1 gpt + 6 glm | 4 |

"Claude cost" covers the management layer only; worker tokens rode flat Z.AI/OpenAI subscriptions, so this is not a total-system dollar claim.

Plan burn per cell (all Claude layers summed):

| Cell | Turns | Cache reads | Cache writes | Output tokens |
| --- | --- | --- | --- | --- |
| Solo (avg) | ~80 | ~6.1M | ~106k | ~39k |
| Flat, Fable mgr (avg) | ~44 | ~2.3M | ~158k | ~30k |
| Flat, Opus mgr | 31 | 1.2M | 90k | 22k |
| Nested | 26 | 4.6M | 268k | 76k |

Caveat: the "solo is higher fidelity" gap did not survive a code audit.
The blind judge scored solo 5/5 and every delegated run 4, but reading the diffs directly found the same two deviations (non-atomic unpack, no export-set selector) present in the solo runs too, just unflagged.
Every run, solo or delegated, skipped real atomicity; nothing was "lost in the delegation telephone game" except one verified nested-only defect.
Treat the fidelity gap as judge noise pending a re-judge.
Nested and the Opus-manager cell are n=1, and Opus ran at default effort vs Fable at high, so effort is conflated with model choice.

## Evidence 2: which worker for which job

Method: four models ran as coding subagents, each inside its own vendor's agent CLI - GLM 5.2 (opencode), GPT 5.5 (codex), Opus 4.8 (Claude CLI), Composer 2.5 (cursor-agent) - across four tasks: a treacherous test-runner migration, a fuzzy-spec feature, a code review with seven seeded bugs, and an API-design taste task.
Three runs per cell, frozen identical prompts, isolated worktrees pinned to fixed commits, blind scoring by two judges (Fable 5 and GPT 5.5).
This compares model+harness pairs, not pure models - which is how subagents are consumed in practice.

| Task | GLM 5.2 | GPT 5.5 | Opus 4.8 |
| --- | --- | --- | --- |
| Migration - judge median (1-5) | 3.00 | 4.00 | 3.67 |
| Migration - tests green | 2/3 | 2/3 | 3/3 |
| Fuzzy spec - judge | 4.08 | 4.17 | 3.54 |
| Review - recall of 7 seeded bugs | 4 | 5 | 4 |
| API taste - judge | 4.25 | 3.62 | 3.62 |
| Commits made | 7/9 | 0/9 (harness) | 9/9 |
| Median wall clock, edit tasks | 327s | 223s | 246s |

Judge score = mean of 3-4 rubric dimensions averaged over two judges.
GPT's 0/9 commits is a codex sandbox limitation (it can't write git metadata in worktrees), not model behavior.
All lanes ran on flat subscriptions, so the meaningful cost metric is plan burn - Opus produced 2.2-2.5x the output tokens of the others (thinking included), the main driver of its subscription burn.

Composer 2.5 also ran but was halted at half its runs when the Cursor plan hit its cap ($19.77 of $20) - too little data to rank.
What exists: it failed the migration in both attempts and never committed by choice, but posted the best single code-review run (6/7 bugs) and tied-best on taste, each at n=1.

Confounds: the Opus lane ran with contaminated context (the user's "shortest working diff wins" plugin hooks fired inside every cell; no other lane carried an equivalent directive; direction of bias unknowable).
The two judges disagreed systematically: the GPT 5.5 judge marked Opus-authored artifacts down 2-3 points in four separate sets.
Treat merged judge scores as approximate.