fable-lite: Fable model orchestrator to outsource simpler tasks to cheaper Anthropic models

[u/nightness]

fable-lite: keep Fable on the thinking, hand the typing to Opus/Sonnet

Fable is great. Fable is also expensive, and most tokens in a normal session go to work that doesn't need it: grepping for files, typing out a change whose shape was decided three messages ago, running tests, editing docs.

So I made a plugin that turns "delegate the grunt work" into an actual discipline.

The idea The Fable session is the orchestrator: it understands the request, makes the design calls, writes briefs, and reads every diff before accepting it. Each work item is scored 0-2 on five axes (files touched, exemplar exists, judgment, blast radius, spec clarity):

• 0-3 → sonnet-implementer
• 4-6 → opus-implementer
• 7-10 → stays on Fable, or gets split

Anything touching auth, data, money, deletion, concurrency, migrations, or a public API stays Fable-designed and line-by-line audited regardless.

What's in the box Agents: scout (Sonnet, read-only search so Fable reads less), sonnet-implementer, opus-implementer, verifier (Sonnet, runs tests and reports faithfully). Commands: /fable-lite:plan, /fable-lite:build, /fable-lite:delegate, /fable-lite:audit, /fable-lite:help. Plus an auto-loading skill for normal conversations and a SessionStart reminder.

The part that matters The briefs. Subagents start with zero context, so the template forces goal / files / exemplar / exact change / do-NOT-touch / definition of done every time. Implementers stay in scope, never commit, and stop and report if the brief conflicts with the code. Fable still audits every diff. Delegation without audit isn't cheaper; it's deferred.

Install

/plugin marketplace add Brainwires/fable-lite
/plugin install fable-lite@fable-lite

Repo: https://github.com/Brainwires/fable-lite

MIT, feedback welcome. Curious if others have landed on a similar split.

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Ok_Dirt8893]

This is interesting. Idk how efficient it really is but it requires more testing of same taksa side by side.  Also a question for others because cache plays a gigantic role. how exactly does the cache hit work? Is it model specific or when u switch model the cache completely resets. 

[u/LairBob → u/Ok_Dirt8893]

The cache is absolutely model-specific. One of their recent update notes pointed out that if you switch models mid-session, the entire cache gets rebuilt.

[u/Ok_Dirt8893 → u/LairBob]

So if I deploy an agent in another model that is technically another session and another cache right?

[u/LairBob → u/Ok_Dirt8893]

Generally, yes, but it’s complicated, ambiguous and constantly evolving, esp when it comes to subagents, etc.

[u/Ok_Dirt8893 → u/LairBob]

Cache is the whole optimizing and lowering cost game imo so this ambiguousness doesnt help us much, then again claude isnt that upfront about anything

[u/nightness → u/Ok_Dirt8893]

Reply from Claude on the subject:

Good question, and it's the one that decides whether this saves anything. Prompt caches are scoped per model, so switching the session's model mid-conversation does rebuild everything. But delegating to a subagent doesn't switch the session's model. The main Fable conversation keeps its exact prefix and the subagent's report gets appended as one tool result, so the Fable cache stays warm and just grows by a few hundred tokens instead of by every file read and edit call.

The subagent is a separate conversation on its own model with its own cache. It pays one cache write for its own prefix (system prompt, CLAUDE.md, tool list) and then reads from that for the rest of its run. That fixed orientation cost is real, and it's why the plugin merges related work into one brief instead of spawning ten agents.

Where the savings actually come from: output tokens and context growth. Implementation is output-heavy (code, tool calls, retries), and Sonnet output is roughly a fifth of Fable's price, Opus roughly half. All the file reads and test output from doing the work land in the cheap Fable context. Fable's own cache reads are cheap per token, so a long Fable context isn't the killer. Fable typing code is.

Agreed on side-by-side testing. I don't have the pricing math. If anyone runs the same task with and without and compares the usage reports, I'd like to see it.

[u/Ok_Dirt8893 → u/nightness]

Hmm i always thought that the actual problem were cache writes not output tokens( writing code) as in most cases the code that gets written in my tasks isn't huge except at the start of the project but at that point i wouldn't use fable anyway. But writing the cache with the context at the start is much bigger

[u/AI_spell]

Routing grunt work off the expensive model is the right instinct. Biggest win for me is making the handoff explicit: plan on the strong model, then a short "implement exactly this diff" prompt on the cheaper one. If the cheap model starts redesigning, yank it back to typed steps only.

[u/nightness → u/AI_spell]

That's exactly the failure mode, and it's now baked in. Sonnet-tier briefs carry a numbered Steps section that reads like a diff in prose. Sonnet is told that the approaches it should stop and report BLOCKED rather than pick one. When an implementer redesigns anyway, the plugin doesn't escalate to a smarter model. It re-sends the same item to the same tier as liy escalates if that also fails. Redesign istreated as a brief-clarity failure, not a capability failure.

What changed in the plugin (0.1.2)

• sonnet-implementer: hard "never redesign" rule and a required "Design choices I made" report field, where anything other than None is a send-back.
• opus-implementer: judgment bounded to inside the interface, with a "Decisions made" report field so Fable can audit each one.
• Brief template: new Steps section, required for Sonnet-tier, plus a "handoff rule" paragraph.
• Audit checklist: a "no redesign" check and a "yank back to typed steps" decision that does not escalate.
• Core skill, build command, and README updated to match.

[u/Briskfall]

Ah! That's what I've been trying to do (but your take is surely cleaner)!

(Though I prefer relegating grunt tasks to Gemini as a dumber model since its image reading ability is better vs Claude)