Fable 5 as Manager: The Delegate-to-Sonnet-5 Cost Pattern

Route Fable 5 to plan, delegate execution to Claude Sonnet 5, and stitch the result with a cheap 7B local model — that's the manager pattern that cuts an agentic-coding bill by 60-70% without a measurable drop in output quality. This piece breaks the routing, gives you the token-per-dollar math, and shows the hardware you actually need to run the local tail.

Who this pattern is for

You are past the toy-agent stage. You have a real agentic loop — Aider, Claude Code, Cursor's background agents, or your own harness — that reads a repo, plans an edit, executes it, runs tests, and iterates. That loop is chewing through 5-15 million tokens a day. Your monthly bill has grown from an amusing rounding error to a line-item on the P&L, and the team has started asking uncomfortable questions about why every git commit costs $0.30 in inference.

The bill grew because early agent harnesses ran everything through the same model. Fable 5, at the top of its tier, is not the cheapest tool for reformatting a JSON blob or extracting a stack trace — but the harness sent it there anyway, because the code path was uniform. The manager pattern is the fix: keep the expensive planner where it earns its rate, push execution to the mid-tier, and finish with a local finisher for the mechanical bits.

This is not novel research — it is the pattern that senior agent operators have been running quietly for a year while junior teams pay full freight. What is new in 2026 is that a $220 used RTX 3060 12GB is enough to run the finisher tier at home, so a solo builder can now replicate the ratio a well-tuned team runs. That is the pattern's second dividend.

Key takeaways

• Fable 5 as manager, Sonnet 5 as executor, 7B local model as finisher — three tiers, ~one-tenth the input cost of a Fable-only pipeline.
• The routing is straightforward: plans + reviews stay on Fable, edits + tests run on Sonnet, dead-simple mechanical work stays local.
• A used RTX 3060 12GB rig covers the finisher tier for ~$450 build cost; recoups vs a pure-cloud pipeline inside 2-4 months for a busy agentic-coding shop.
• The pattern only works if your harness understands per-step cost tiers — Aider, Claude Code, and MCP-aware clients already support this.
• Quality regression from a well-tuned three-tier pipeline vs Fable-only is small on real code — under 5% on task pass rate in community measurements.

What "manager pattern" means in practice

The manager pattern is a task-router: every prompt in your agent loop is routed to the cheapest tier that can reliably handle it. In a three-tier setup:

1. Manager (Fable 5) — reads the task description, decomposes into a plan, reviews executor output, decides when to stop iterating. High cost per call, low volume — maybe 5-15% of total tokens.
2. Executor (Claude Sonnet 5 or equivalent mid-tier) — takes a plan step, edits code, runs tests, reports back. Medium cost, medium volume — 60-80% of tokens.
3. Finisher (local 7B, e.g. Qwen 3 7B q5) — handles small mechanical prompts: reformat a diff, generate a commit message, extract a filename from a log, retry with a small tweak. Near-zero marginal cost — 15-30% of tokens.

The routing rule is not fancy: token-length + task-type. Anything under 500 tokens and clearly mechanical (no reasoning required, no repo-wide context) goes local. Anything requiring reading multiple files or writing code goes to the executor. Anything requiring planning or judgment goes to the manager. Community reference implementations exist for Aider's model-routing configuration and Claude Code's per-step model override.

Cost math on a real workload

The reference workload is a busy agentic-coding shop: 8 developers, 20-30 agent runs each per day, average 60K tokens per run — that is 12M tokens/day, ~360M/month. Pure-Fable pipeline pricing at rough current rates:

Blended blend for the manager pattern assumes ~10% of tokens on Fable, ~65% on Sonnet, ~25% local. Monthly the shop saves ~$4,500 — enough to fully amortize a small local rig fleet inside two months, and enough to pay for a mid-tier executor upgrade if you want it.

Solo builders don't hit the same volumes but the ratio holds. A hobbyist pushing 15M tokens/month on a pure-Fable pipeline runs about $270; the same volume on manager pattern runs about $80.

The RTX 3060 rig that runs the finisher

For the finisher tier a 7B model at q4/q5 is plenty. The MSI RTX 3060 Ventus 3X 12G fits a 7B at q5_K_M with room for 32K context and an idle backend running. Pair it with a Ryzen 7 5700X so the CPU can host tokenizer preprocessing and orchestration without waking the GPU. A Samsung 970 EVO Plus 250GB boot drive is more than enough — the 7B weights are ~4-5GB at q4/q5.

Community measurements from the llama.cpp benchmarks and per-model tables at artificialanalysis.ai put 7B q5 generation on the 3060 at roughly 45-60 tokens/sec at short context. That is faster than most humans read, which means the finisher never becomes a UX bottleneck.

If you already have a Gigabyte RTX 3060 Gaming OC 12G lying around from a gaming rig, use it — same chip, same throughput.

Routing table you can copy

When to skip the finisher tier

The three-tier pattern costs an extra day of harness setup. Skip it and go two-tier (Fable + Sonnet only) if any of these apply:

• Your total token bill is under $100/month. Not worth the wiring.
• Your agent loop is entirely one-shot user prompts, not autonomous iteration. Manual routing works fine.
• You have no local hardware. Renting a 3060 in the cloud for finisher work wipes out the savings.

For everyone else the three-tier pattern is the current best-practice cost-cutter, and getting to it does not require a rewrite — Aider, Claude Code, and MCP-aware clients already accept per-step model configuration.

Common pitfalls

• Sending finisher work to the manager. Look at your telemetry. If Fable 5 is handling 50% of your tokens by count and 90% by cost, your routing is broken. Prompts under 400 tokens with no code should almost never touch the top tier.
• Sending planning work to the finisher. A 7B local model does not decide the next agent step reliably; it will happily loop forever. Reserve local for the mechanical tail.
• Ignoring latency. The manager tier is slower per call. If your loop is user-facing and iterates many times, add a per-iteration budget so Fable doesn't get called on every micro-decision.
• Skipping local caching. Local KV-cache and prefix reuse make the finisher tier meaningfully faster; leave prefix caching off and you'll waste seconds every prompt.
• Not measuring quality. The pattern is only worthwhile if the executor's pass rate stays close to the manager's. Instrument your CI: if pass rate drops more than 5%, retrune the routing.

Sample harness configuration (Aider-style)

The routing rule in a typical Aider config looks like this, in pseudocode:

model_map:
 plan: fable-5
 edit: claude-sonnet-5
 review: fable-5
 utility: local://qwen-3-7b-q5

Aider's built-in --model and --weak-model flags cover most of this out of the box; the third tier is exposed through the local endpoint knob. Full instructions live in the Aider docs. Claude Code's equivalent is per-tool model override — same three-tier idea, different config surface.

Bottom line

If your agent loop is real work — not a demo — the manager pattern is the single biggest cost-and-quality lever available in 2026. Use Fable 5 for planning, Sonnet 5 for execution, and a local 7B for the mechanical tail. A used RTX 3060 12GB rig covers the local tier for under $500 and pays back inside a quarter for any serious workload.

Related guides

• Grok 4.5 Ranks #4 on GDPval: Cloud-vs-Local Math for 2026 — the wider cloud-vs-local decision.
• Gemini API Adds MCP + Background Execution: Build a Local Agent Host — hosting the agent loop itself.
• Best Budget Gaming CPU in 2026: 5 AM4 and Entry Picks Ranked — the AM4 CPU picks that pair with a 3060.

Citations and sources

• artificialanalysis.ai — Fable 5 tier comparison and per-token pricing
• Aider — official model-routing documentation
• TechPowerUp — RTX 3060 12 GB specification database

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.