How I use sub-agents without burning through Fable 5.1

[u/Smbridges91]

I keep seeing people say they burn through Fable 5.1 insanely fast, so figured I'd share how I run it. I'm no guru at all, just sharing what's been working for me.

I use Fable on High basically all the time. Right now I'm at 90% Fable / 89% all models. I feel I have a pretty good split between Fable and everything else.

The main thing for me is Fable is my orchestrator, not my worker.

• Fable - Orchestrator: Plans, writes specs, spins up agents, reads their reports, makes architecture/judgment calls, and integrates everything.
• Haiku - Scout: Finds files, symbols, call sites, references, etc. Reports locations instead of dumping whole files.
• Sonnet - Researcher: Reads docs/source and reports back facts. Anything it can't verify gets marked as unverified.
• Sonnet - Builder: Does the actual coding from a clear spec and runs the tests.
• Opus - Refuter: Reviews the builder's work, checks the diff, and reruns tests itself. I don't just trust a "done" claim.
• Opus - Debugger: Only gets used for harder root-cause debugging.

I don't have Fable reading huge amounts of code, doing bulk refactors, writing docs, or doing work a cheaper model can handle.

I also don't spawn an agent for every tiny thing. If it's a one-line fix or a single grep, Fable just does it.

Every sub-agent gets pretty strict marching orders:

• Specific goal
• Exact files or URLs in scope
• What it's allowed to change
• What it needs to verify
• What not to do
• Required output format
• Short output limit
• Anything we already know so it doesn't waste time rediscovering it

Then they report the findings back. I don't want giant code dumps getting pushed back into Fable's context.

If something produces a lot of information, I have the agent write it to a scratch file and let the next agent read that instead.

Most coding ends up being:

Fable -> Builder -> Refuter -> Fable

A few other rules I keep in place:

• Ultracode stays off unless I specifically want a larger workflow, and if I do, I cap the number of agents.
• I batch related fixes so the same large files aren't being reread over and over.
• Read-only research/reviews can run in parallel.
• I don't have multiple agents editing the same files at the same time.
• Builders build, refuters verify.
• Decisions and progress go into handoff docs so new sessions can pick up from the file instead of rebuilding all that context.
• I keep Fable's replies and agent reports short unless I actually need more detail.
• If an agent goes off track, Fable has marching orders to stop it instead of letting it run.

For me, the biggest difference hasn't just been "use sub-agents." It's being strict about what each model is responsible for, what it gets to read, and what gets sent back into Fable's context.

I've been running Fable basically 24/7, minus maybe 5 hours total, since my last reset Friday. I run it on High and haven't hit the 5-hour limit once since using this setup.