---
title: 'You Don''t Need a Bigger Claude Plan (You Need Subagents)'
source: 'https://www.youtube.com/watch?v=NRTBSmzXXoY'
video_id: 'NRTBSmzXXoY'
date: 2026-09-21
duration_sec: 448
channel: 'Brad Bonanno | AI Automation'
---

# You Don't Need a Bigger Claude Plan (You Need Subagents)

> Source: [You Don't Need a Bigger Claude Plan (You Need Subagents)](https://www.youtube.com/watch?v=NRTBSmzXXoY)

## Summary

Learn how to maximize Fable usage in Claude Code by delegating grunt work to cheaper sub-agents. The video covers both built-in and custom sub-agents, plus a personal workflow for delegation.

### Key Points

- **Usage limit problem** [00:00] — Fable usage limits evaporate quickly when used for everything; sub-agents help extend the limit.
- **Fable overqualified for simpler tasks** [00:32] — Fable is overly capable for simple, token-heavy tasks like file reads; cheaper models should handle those.
- **Sub-agents explained** [00:59] — Sub-agents are separate AI instances that Claude instructs, run in their own context, and return results; Sonnet uses 1/5 the usage.
- **Default Explore agent** [01:34] — Explore is read-only, finds files without burning tokens, can run on Haiku.
- **General Purpose Agent** [01:57] — Can do most coding tasks; model choice (Opus, Sonnet, Haiku) can be set per agent.
- **Routing rules** [02:12] — Prompt Claude to never use Fable for sub-agents and save rules in CLAUDE.md.
- **Custom sub-agents and thinking levels** [03:26] — Custom agents allow control over thinking level; higher levels cost more (Fable: 2.4x, Opus: 3x) for minimal score gains.
- **Creating custom sub-agents** [04:20] — Agents are markdown files in .chord/agents folder; can set model, effort, tools, and even color.
- **Recommended workflow** [04:48] — Use Explore (Sonnet 5 medium) → Research (Sonnet 5 medium) → Builder (Opus 5 medium) → Reviewer (Opus 5 medium) for projects.
- **Avoid overusing agents** [06:52] — For small changes, let Fable do it; starting agents can burn more tokens than the savings.

## Transcript

Most people don't know that you can stop hitting your Fable usage limit by giving Claude a team of agents. Because when you use Fable for everything, your usage limit evaporates in just a few pumps. But there's actually a way that you can use Fable 24-7, hit your usage limits less, and get the same great results.
But before I show you how, let me explain why we need it in the first place. The biggest problem with Fable 5.1 right now is that you can only spend up to half of your weekly usage limit on it. And if you hit that limit early, you're waiting days for a reset or even worse, handing over more cash for usage credits.
But what most people don't understand is that Fable is actually overqualified for 99% of the work that you're using it for. Because the tasks that are draining your usage limit aren't complicated, they're just token heavy.
Things like reading files, making edits and changes can be done by smaller cheaper models, while you save Fable for planning, directing and orchestrating that you need it for. So when you tell Fable to do all of that grunt work, you're essentially paying expert-level rates for intern-level work.
In Claude code, sub-agents let you save your Fable limit for the work that needs it, while smaller, cheaper models handle the grunt work. A sub-agent is just another AI that Claude can give a specific job to. Claude sends it the instructions, it does the work in its own separate conversation, then brings the result back.
So Fable can stay in charge without having to do every step itself. The reason this saves your usage limit is because you can have that agent run on a different model, like Sonnet, which uses one-fifth the amount of usage. And you don't need to install or build anything yourself to get started saving tokens, because Chord Code already ships with two default sub-agents that you can start using today.
The first is the Explore agent. It's Fable's eyes and ears. It's fast, read-only, and optimized for finding files in your projects so Fable doesn't have to search through them all and burn tokens. Because the agent only searches and reports the location of files you can use a tiny model like Haiku Then for everything else there a General Purpose Agent This agent has all all the same capabilities as your regular Chord code so it a workhorse for just about anything You
can print it at research, building or reviewing and when Chord starts one it can choose which model that agent uses. So it can use Fable, Opus, Sonnet or Haiku. You can keep Fable selected in your main conversation and ask it to do something like this. When building out this project use
sub-agents. Use Opus or Sonnet appropriately. Never use Fable for any sub-agent. I'm starting one conversation with Fable but it can hand the work it's overqualified for to another model. If you don't want to type that out every time, ask Claude to save this routing rule in your project's
Claude.nd. That way Claude always knows how I want the work divided whether I start a new session or I'm continuing what I'm in. Just by adding a few lines to your Claude.nd you'll already see a huge difference in how far your Fable limit goes every week. We need to add one more thing to our Claude.nd
but before we get to that, if you want to build an AI operating system that runs your business and 10x's your productivity with AI, that's what we'll do in my next Founder OS Bootcamp. I'll hand over the exact setup and my AI playbook and teach you to adapt them to your business.
Join the waitlist below to get first access. The thing is, because these sub-agents use smaller models and don't see the conversation we've already had with Fable, we need to give them clear briefs to make sure that they stay on track. So to make sure that Fable briefs the agents properly every time, I also add this into my call.md.
It tells my lead agent, Fable, to set a clear goal, scope, context, and return format for the sub-agent. But so far, we've only scratched the surface of how you can use sub-agents to save your usage in Cord Code. The real unlock is creating your own custom sub-agent.
With default agents, we can control the model, but we can't control the level of thinking that the agent works with, which is just as important as the model. And changing the thinking level is where you can find even more savings because the same model can cost vastly different amounts depending on which level of thinking it using Look at Fable here Going from medium to max takes its score from 49 to 53 on the artificial analysis benchmark but costs almost two and a half times as much
Opus goes from 45 to 51 for almost three times the cost. So the extra thinking does help, but the cost climbs much faster than the score. Those extra points might not offer a difficult job, but if your sub-agent can already finish its task reliably on medium, you're spending more without necessarily
getting results that you need. That's where custom sub-agents come in because in custom sub-agents we can control the thinking level directly and creating one is pretty simple. Each agent is just a markdown file. You can ask Chord to write the whole thing for you. They live in your .chord
folder under a sub-folder called agents. The description tells Chord when to call it, the model and effort control what you're asking it to run on and the tools control what it can do. You can even change the color of your sub-agents so they're easier to recognize when they're running
And because they're totally customizable, you can build out your own agent team for every task in your workflow using the right model for the right job. There are three essential custom agents that I use daily. Each of these agents handles a discrete area of my work in code code.
I start the workflow with the Explorer agent, which is already built in using Sonnet 5. It figures out what's going on in the project and reports back to Fable, so Fable knows what we're working with before we've decided what needs to change.
From there, Sable calls on SIRS custom sub-agent, Research, to check documentation and any outside information it needs for the project. I run this also on Sonnet 5 Medium. Sable has already defined what it needs to find, so the agent can focus on that search and bring back a short answer with the source links.
And if it can't verify something, it reports that back as well, so Sable knows what's still missing. I give it access to search for web and read relevant pages, and once Sable has those findings, it can finish the brief and call the next agent, which is Builder.
This agent actually changes files in the project Table plans and orchestrates based on the explorer and research agents then hangs the implementation over to Builder I run this on Opus 5 at Medium Once Fable has made the bigger decisions and defined a clear brief Opus can focus on implementing it and Medium keeps the thinking cost down while staying very capable
Give it the same access as your regular code agent, so it can make changes and run tests completely by itself. And once Builder reports back, Fable calls the third agent, which is Reviewer, to check what actually resulted and how that compares to what the brief was.
This runs on Opus 5 medium. I want a fresh check of the work here because there can be problems that weren't obvious when Fable wrote the brief. It takes the original brief and the actual changes and then runs the relevant checks itself.
That way, Fable gets an independent check of the work with evidence of any problems it finds. Those findings can go back to a new Builder as specific fixes. and once the results meet the brief, Sable can accept it. So now, Fonit is handling the exploration and research,
Opus is handling the building and checking, and Sable is still playing and directing the whole thing. Once you've created these agents, add their names and jobs to the routing rules from earlier so Sable knows when to use each one. And if you want my exact system prompts for all three agents,
I'll put them in the guide in the description below so you can copy them into your own setup. But there's one last thing to keep in mind because you might be tempted to start using agents for absolutely everything. But there's actually a cost in speeding up these sub-agents as well.
So if you only need to make a minor change to something, Fable can do it itself. Because in those cases, starting a sub-agent and reviewing the output would burn more tokens than just having Fable handle it. Getting more agents running is only useful when the work they take off Fable's plate justifies the extra handoff cost.
And the point of all of this is to build a setup that you own and takes real work off your plate. If you want to build that with me, join my next FounderOS Bootcamp. I'll hand over the exact setup and playbooks and teach you to adapt them to your business.
Join the waitlist below and if this was useful, hit subscribe. Thanks for watching.