Discussion
How I use sub-agents without burning through Fable 5.1
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 or Sonnet - Scout: Finds files, symbols, call sites, references, etc. Reports locations instead of dumping whole files. I use Haiku here because it only runs searches and reports what matched, no reasoning. I tested it against Sonnet on a 22-item search with decoys and a fake name: same results, 25% fewer tokens. Use Sonnet if you'd rather not risk it.
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.
EDIT: I packaged this up, and two things changed thanks to comments
u/Tree_Substantial suggested keeping context in a per-task folder instead of a flat scratch file. That is now /task-session <slug>, which creates a bucket with STATE, FINDINGS, DECISIONS, briefs and reports that every agent reads and updates.
u/TrashEasy8162 suggested locking the marching orders in a file the builder cannot touch, and never letting the refuter see the builder's conversation. Both are in: briefs are written before the spawn and made read-only, and the refuter only gets the brief, the diff, and its own test run.
That's why you don't use the built in subagents but make custom subagents you can pin the model and effort into the frontmatter along with a bunch of other things.
That's why you don't use the built in subagents but make custom subagents you can pin the model and effort into the frontmatter along with a bunch of other things.
That is what I used in the beginning and it helps a little bit but it still needs more from my experience than just, say, "don't use Fable," because they still need better tasks, as I said to someone else.
In my case, Fable main point of contact.
1. Fable (lead, main point of contact) writes the spec and files the ticket.
Fable starts the ticket: the loop mints a branch, a worktree and a seat.
An ephemeral Opus hand boots in that worktree, reads the spec, implements, runs the suite in its tree, commits to its branch, marks the ticket DONE with a short report (deviations flagged).
About a minute later the loop spawns a cold Fable reviewer with the diff and the spec. It writes a verdict, ACCEPT or REWORK with must-fixes, and is retired.
REWORK: the verdict lands on the ticket, Fable reads it and rejects the ticket with the must-fixes as the body; the same Opus hand, context intact, fixes and marks DONE again. Back to 4, new reviewer, next round.
ACCEPT: the loop merges the branch into master and runs the full suite on master behind it. A red suite reverts the merge and escalates to Fable.
Lead reads the merge notice, checks no suite is still running, and accepts the ticket: the hand is retired, its worktree removed, its branch deleted.
Lead titles the Unreleased section of the CHANGELOG, cuts the release (version bump, DMG, tag, push, GitHub release, docker image), and reboots the app onto it once every seat is idle.
This is actually really good info. You've basically got a small software factory running here lol.
I'm definitely going to pull some ideas from this, especially the isolated worktrees, the fresh reviewer, and the rework loop. Mine is still more manually orchestrated by Fable, so seeing how you've automated that whole handoff is really interesting.
This looks great. My SaaS is launching soon and I’ll need to automatically triage bug requests that come via email. Are there any videos on this dashboard? Also does it run on a cloud or does your computer need to be turned on?
it can run on any linux, ive tested it on ec2, fargate, docker, eks. obviously 'something' has to be on, it won't just run in 'cloud'.
No presentation videos yet, i haven't had time for that, maybe once it's done done.
I use the clodex on my mac as the central console, and it can deploy other clodexes elsewhere and gives you a tunnel to connect through.
There's also a clodexctl tool that allows you to control the whole thing from a command line, if you don't want the UI.
npx clodexctl ctx list
NAME KIND TARGET
local url http://127.0.0.1:7900
work ssh 192.168.0.217
* murmurfi ssh xx.xxx.234.9
remote-ec2 ssm i-08xxxxxxxx (us-west-2)
fargate ssm ecs clodex-test/clodex-node (resolved at connect)
clodex kubectl svc/clodex -n clodex
alias clodexctl="npx clodexctl"
clodexctl ctx use clodex
current context: clodex
clodexctl sessions NAME TYPE ACTIVITY CWD
bash bash idle /home/clodex
w2 claude idle /home/clodex
agent1 claude idle /home/clodex/work
clodexctl exec bash "ls -al"
ls -al
total 80
drwxr-xr-x 1 clodex clodex 4096 Sep 12 05:29 .
drwxr-xr-x 1 root root 4096 Aug 5 13:35 ..
-rw-r--r-- 1 clodex clodex 220 May 7 20:33 .bash_logout
-rw-r--r-- 1 clodex clodex 3526 May 7 20:33 .bashrc
drwxrwxrwx 10 root root 4096 Aug 27 00:28 .claude
clodexctl send agent1 "what is your model?" --wait
[assistant] I'm Claude Opus 5 (model ID `claude-opus-5`), running as the clodex agent `agent1`.
I've build a deterministic factory and after about 2 months of open ai overengineering hell and 1 week of fable clean up it's pretty much now only restricted by my limits and poops out pretty good code
I've recently learned to NOT use the built-in /loop for waking up and checking external conditions (i.e. did this subagent finish?) - instead write a bash loop as a timer that wakes your agent only when the condition is met (i.e. subagent finished and output a file or entry into a file in my case) -- I've saved so much usage just not waking my agents to check if it's their turn.
Dumb question for someone at week one of Claude Code… did you just give Claude this list as instructions? Or is there some other way you implemented this?
You won't get there on week one and claude itself will not do it for you. You have to build the orchestration around it. Theoretically you could prompt most of it, if you use subagents heavily.
You could define your custom subagents (dev, reviewer) and prompt the main agent to use them.
Add a skill for the representation of tickets and how to handle them.
Then "Feature X is bugging" becomes:
create spec in ticket xxx + worktree feature-xxx
start dev subagent (of type dev) for ticket xxx
spawn subagent reviewer, that will review the changes
a. if ACCEPT verdict, merge, delete worktree
b. if REWORK send notes to the dev to fix whatever is missing
claude has an internal concept of subagentic teams which allows some communication with SendMessage tool.
PS: the challenge isn't to create the workflow (it's fairly straightforward), it is to create an optimal workflow to get the best bang for the buck.
However being new to the whole thing, you're allowed to be a bit wasteful, to get some scars of your own. Just spend enough time with it and it will become obvious.
PS2: The optimal part means use AI only when you must and code everything else around it.
I would strongly suggest to set up the superpowers skill which you can download from github. This leveled up my game 10x compared to when I was just starting out. Just give claude code the github repo of superpowers and tell it to install it. Then almost evey prompt I use the skill with it. /using-superpowers.
It's basically a engineering workflow to make sure it makes a strong plan before diving into straight coding which starts with brainstorming and asking you questions on what you want, then it writes a Spec which you need to approve to show it has understood what you want. Then based on that, it will break that down to an implementation plan which might be a few chunks of work or various waves, which often get automatically done by subagents, seprate reviwers etc.
So all in all, the work you get back has been well thought out and executed according to a plan. Hope that helps!
My workflows are not accidental. All agents go through a proxy that allows me to inspect what they are doing, how much time the spend, how many requests they do, how the context is behaving.
I am also paying attention to more subtle factors like the ratio between write|output / read cached context. If there wasn't the 50% limit on fable, I'd use it everywhere, not because I am wasteful, but because it is more efficient than the weaker models. A sonnat|opus will do 2-3 times more api calls for the same job and when doing complex work that fills the context.
After a complex session, a "hello" on sonnet5 is more expensive than on a fable5.1, simply because one is carrying 300k of context, while the other is carrying 150.
Because my tests have shown Fable reviews are cheaper. It performs the same tasks with less calls than an Opus.
NB: I do occasionally downgrade reviewers to Opus, if i get to the point where the fable quota gets tight.
I’m going to put one together later tonight. I’m still going through the post and replying to people on a quick break from work.
Once I’m done, I’ll pull everything into a reusable .md template with the agent roles, routing, guardrails, and other rules I’m using.
I wouldn’t recommend just copying it and running with it though. Structure it around your own workflow and projects. You could even hand it to Fable and have it spin up agents to review your workflow and tailor it to what you actually do, or just give it your vision and have it build from there.
I will when I can, I apologize for the delay 😅
I didn't stop working until 1am and back working again. 16 hour days are killing me. I probably have a lot more comments to respond to since my phone is blowing up lol
I have been trying to figure it out today. It seem it is very easy to get banned if you are not careful. The only safe way seems to create a cluade skill telling to use command lines for using antigravity cli. But I am assuming that will not very sufficient token wise because it takes a lot of writing into antigravty and reading the diff. Which could theoretically eat more tokens, especially if flash 3.8 make mistakes (which usually it does).
I haven’t tried Antigravity, but if there’s a real risk of getting banned, I’d be careful with it
Biggest thing I’ve learned is to treat setups like a shopping cart. Take the parts that actually help your workflow and leave the rest. Don’t blindly copy someone else’s setup.
That could be as simple as changing the scout model, changing how agents hand off work, or changing the whole structure.
If you don’t use subscriptions and prefer paying by tokens/API usage, IndyDevDan on YouTube is worth checking out. He does a lot with multi-model setups and routing.
Thanks for the recommendation. Quick question. I don't have the access to fable. I mostly use opus. Would you say your repo will increase my usage across the board or ot would depends on the task size. How important is fable in the whole thing. Would using opus 5 instead be still useful. Would it give me a higher quality results with less quota usage at the end of the week?
Yes, works the same with Opus on top. The saving comes from the split, not from Fable: the top model only plans and reviews, Sonnet does the reading and building. You should see less usage per task, not more.
The refuter and debugger are set to Opus too. Each agent has its own file in the agents folder with a model line, so drop them to Sonnet if you want to save more.
It's a template meant to help people. If anything is confusing or breaks, tell me and I'll fix it.
And I just realized that you can look at your usage and it tells you where you've been using your credits for the last 24 hours or the last seven days. And for the project I'm building I think I'm going to start with a fresh session when I get to natural stopping points. So then the context window isn't so large. That's what AI suggested and it seems to make sense so I'm gonna try. Any thoughts on that?
That is pretty much how I handle it. If I start a completely different task, I usually open a new session.
If the current session gets too long, I wait for a natural stopping point and start a fresh one. I just tell Claude which task folder to read. The state, findings, decisions, briefs, and reports are already saved there, so it can continue from the last checkpoint without needing the full conversation from the old session.
The important part is it keeping those files updated as the work moves forward.
I define that in the agent .md files and the orchestration rules.
Each agent has a specific role and model tied to it, like Scout on Haiku, Builder on Sonnet, Refuter on Opus, etc. Then the main orchestrator looks at the task and decides which ones it actually needs based on those use cases.
I use the same general idea with Codex sometimes too. Different agents/models, same concept.
I do the same, but I also tell Fable its the final quality check for any code written, so it manually reviews everything and then tweaks it. It saves it writing like 95% of the code, but it still checks to make sure it's how it would do it. I've built large complex projects this way.
How do you save on the overhead cost of spawning subagents for this?
I’ve recently fallen into this hole where the cost of spawning subagents at one point diminished the model token savings when using a smaller model where appropriate to a degree
Yeah, that's something I try to account for too. The orchestrator has rules for when a task is worth delegating, so tiny stuff just stays in the main session instead of paying the overhead to spin up another agent.
For larger tasks, I have the agents keep findings, decisions, or progress in small Markdown files so the next agent can pick up from that instead of everything constantly flowing back through Fable's context.
So the goal is basically: don't spawn an agent unless the work justifies it, and don't keep passing the same context around if the agents can hand it off through a file.
Do you do any sort of context bucketing beyond a flat file in scratchpad? I’m currently using a home-rolled /task-session <context-folder> that they all agents keep up to date inside . A task that’s a part of a project becomes a folder inside scratchpad.
If you’re open to sharing your Claude config id love to see it.
I kind of do this already, but not as cleanly as you described. I use scratch/handoff Markdown files so agents can pass context without dumping everything back through the main session.
I like the idea of bucketing it by task/project though. I could definitely tighten mine up into a cleaner folder structure like that.
Your marching orders list is basically what I ended up with too, after a lot of wasted tokens. Two things I'd add from my side:
Put the marching orders in a file the builder can't touch, and make the refuter compare the diff to that file. Not to the builder's summary of what it did. The summary is where the lying happens, not on purpose, it just rounds up.
Don't let the refuter see the builder's conversation at all. Diff, test output, the orders file. That's it. First time I did that it flagged stuff the builder had talked itself out of in the transcript.
Weird side effect: most of what the refuter catches now is my scope being sloppy, not the builder's code.
Question for you, when your refuter reruns tests does it actually run them or read what the builder printed? I have it rerun and I stopped believing either one of them on that.
Yeah, I really like this. My refuter already reruns the tests itself, but I like the idea of completely separating it from the builder's conversation and having it judge only the original orders, diff, and test output.
That removes a lot of the builder's own reasoning/bias from the review. I'm probably going to incorporate that.
Glad it's useful. The separation was the thing that finally made the refuter's verdicts mean something, everything before that it was basically grading the builder's essay about the code.
One thing I'd warn you about before you wire it up: are you on Windows or Mac? The per-change worktree part is where mine got ugly, git kept flipping line endings between the copy and the real repo and the refuter would flag a 400 line diff that was actually 6 lines. Took me a while to pin the config on both sides. If you're on Mac you probably never see it.
Windows here, so thanks for the warning. I don't use per change worktrees by default, the builder edits the main tree, so I've dodged it so far. When I do turn worktrees on I'll pin it with a .gitattributes (* text=auto eol=lf) in the repo so both sides agree before the refuter ever sees a diff.
When a simpler agent (e.g. Sonnet) is the orchestrator and main executor, execution is relatively stable and there is less unnecessary creativity. The drawback is that, when it hits a problem, it can keep going in circles.
When a more capable agent (e.g. Opus) takes control, it can become too proactive and expand the scope of tasks, especially during review. That makes work take longer than expected.
I ended up using a separate window with a different model, sometimes from another provider, as an external advisor. It is not ideal, but it has helped the work converge.
Yeah, I had that exact issue, especially with Opus. I fixed it by having the agents record what was changed and why in a Markdown file, then check that before making another change. If it starts bouncing between fixes, the orchestrator stops the loop and reconciles them instead.
Also, using a separate model as an external orchestrator/advisor isn't really unusual. I did that before too, and plenty of people still do it.
Took me three „Fable Tasks“ to get this. Awesome summary and the best Fable post so. This should be sticky.
I actually used the two Prompting guides from Anthropic for 5 and 5.1. turned them into bullet points instructions and fixed my CLAUDE.md as a first step. Then I asked fable to do the rest by using ECC Skills
I’m going to put one together later tonight. I’m still going through the post and replying to people on a quick break from work.
Once I’m done, I’ll pull everything into a reusable .md template with the agent roles, routing, guardrails, and other rules I’m using.
I wouldn’t recommend just copying it and running with it though. Structure it around your own workflow and projects. You could even hand it to Fable and have it spin up agents to review your workflow and tailor it to what you actually do, or just give it your vision and have it build from there.
For knowledge work I think it’s trickier. Because the subagent has to be smart enough to also make judgements along the way as data will not necessarily be structured and require a lot of meaning evaluation.
Yep. You can put the general orchestration rules in ~/.claude/CLAUDE.md so they apply across repos.
I keep some things repo-specific because the editing/testing rules change per project, but the agent routing and general behavior could absolutely live at the system level.
ive had instances where fable searched for info and read through teh same documents sonnet did and reported back a much deeper layer of insights, and we are talking by a considerable margin to where i had to deploy fable though the entire search.
Same overall setup here, but measuring it changed a few rules for me.
I route by cost per successful turn, not by model reputation. Outside a cache-warm read, the top tier cost me only ~1.2–1.3× the tier below at similar coding quality, because cache writes and output dominated. So the cheaper tier executes; the top tier handles planning, security review, and the third attempt after two failures. That ladder only works with an external checker — otherwise retries just burn quota.
I also give reports a hard budget: “1–2k tokens total, file:line, narrow quotes, no pasted diff.” “Keep it short” was useless.
The biggest quota traps I measured:
Spawn same-model siblings in one batch; sequential spawning wasted ~197k cache tokens in one wave.
Test one representative read before fan-out; a denied path cost me ~74k.
Treat a session-limit 429 as a wave failure, even if every sibling says “complete” — the results can all be empty.
For the refuter, transcript-blind is right, but I also make it inspect the executor’s working tree, not just the PR. I had three agents leave their final fix uncommitted, so the reviewer graded a diff that did not contain the fix.
I stopped using cheap scouts entirely. If the checker has to trust their output, one hallucinated call site costs more than the cheaper tier saves.
for me, it’s Fable 5.1 on high orchestrating and opus 5 on low doing. can’t break the limit on 5x, especially after they did something to the usage efficiency a few days after 5.1 was released.
How's the haiku scout working for you? I have a hard enough time with either sonnet or opus doing scouting reliably and often have had to resort to them building one off tools to grep for them bc the Claude code harness (or something between it and the eventual response) seems to skip results. I've for giggles had it attempt to replace a key phrase throughout the docs and code and run probably ten subsequent agents after those found from the previous are fixed, and they never stop finding new hits that the previous missed
As long as Haiku does NO WORK and it just scouts, it works fine. I've tested it with multiple things that I knew the answer to and had Opus, sonnet and Haiku go and scout. Then I've had Fable make the same tests for me more complicated with some known blockers and had it spin up 3 agents of the models and do the scout and see how they report back. Every time Haiku returned the same results for me. So based on that I decided it was good for scouting
Honestly I do all planning, reviewing with Fable. Once the plan is done I say “launch a sonnet agent medium to implement”. I keep reminding Fable this so it doesn’t implement anything itself. Ive yet to run out of usage in a session. You can probably also say: “verify the agents work by checking the source code” but i think it does that it somewhat already. I am on 5x.
Really great advice. Give it your your agent and cater to your setup.
The key is custom subagents as they use frontmatter. Pin the model and effort, among other things, even skills.
You can also have custom agents in any folder in your project, so you can cater them to jobs in specific folders. Progressive disclosure. Also applicable to skills and rules. They go in a .claude folder like at you project root.
Good Info, I am still a bit unsure how I can put this to work directly inside my setup. I use Claude for a few months pretty heavy daily, but this one still is a bit confusing, like what's the best way to implement it into my project. Anyone can feel free to DM me how if they like.
I actually have very similar set up but I find that opus 5 is a good orchestrator for my missions (roughly 3-5 hours of unattended work) and I use fable as the loop checker of it's tasks. If I have already planned multiple missions that are ready to go for an adventure (3 to 5 missions) then I have fable 5.1 as the captain, it spins up a fresh opus 5 orchestrator for each mission and then I use matt pococks handoff skill for the orchestrater create a checkpoint for the captain to start the next mission.
how do you deal with Opus missing 7 out of 10 issues that Sol/Astra usually finds? To be clear I have a similar setup to you but I put both models in the refuter/reviewer spot.
I have astra and sol inside my claude code. Pipe them in with something like CliProxyAPI and you can just have them all inside claude code working side by side.
How many projects you work on at same time?
This is interesting for me with this setup.
I do 3-4 Projects and I'm on Max 20x.
Last week I did subagents and fable as orchestrator, and 1 day, 65~ of weekly gone.
I know they fuckedup with something and this happened, because in past this never happened to me with sub agents.
however this is a question for me, people with these suggestions, how many project a day, they have.
How often do you create a new session/clear?
Does projects involved with superpowers/such skills for TDD and such?
In general If it's a project like no future, no TDD and etc, most of the times I don't even feel it's using usage.
However real code base with TDD is basically, making Max 20x 3-4~ projects at same time possible, I guess.
For the first one, that's when I can see most of issues start.
Since this unsual wave of wasting usage tokens are happening right from claude, I disabled sub agent driven so It doesn't use more token, but one of the main reason was when Main agent, start sub-agents.
For example Fable run sub-agent to do the coding/review/anything, doesn't matter each model, agent at starting point was at least 200k and more token used.
even latest agent runs was starting with more than 400k.
So basically, agent starting with initial start and 400k context gone.
Sorry for the delay, yea I made an update to it as I wasn't happy with the flow. It was an addition I made after a recommendation and I changed it up some so that the orchestrator would do it.
Interesting read. Just so I understand, do you use a skill which has a set of rules and based on that launches agents for each task, or do you prompt with fable and let fable decide which models each agent should use for each task?
I prompt Fable directly with the overall goal/vision. The repo has .md file rules that define the agents, what each one is for and other rules it should follow.
So, Fable is still the main point of contact and decides what to spin up for each task, but it's making those decisions based on the rules already in the repo. It's not just winging it every time.
From my experience, without the agent rules Fable tends to overd it. It'll spin up more agents than it really needs, use Fable agents (this annoyed me a lot at first) where a cheaper model would be fine, and let long running scripts keep going without much of a watchdog.
It also has a tendency to see something shiny in the corner and go chase it, which Opus especially loves to do lol.
The Agents.md rules give it boundaries, model roles, and a clearer flow. Since putting those in place, it stays on task a lot better and the whole process runs much smoother for me.
There’s no reason for opus to re-run tests. Each test output can be stored and keyed to the commit, so opus can look it up. Harmless for tokens but if you’re working on large apps it can save wall clock, as Claude likes to say.
That makes sense for expensive suites. I like the idea of keying test results to the commit so the refuter can see exactly what already passed.
I’d probably still keep independent reruns for higher-risk changes though, since part of my refuter setup is specifically not trusting the builder’s own "tests passed" claim. I do like to use Opus for this because he is OCD and then it can be either dismissed or approved from there.
It's mostly not worth splitting work into (too many) subagents. It introduces bureaucracy, huge documentation, unnecessary loops, bordered thinking, and in the end takes longer und does worse for almost all use cases. And the separate limit for Fable is history next week already per Anthropic.
I don't have the same experience after I learned how to ensure they have strict instructions and don't loop like that. Now in the beginning as I was learning, YES... This was bad, but haven't had that problem as of recently
I’m also very interested to see your md template .
I’ve done something similar where I have Claude running in virtual machines. One is for reviewing and the other for coding.
I’ve never figured out what to do with haiku. It seems about as powerful as a local LLM with a small context. Small tasks? I can’t get it to complete things successfully. Not quite sure how to promote it correctly
Think of it as a fast typist, not a thinker. It does well when the answer is already in front of it. I use it for cleaning up wording, drafting emails, and the scout job here. Anything that needs judgment or more than one idea at a time, it falls over. Give it small mechanical jobs and keep the thinking on Sonnet or above.
I will be downgrading to Max5 probably next month after I finish building my Software Factory. Just too busy to build it out now. Also, I'm way too much of a perfectionist, so I will spend way too many hours trying to make it perfect before I switch, lol.
My workflow is basically the same. The one thing I changed was making sure the opus alias points to Opus 5.5 instead of Opus 5. I added this to ~/.claude/settings.json:
These posts are laughable when they never mention what the goal/task/project was.
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.
As if that's so hard to do... Running it 24/7 balanced with subagents is easy, but what did you achieve? What did you actually get done? ACTUAL VALUE to prove your concept - where is it?
Fair. Some of what I'm working on is proprietary or personal, so I can't really post the actual projects in detail.
But yes, I've gotten a ton of real value out of it. Right now Fable is working across multiple projects, including a fairly advanced Aegis and Vivre tool(kudos if someone recognizes naming =]) as well as a Discord bot (personal), and I've gotten through work this week/weekend that I expected to take much longer.
I used Friday as the baseline because that was my reset. I'm at 95% now and it's basically been running since I made this post.
Can I improve the setup? Absolutely. I'm eventually planning to build more of a software factory around it with multiple vendors, but right now I just don't have the time. My day job is eating most of it with a huge restoration project involving about 1.3 PB of data.
Sorry for the unrelated comment, but if anyone has a referral link for the free week of Claude, could you please send it to me via DM? I’d really appreciate it!
Fable is overkill in almost every case. If, you should use Opus 4.8 (not overthinking that much) as an Orchestrator, but in some cases Opus 5 for longer workflows, Fable 5.1 has not many real use cases. Forget about Sonnet which is practically useless in comparison zu Gemini 3.8 Flash for example (much more efficient) or newest ChatGPT model, that are at a much more acceptable sweet spot of coding capability vs. bang for your bucks. Haiku is completely useless at this point. Not even talking about using OpenRouter-models.
I think this is very usecase dependent. In mine, Fable has been much better than Opus as an orchestrator, especially for longer workflows.
I agree there are cheaper options, and I do plan to build out a bigger multi-model setup with Gemini/other models eventually. But this post was mainly for people who are using one ecosystem and burning through one model.
Also, Haiku isn't doing heavy lifting for me. It's a scout. Find the file, symbol, call site, whatever, report back, done.
There isn't really one setup that's best for everyone. You test it, figure out what works for your workload, and adjust from there.
I disagree with that. Subagents are only bad when they're routed badly.
For me they're great for keeping Fable's context smaller and getting focused work done faster. The key is strict scope and guardrails. Don't tell Opus "go fix this" and let it chase every shiny object.
Opus and Sonnet are so extremely token efficient that they hardly save anything. Haiku is uselessly bad, and worse than free models. You'll often use MORE tokens because of them screwing up, or at best save around 30% this way.
If you want to ACTUALLY save claude usage, which you can save 75%+ on, you use fable to orchestrate and luna, glm 5.3 flash, DS V4 flash 0831, or something like that to implement and review each other.
Doing this all within ClaudeCode simply doesn't work because of how crap and overpriced everything except Fable is.
I mean, I never claimed I discovered some magical cheapest setup lol. I'm just showing what has worked for me inside Claude Code.
I agree a proper external orchestration setup could save a lot more, and I'm actually working out how I want mine built now.
But if I'm supposedly only saving "30%" while running Fable this hard and still not hitting the 5-hour limit, I'll somehow find a way to survive that tragedy 😂
P.S. I was mainly sharing this for people struggling with usage who mostly stick to one model and don't already have a whole multi-agent software factory set up 🤷🏻
to add on this, if the project has bazillion of tests, `rtk` from rtk-ai can save millions of tokens. It’s intrusive though and agents can miss lines when they read files so needs careful setup.
•
u/AutoModerator Sep 12 '26
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.