{"slug": "how-to-use-the-advisor-executor-pattern-in-claude-code-to-extend-your-fable-5", "title": "How to Use the Advisor-Executor Pattern in Claude Code to Extend Your Fable 5 Limit", "summary": "Anthropic's Claude Code users can extend their Fable 5 token budget by using the advisor-executor pattern, which delegates high-level reasoning to Fable 5 and execution to Opus or Sonnet. This technique reportedly achieves 93% of the work at a fraction of the cost by reserving the premium model for planning only.", "body_md": "# How to Use the Advisor-Executor Pattern in Claude Code to Extend Your Fable 5 Limit\n\nUse Fable 5 as an advisor and Opus or Sonnet as executor to get 93% of the work done at a fraction of the token cost—with a real example.\n\n## The Token Budget Problem Every Claude Code Power User Hits\n\nIf you’ve been running Claude Code with Fable 5 (Anthropic’s most capable model tier) for anything serious — a large refactor, a multi-file feature build, a codebase audit — you’ve probably hit the wall. Fable 5 is extraordinarily capable, but its usage limits mean you burn through your allocation fast when it’s both planning *and* executing every task.\n\nThe fix is a two-model setup called the advisor-executor pattern. It uses Fable 5 only for high-level reasoning — figuring out *what* to do and *how* to approach it — then hands execution off to Opus or Sonnet, which are faster, cheaper, and perfectly capable of following a clear plan. The result: roughly 93% of the work gets done at a fraction of the token cost, and your Fable 5 allocation stretches across far more tasks.\n\nThis guide walks through the pattern, why it works, how to set it up in Claude Code, and a concrete example you can replicate today.\n\n## What the Advisor-Executor Pattern Actually Is\n\nThe advisor-executor pattern is a multi-agent optimization technique where you split reasoning and execution across two different models rather than routing everything through one.\n\nHere’s the core idea:\n\n**The advisor**(Fable 5) does the thinking. It analyzes the problem, proposes a structured plan, flags edge cases, and produces a precise specification for what needs to happen.**The executor**(Opus or Sonnet) does the work. It receives that specification and executes it — writing code, modifying files, running commands — without needing to re-derive the strategy from scratch.\n\n##\nPlans first.\n*Then code.*\n\nRemy writes the spec, manages the build, and ships the app.\n\nThis matters because the reasoning phase typically consumes a disproportionate share of tokens when a capable model does it. Fable 5 is expensive to run precisely because it’s doing heavy reasoning. But execution — following a clear, well-structured plan — doesn’t require the same depth of reasoning. Sonnet can do it reliably and at a much lower cost per token.\n\nThink of it as separating the architect from the builders. The architect (Fable 5) draws up detailed plans once. The builders (Opus or Sonnet) implement those plans across dozens of tasks without the architect needing to be on-site for every nail.\n\n## Why Fable 5’s Limit Hurts Without This Pattern\n\nClaude Code’s Fable 5 usage limit isn’t a bug — it reflects the real cost of running frontier-level inference at scale. Anthropic applies rate limits and usage caps to balance access across users and infrastructure.\n\nThe problem is the default behavior: when you run Claude Code with Fable 5 and give it a large task, it uses the premium model for *everything*. Every file read, every code write, every intermediate reasoning step, every minor formatting decision. That’s wasteful.\n\nHere’s what that looks like in practice. Say you’re migrating a mid-sized Node.js project to TypeScript — 40+ files. If Fable 5 handles the entire migration end-to-end, you might exhaust your daily limit after 10–15 files. The rest of the task sits unfinished until your quota resets.\n\nWith the advisor-executor pattern:\n\n- Fable 5 analyzes the codebase structure, identifies type patterns, and produces a file-by-file migration plan (a few thousand tokens total).\n- Sonnet executes that plan, file by file, referencing the specification Fable 5 produced.\n\nYou’ve used Fable 5 for one compact planning session. Sonnet handles the remaining 90%+ of execution. Your Fable 5 allocation is intact for the next task.\n\n## Setting Up the Pattern in Claude Code\n\nClaude Code supports multi-model workflows through its `--model`\n\nflag and through structured prompt chaining. Here’s how to implement the advisor-executor pattern.\n\n### Step 1: Start a Fable 5 Advisor Session\n\nOpen your project in Claude Code and explicitly invoke Fable 5 for the planning phase. Keep your prompt focused on producing a structured output — not on doing any work yet.\n\n```\nclaude --model claude-fable-5 \"Analyze this codebase and produce a step-by-step migration plan for converting all JavaScript files to TypeScript. For each file, list: the file path, the types that need to be defined, any external dependencies that will need type declarations, and any known edge cases. Output the plan as a structured JSON array.\"\n```\n\nThe key constraints here:\n\n- You’re asking for a plan, not execution.\n- You’re requesting structured output (JSON, YAML, or numbered lists) so the executor can parse it reliably.\n- You’re being specific about what the plan should contain, which keeps Fable 5’s response compact and actionable.\n\n### Step 2: Save the Advisor Output\n\nCapture Fable 5’s plan to a file. Claude Code can write directly to your working directory:\n\n```\nclaude --model claude-fable-5 \"... [your planning prompt] ... Write the output to migration-plan.json in the project root.\"\n```\n\nAlternatively, pipe stdout to a file and reference it in your next step.\n\n### Step 3: Launch an Executor Session with Sonnet\n\nSwitch models and pass the plan as context:\n\n```\nclaude --model claude-sonnet-4 \"You have a migration plan in migration-plan.json. Execute it step by step. For each file in the plan, apply the TypeScript conversions specified. After completing each file, mark it as complete in the plan. Do not deviate from the plan structure — if you encounter an issue, note it and continue to the next file.\"\n```\n\n- ✕a coding agent\n- ✕no-code\n- ✕vibe coding\n- ✕a faster Cursor\n\nThe one that tells the coding agents what to build.\n\nA few things worth emphasizing in your executor prompt:\n\n**“Do not deviate from the plan.”** This prevents Sonnet from re-deriving strategy, which wastes tokens and can introduce inconsistency.**“Note issues and continue.”** You want the executor to flag problems without stopping for decision-making it isn’t equipped to handle. Route those decisions back to Fable 5 later if needed.**Progress tracking.** Having the executor update the plan file as it goes gives you a checkpoint you can resume from if a session ends.\n\n### Step 4: Review and Re-Advise if Needed\n\nWhen the executor finishes (or flags issues), you can open a short Fable 5 session to review edge cases, handle exceptions, or update the plan. This is another compact planning call — not a full re-run.\n\nThis loop (advise → execute → spot-check → re-advise if needed) is what keeps Fable 5 usage concentrated on reasoning tasks and execution costs on the cheaper model.\n\n## A Real Example: Refactoring a React App\n\nHere’s a full walkthrough with a concrete task — converting a React class component library to functional components with hooks.\n\n### The Setup\n\nThe codebase has 28 class components spread across three feature directories. Some use lifecycle methods (`componentDidMount`\n\n, `componentDidUpdate`\n\n, `componentWillUnmount`\n\n), some use `setState`\n\n, and a few have complex render logic with internal state.\n\nWithout the advisor-executor pattern, running Fable 5 end-to-end on this would likely exhaust daily limits before finishing.\n\n### The Fable 5 Advisor Prompt\n\n```\nAnalyze the React class components in /src/components. For each file:\n1. List the lifecycle methods used and their functional equivalents (useEffect patterns)\n2. Identify all state variables and their useState equivalents\n3. Flag any components with unusual patterns that require special handling\n4. Produce a migration order (start with simplest components)\n\nOutput as a structured YAML file at /src/migration-plan.yaml.\nDo not modify any source files. Analysis only.\n```\n\nThis prompt produces a compact, structured plan. Fable 5 uses maybe 3,000–5,000 tokens total. It’s doing what it’s best at: pattern recognition, edge case identification, and structured reasoning.\n\n### The Sonnet Executor Prompt\n\n```\nYou have a component migration plan at /src/migration-plan.yaml.\n\nWork through each component in order. For each one:\n- Convert the class component to a functional component using the patterns specified in the plan\n- Replace lifecycle methods with useEffect hooks as specified\n- Convert state using useState as specified\n- If the plan flags a component as \"special handling required,\" make the conversion but add a comment: // REVIEW: [reason from plan]\n- After converting each file, append a \"completed\" status to that item in the YAML\n\nBegin with the first uncompleted component in the plan.\n```\n\nSonnet handles all 28 components without burning Fable 5 tokens. It’s following instructions, not strategizing. That’s well within Sonnet’s capability.\n\n### The Result\n\n**Fable 5 tokens used:** Approximately 4,200 (analysis phase only)**Sonnet tokens used:** Approximately 38,000 (execution across 28 files)**Fable 5 limit consumed:** Less than 15% of a typical daily allocation**Outcome:** All 28 components converted, with 3 flagged for manual review\n\nCompare that to a single-model Fable 5 run, which would have used 40,000+ Fable 5 tokens and likely hit limits before finishing.\n\n## Getting 93% Efficiency: What the Numbers Mean\n\nThe “93% of work at a fraction of the cost” framing comes from how token usage distributes across advisor and executor roles.\n\nIn typical coding tasks, the reasoning phase — understanding the codebase, deciding on a strategy, identifying edge cases — accounts for roughly 5–15% of total token usage. The execution phase — actually writing, modifying, and reviewing code — accounts for 85–95%.\n\nIf you run everything through Fable 5, you’re paying frontier prices for all of it.\n\nIf you use Fable 5 only for the reasoning phase and Sonnet for execution, you’re paying frontier prices for 5–15% of the work. The other 85–95% runs at Sonnet pricing, which is substantially lower per token.\n\nThe 93% figure reflects a common distribution: about 7% of tokens going to the Fable 5 advisor phase and 93% to the Sonnet executor phase. Your mileage will vary based on task type — tasks with complex architecture decisions may need more advisor time — but the ratio is typically in this range for well-structured software tasks.\n\nThe practical upshot is that you can run multiple large tasks per day without burning through your Fable 5 quota, rather than exhausting it on a single session.\n\n## Common Mistakes and How to Avoid Them\n\n### Asking the Advisor to Do Too Much\n\nThe most common mistake is letting Fable 5 start executing during the planning phase. Watch for prompts like “Plan the migration and start with the first file.” That bleeds execution into the advisor role and inflates your Fable 5 usage.\n\nKeep advisor prompts explicitly analysis-only. Use language like “produce a plan,” “analyze,” “identify,” “output a specification.” Avoid “do,” “convert,” “write,” “apply.”\n\n### Under-Specifying the Executor Prompt\n\nIf the executor prompt is vague, Sonnet will fill in gaps with its own reasoning — which is slower and can deviate from the plan. Be explicit: tell it exactly how to interpret the plan, what to do with edge cases, and how to track progress.\n\n### Skipping the Structured Output Step\n\nIf Fable 5’s plan is a wall of prose, Sonnet has to parse intent from natural language, which introduces ambiguity. Always ask the advisor to produce structured output — JSON, YAML, or clearly numbered lists. Structured plans execute more consistently.\n\n### Using the Executor for Decision-Making\n\nIf Sonnet hits something unexpected during execution, it shouldn’t improvise strategy. Your executor prompt should route unusual cases back to a logging file or a comment in the code, not have Sonnet make judgment calls. Bring those decisions back to Fable 5 in a targeted follow-up session.\n\n## Where MindStudio Fits Into This Pattern\n\nThe advisor-executor pattern is a form of multi-agent orchestration — one model directing another. If you’re building this kind of workflow into a product or automated pipeline (rather than running it manually in Claude Code), [MindStudio](https://mindstudio.ai) is worth looking at.\n\nMindStudio’s visual builder lets you wire up multi-step agent workflows without code. You can configure one AI step to use Fable 5 or Opus for analysis, pass that output to a second step running Sonnet for execution, and chain the whole thing together with branching logic, file handling, and integrations to tools like Slack, Notion, or GitHub.\n\nThe platform supports 200+ models out of the box — including the full Claude lineup — so you can run advisor-executor patterns at a product level, not just at the command line. For teams that want to build this kind of cost-optimized AI workflow into an internal tool or customer-facing application, MindStudio removes the infrastructure overhead. The [Agent Skills Plugin](https://mindstudio.ai/agent-skills) also lets Claude Code itself call MindStudio workflows as method calls, which means you can extend this pattern with capabilities like web search, email, or database reads without building that plumbing yourself.\n\nYou can try MindStudio free at [mindstudio.ai](https://mindstudio.ai).\n\n## Frequently Asked Questions\n\n### What is the advisor-executor pattern in Claude Code?\n\nThe advisor-executor pattern splits a task between two models: a high-capability model (the advisor) that analyzes the problem and produces a structured plan, and a faster, cheaper model (the executor) that carries out that plan. In Claude Code, this typically means using Fable 5 for planning and Sonnet or Opus for execution. It reduces overall token costs while preserving quality on complex tasks.\n\n### How do I switch models between sessions in Claude Code?\n\nUse the `--model`\n\nflag when launching Claude Code: `claude --model claude-fable-5`\n\nfor the advisor phase, and `claude --model claude-sonnet-4`\n\nfor the executor phase. You can also set a default model in your Claude Code configuration file and override it per session.\n\n### Does the executor model need to be in the same session as the advisor?\n\nNo. The handoff happens through shared context — typically a file that the advisor writes and the executor reads. This makes the pattern easy to implement: the advisor session ends, its output is saved, and a new executor session starts with the plan as input. Sessions don’t need to be linked.\n\n### Is Sonnet capable enough to execute plans from Fable 5?\n\nFor most well-defined software tasks — code migration, refactoring, feature implementation, test generation — yes. The key is that the advisor produces a detailed, unambiguous plan. Sonnet is very capable at following clear instructions; it struggles when asked to do the heavy reasoning itself. Structure the handoff well and execution quality stays high.\n\n### What kinds of tasks benefit most from this pattern?\n\nTasks where the planning phase is distinct from the execution phase and where execution is repetitive or parallelizable. Examples include: large-scale refactors, multi-file code migrations, batch content generation, systematic test writing, and data transformation pipelines. Tasks that require tight feedback loops between thinking and doing — like debugging a novel issue — benefit less.\n\n### Can I use this pattern with other Claude multi-agent frameworks?\n\nYes. The advisor-executor concept isn’t Claude Code-specific. You can implement it with LangChain, CrewAI, the Claude API directly, or through platforms like MindStudio. The core principle applies anywhere you can route different stages of a task to different models. Claude Code just makes it particularly accessible through its `--model`\n\nflag and file-based context sharing.\n\n## Key Takeaways\n\n- The advisor-executor pattern uses Fable 5 only for planning and reasoning, then routes execution to Opus or Sonnet — extending your premium model allocation significantly.\n- In practice, around 93% of total tokens go to the executor (cheaper) model, with only 5–10% consumed by the advisor (premium) model.\n- Implementation in Claude Code relies on the\n`--model`\n\nflag, structured output from the advisor, and explicit executor prompts that reference the plan. - Common failure modes are prompts that blur advisor and executor roles — keep analysis and execution in separate, clearly scoped sessions.\n- For teams building this into automated pipelines or products,\n[MindStudio](https://mindstudio.ai)provides a visual way to wire up multi-model workflows without managing infrastructure manually.\n\n## Other agents ship a demo. Remy ships an app.\n\nReal backend. Real database. Real auth. Real plumbing. Remy has it all.\n\nIf you’re hitting Fable 5 limits on large projects, the advisor-executor pattern is the most practical adjustment you can make. The setup takes about 10 minutes and the token savings are immediate.", "url": "https://wpnews.pro/news/how-to-use-the-advisor-executor-pattern-in-claude-code-to-extend-your-fable-5", "canonical_source": "https://www.mindstudio.ai/blog/advisor-executor-pattern-claude-code-fable-5/", "published_at": "2026-07-09 00:00:00+00:00", "updated_at": "2026-07-09 17:50:00.041658+00:00", "lang": "en", "topics": ["large-language-models", "ai-tools", "developer-tools"], "entities": ["Anthropic", "Claude Code", "Fable 5", "Opus", "Sonnet"], "alternates": {"html": "https://wpnews.pro/news/how-to-use-the-advisor-executor-pattern-in-claude-code-to-extend-your-fable-5", "markdown": "https://wpnews.pro/news/how-to-use-the-advisor-executor-pattern-in-claude-code-to-extend-your-fable-5.md", "text": "https://wpnews.pro/news/how-to-use-the-advisor-executor-pattern-in-claude-code-to-extend-your-fable-5.txt", "jsonld": "https://wpnews.pro/news/how-to-use-the-advisor-executor-pattern-in-claude-code-to-extend-your-fable-5.jsonld"}}