How to Use the Advisor-Executor Pattern in Claude Code to Extend Your Fable 5 Limit
Use Fable 5 for planning and review while Sonnet handles execution. This model routing pattern cuts token costs dramatically while maintaining output quality.
The Problem with Running Everything Through Your Most Capable Model
Claude Code is a powerful coding agent. But if you’ve been using it heavily, you’ve probably hit a wall: your most capable model — Claude claude-opus-4-5, referred to in Claude Code’s environment as Fable 5 — has a usage limit, and it burns through that limit fast when you’re running it on every step of a task.
Planning. Drafting. Executing. Reviewing. Debugging. All of it routed through the same expensive, rate-limited model.
The advisor-executor pattern is a straightforward solution to this. Use Fable 5 where its reasoning capability actually matters — planning and reviewing — and delegate the execution work to Claude Sonnet. You spend your Fable 5 budget on the decisions that require it, not on the mechanical work of writing boilerplate or making incremental edits.
This article walks through how the pattern works, how to configure it in Claude Code, and how to think about model routing more broadly when you’re building multi-agent workflows.
What the Advisor-Executor Pattern Actually Is
The advisor-executor pattern is a form of multi-agent architecture where two agents — or two instances of the same agent using different models — handle different phases of a task.
The advisor handles high-level work:
- Decomposing complex tasks into subtasks
- Deciding how to approach a problem
- Setting constraints and acceptance criteria
- Reviewing output and catching errors
The executor handles implementation:
- Writing the actual code or content
- Running file operations
- Making API calls
- Iterating on drafts
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
The key insight is that these two phases have very different cognitive requirements. Planning and review demand nuanced reasoning. Execution is often pattern-matching and mechanical implementation of instructions that have already been thought through.
Expensive frontier models like Fable 5 are optimized for the first kind of work. Claude Sonnet is more than capable of handling the second — and it costs significantly less per token.
When you separate these roles, you’re not sacrificing quality. You’re applying the right tool to the right job.
Understanding the Fable 5 Limit in Claude Code
Claude Code assigns models to tasks based on your configuration, but when you’re running interactively, it defaults to the most capable model available. In current Claude Code setups, that’s claude-opus-4-5 — which Anthropic internally identifies under the Fable codename.
The limit exists because Opus-tier models are expensive to run. Anthropic caps usage to manage infrastructure load and to keep costs predictable for users. When you hit the Fable 5 limit, Claude Code either throttles you, requires you to wait for your quota to reset, or falls back to a less capable model automatically.
The frustrating part: if you’ve been using Fable 5 for every step of every task, a large chunk of that budget went to work that didn’t require Opus-level reasoning. Generating test scaffolding, reformatting files, writing out repetitive patterns — this is Sonnet-tier work being billed at Opus-tier rates.
The advisor-executor pattern fixes this by making the budget allocation intentional.
How to Configure the Pattern in Claude Code
Step 1: Understand Claude Code’s Model Selection Options
Claude Code allows you to specify which model handles different tasks. By default, it routes everything through the primary model. But you can override this behavior using the --model flag in the CLI, or by configuring model preferences in your claude_code_config.json file (or equivalent project-level config).
The goal is to make Fable 5 the exception, not the default.
Step 2: Define Your Task Phases
Before writing any configuration, map out the task phases for the kind of work you do most often. For a typical feature development workflow, it might look like:
Advisor phase (Fable 5):
- Understand requirements
- Break the feature into discrete subtasks
- Identify edge cases and constraints
- Specify the expected interface, function signatures, or data structures
Executor phase (Sonnet):
- Write the implementation code
- Create test files
- Generate documentation strings
- Apply linting or formatting changes
Advisor phase — review (Fable 5):
- Review the completed implementation
- Identify logical errors or missed requirements
- Approve or send back with specific corrections
This structure lets Fable 5 act as the senior developer, while Sonnet acts as the implementation engineer.
Step 3: Set Up Your CLAUDE.md Instructions
Claude Code reads your CLAUDE.md file for project-level instructions. This is where you encode the advisor-executor logic.
Here’s a working example:
## Model Routing Instructions
You operate in two modes: ADVISOR and EXECUTOR.
**ADVISOR mode** (use your full reasoning capability):
- When asked to plan, decompose, or architect a solution
- When reviewing completed work against requirements
- When catching logical errors or edge cases
**EXECUTOR mode** (optimize for speed and token efficiency):
- When implementing a plan that has already been defined
- When writing boilerplate, tests, or documentation
- When applying clearly specified changes to existing files
For EXECUTOR tasks, default to conservative, well-established patterns.
Do not over-engineer. Follow the plan specified in the advisor phase exactly.
If you encounter ambiguity during execution, flag it rather than resolving it autonomously.
This shapes Claude’s behavior at the instruction level — even before you configure model routing.
Step 4: Route Models Explicitly
For programmatic control, use the Claude Code CLI with explicit model flags:
# Advisor phase — plan the task
claude --model claude-opus-4-5 "Analyze this codebase and create a detailed implementation plan for adding OAuth2 support. Output a numbered task list with clear acceptance criteria for each step."
# Executor phase — implement
claude --model claude-sonnet-4-5 "Implement step 1 from the plan: [paste plan step]. Follow the plan exactly. Flag any ambiguity instead of resolving it."
# Advisor phase — review
claude --model claude-opus-4-5 "Review the implementation in [file]. Check it against these criteria: [paste criteria from plan]. Return a pass/fail with specific notes."This keeps your Fable 5 usage tightly scoped to the planning and review calls, while Sonnet handles the bulk of the execution calls.
Step 5: Automate the Routing with a Shell Script
Once you’ve got the pattern working manually, wrap it in a script so you’re not managing model flags by hand on every call.
#!/bin/bash
# advisor_executor.sh
TASK="$1"
PLAN_FILE="task_plan.md"
echo "=== ADVISOR: Planning phase ==="
claude --model claude-opus-4-5 \
"Create a detailed step-by-step implementation plan for: $TASK.
Output as a numbered list. Each step must include: what to do,
which files to modify, and acceptance criteria." > "$PLAN_FILE"
echo "Plan saved to $PLAN_FILE"
echo ""
echo "=== EXECUTOR: Implementation phase ==="
# Read each step and execute with Sonnet
while IFS= read -r line; do
if [[ "$line" =~ ^[0-9]+\. ]]; then
claude --model claude-sonnet-4-5 \
"Execute this task exactly as specified: $line
Follow the implementation literally. Flag ambiguity, don't resolve it."
fi
done < "$PLAN_FILE"
echo ""
echo "=== ADVISOR: Review phase ==="
claude --model claude-opus-4-5 \
"Review all recent changes against the plan in $PLAN_FILE.
Report pass or fail for each step with specific notes."This is a simplified starting point. In practice, you’ll want to add error handling, step confirmation prompts, and logging — but the structure holds.
Measuring the Token Savings
The efficiency gains from this pattern depend on your task mix, but the math tends to be significant.
Claude claude-opus-4-5 costs roughly 5–6x more per token than claude-sonnet-4-5. If your typical workflow breaks down as 20% planning/review and 80% execution, and you route execution to Sonnet, you’re looking at a cost reduction in the range of 60–70% for that execution portion.
More importantly for Fable 5 usage limits: you’re consuming Opus tokens at a fraction of the previous rate. A task that previously required 50,000 Opus tokens might now use 10,000 Opus tokens and 40,000 Sonnet tokens. Your Fable 5 budget stretches 4–5x further.
Some rough benchmarks to calibrate your expectations:
- Simple feature additions: Executor handles ~85% of work. Advisor used for initial plan + final review only.
- Architectural decisions: Advisor handles ~50% of work. These require more back-and-forth reasoning.
- Bug fixes with clear repro steps: Executor handles ~90%. The plan writes itself.
- Ambiguous or exploratory tasks: Advisor-heavy. Don’t try to force Sonnet into tasks that lack clear specifications.
Remy doesn't write the code. It manages the agents who do.
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
Common Mistakes to Avoid
Giving the Executor Ambiguous Plans
Sonnet is capable, but it doesn’t handle ambiguity as well as Opus. If your plan says “handle edge cases appropriately,” Sonnet will make a judgment call — and it might not be the judgment call you wanted.
Make Advisor plans explicit. Specify the expected input types, output formats, error handling behavior, and function signatures. Leave nothing to interpretation.
Using Fable 5 for Mechanical Reviews
Not every review requires Opus reasoning. If you’re checking whether a file was reformatted correctly, or whether a variable was renamed consistently across files, Sonnet can do that check. Save Fable 5 for reviews that require understanding intent, catching logic errors, or validating architectural decisions.
Switching Models Mid-Execution
Every model switch has overhead. Try to batch your Advisor and Executor calls rather than alternating on every small decision. Plan for a full feature, execute the full feature, review the full feature — rather than planning and reviewing each individual step.
Not Logging the Advisor’s Output
The plan the Advisor produces is valuable. Store it. Reference it. If the Executor fails or goes off-track, having the original plan makes it much easier to course-correct. Build logging into your workflow from the start.
Where MindStudio Fits for Multi-Agent Routing
If you’re building these kinds of model routing patterns more broadly — not just in Claude Code but across automated workflows, business processes, or AI-powered apps — MindStudio handles the orchestration layer out of the box.
In MindStudio’s visual workflow builder, you can create multi-step AI workflows where different steps use different models. An Opus-tier model can handle a planning node, output a structured task list, and pass it to a Sonnet-tier model for execution — all without writing orchestration code.
This is directly relevant if you’re building agents that go beyond Claude Code’s scope: document processing pipelines, customer-facing AI tools, or background automation jobs that run on schedules. MindStudio gives you 200+ models available without separate API keys, and the same advisor-executor logic you’d implement manually in a shell script becomes a visual workflow you can modify in minutes.
The MindStudio AI agent builder is free to start and supports the kind of model routing described in this article natively — useful if you want to scale this pattern beyond a single coding environment.
Extending the Pattern: Sub-Agents and Parallelism
Once you’re comfortable with the basic advisor-executor split, there are a few natural extensions worth considering.
Parallel Executor Agents
If your plan contains independent subtasks — features that don’t depend on each other — there’s no reason to run them sequentially. You can spawn multiple Sonnet executors in parallel, each handling a different subtask, then bring results back to Fable 5 for a consolidated review.
This dramatically reduces wall-clock time on large features. The Advisor plans once, multiple Executors work simultaneously, the Advisor reviews once.
Specialized Executor Roles
Not all execution tasks are the same. You might route:
- Test writing to a model optimized for coverage
- Documentation to a model with strong writing ability
- Security checks to a model with security-focused training
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
The advisor-executor pattern is really a model-routing pattern. The “executor” role can be further split based on task type.
Feedback Loops
In a simple advisor-executor pattern, the Advisor reviews once and either approves or sends back corrections. In a more robust setup, you can add a feedback loop: if Fable 5’s review finds issues, it generates a correction plan that goes back to Sonnet for a targeted fix, then re-reviews.
This keeps the correction work in Sonnet while preserving Fable 5’s reasoning for the review itself.
FAQ
What is the Fable 5 limit in Claude Code?
The Fable 5 limit refers to the usage cap on Claude claude-opus-4-5 (Opus 4.5) within Claude Code. Anthropic applies rate limits to Opus-tier models to manage infrastructure load and cost. When you hit the limit, you’re throttled or forced to wait for your quota to reset. The advisor-executor pattern extends how long your Fable 5 budget lasts by reserving Opus usage for planning and review tasks only.
Is Claude Sonnet good enough for code execution?
Yes, for most implementation tasks. Claude Sonnet 4.5 handles well-specified coding tasks — writing functions, implementing specified interfaces, generating tests, applying refactors — with high reliability. Where it falls short is in tasks that require resolving significant ambiguity, making architectural judgments, or catching subtle logic errors. That’s precisely why the advisor-executor pattern reserves those tasks for Opus.
How much do I actually save using the advisor-executor pattern?
Token cost savings depend on your task mix, but a rough estimate is 50–70% cost reduction on tasks that are 70–80% implementation work. More importantly, your Fable 5 usage quota goes significantly further — often 4–5x — because Opus tokens are only consumed during planning and review phases.
Can I use this pattern with Claude Code’s native sub-agent features?
Yes. Claude Code supports spawning sub-agents via its tool use capabilities. You can configure your primary agent (Fable 5) to spawn Sonnet sub-agents for execution tasks and receive their output for review. This is the most integrated way to implement the pattern within Claude Code itself.
Does the quality of output actually hold up?
In practice, yes — with the caveat that your plans need to be explicit. The quality of the Executor’s output is directly proportional to the quality of the Advisor’s plan. A well-specified plan from Fable 5 gives Sonnet everything it needs to produce solid output. A vague plan produces vague output, regardless of which model you use for execution.
What tasks should always stay with the Advisor (Fable 5)?
Tasks that require understanding intent, resolving ambiguity, making trade-off decisions, catching subtle logic errors, or evaluating whether an implementation actually solves the original problem — these belong with the Advisor. If you’re not sure, ask: does this task require judgment, or just pattern execution? Judgment stays with Fable 5.
Key Takeaways
- The advisor-executor pattern splits AI tasks into planning/review (Fable 5) and implementation (Sonnet), matching model capability to task requirements.
- This extends your Fable 5 usage limit by 4–5x in typical workflows, while reducing overall token costs by 50–70%.
- Explicit, unambiguous plans are the most important factor in execution quality — garbage in, garbage out.
- The pattern scales: add parallel executors for independent subtasks, specialize executor roles by task type, and build feedback loops for iterative correction.
- Tools like MindStudio handle model routing natively if you want to apply this pattern across broader automated workflows beyond Claude Code.
Start with the basic two-phase split — plan in Fable 5, execute in Sonnet, review in Fable 5. Once that’s working reliably, layer in the more advanced extensions. The simpler version alone will meaningfully stretch your Fable 5 budget.
