Plan with Fable 5, Build with Sonnet: The Model Routing Pattern That Cuts AI Costs
Use Claude Fable 5 for planning and architecture, then switch to Sonnet for implementation. This routing pattern cuts token costs without sacrificing quality.
Why Running Every Task Through Your Best Model Is Costing You More Than You Think
AI costs have a way of sneaking up on teams. You start with a few workflows, everything works great, and then the token bill triples when you scale. The culprit is usually the same thing: using a high-capability model like Claude Fable 5 for every single task — including ones that don’t need it.
The fix isn’t to downgrade your AI setup. It’s to route the right work to the right model at the right moment. This is called model routing, and the pattern of pairing Claude Fable 5 with Claude Sonnet is one of the most practical ways to cut AI infrastructure costs without touching output quality.
This article walks through exactly how that pattern works, when to apply it, and how to implement it in your own workflows.
What Makes Fable 5 and Sonnet Different
Before getting into the routing logic, it helps to understand what actually separates these two models.
Claude Fable 5: Built for Complexity
Claude Fable 5 sits at the top of Anthropic’s model tier. It’s designed for tasks that require deep reasoning, long-context comprehension, ambiguity resolution, and multi-step planning. It performs better on tasks where the structure of the answer matters as much as the answer itself.
The tradeoff is cost. Fable 5 costs significantly more per token than Sonnet — both for input and output. When you’re running thousands of requests per day, that difference compounds fast.
Claude Sonnet: Fast, Capable, Affordable
Sonnet is Anthropic’s mid-tier model. It’s not a stripped-down version of Fable 5 — it’s a capable model that handles a wide range of tasks well. For well-defined, structured tasks where the instructions are clear and the output format is predictable, Sonnet performs close to Fable 5 at a fraction of the cost.
The key insight: most of the work in a multi-step AI workflow doesn’t require Fable 5’s reasoning depth. Only the planning stage does.
The Core Routing Pattern: Plan High, Build Low
The model routing pattern works like this:
- Fable 5 handles the planning phase — It takes the raw problem, figures out what needs to happen, decides on structure, and produces a detailed plan or architecture.
- Sonnet handles the execution phase — It takes that plan and carries it out, step by step, following the structure Fable 5 already defined.
This works because the hard cognitive work — breaking down an ambiguous problem, resolving conflicting requirements, deciding on the right approach — is done once, by Fable 5. Sonnet doesn’t need to re-reason from scratch. It’s working off a clear spec.
Think of it as the difference between an architect drawing blueprints and a contractor building from them. The architect needs to solve the hard design problems. The contractor needs to execute reliably. These are different skill levels with different price tags.
Where Fable 5 Actually Earns Its Cost
Not every task benefits from Fable 5. Here’s where the investment is justified.
Decomposing Complex Problems
When a user prompt or business requirement is vague, multi-layered, or contains implicit assumptions, Fable 5 is far better at surfacing what’s actually being asked and breaking it into actionable sub-tasks. This upfront decomposition work is expensive to do poorly — if your plan is wrong, every downstream step compounds the error.
Designing Workflow Architecture
If you’re building a multi-step AI agent, Fable 5 is better suited to decide what the steps should be, in what order, and how they should hand off to each other. This architectural decision-making requires understanding tradeoffs and anticipating edge cases — tasks where Fable 5’s reasoning depth pays dividends.
Producing Structured Specifications
Before Sonnet writes a document, generates code, or processes data, it needs a clear spec. Fable 5 is better at producing rich, unambiguous specs that reduce the chance of Sonnet going off-track mid-execution. A well-written spec from Fable 5 often eliminates the need for retry loops and correction steps downstream.
Handling Ambiguous or High-Stakes Decisions
Any step in your workflow where the wrong answer creates real problems — a compliance judgment, a business logic decision, a nuanced communication — should go through Fable 5. These are high-leverage moments where the cost difference is irrelevant compared to the cost of getting it wrong.
Where Sonnet Handles the Load
Once planning is done, Sonnet takes over for the bulk of the work.
Executing Against a Defined Plan
If Fable 5 has already determined what needs to be written, built, or processed, Sonnet can carry that out with high reliability. Following a structured plan is a fundamentally different task from creating one, and Sonnet is well-suited to it.
Repetitive or High-Volume Tasks
Any task you’re running at scale — summarizing documents, classifying inputs, drafting templated outputs, transforming data — is a Sonnet task. The per-token cost difference multiplies with volume. Running 10,000 summarization requests through Fable 5 instead of Sonnet can mean the difference between a $200 workflow and a $2,000 one.
Structured Data Extraction
Pulling structured information from text — dates, names, values, categories — is a task Sonnet handles cleanly. The format is predictable, the logic is explicit, and there’s no deep reasoning required. This is exactly where you don’t need Fable 5.
First-Draft Generation with a Clear Brief
Sonnet can produce strong first drafts when it’s working from a detailed brief. The brief doesn’t need to be long — it needs to be precise. If Fable 5 writes the brief, Sonnet writes the draft, and the quality holds up.
How to Implement the Pattern
Putting this into practice means rethinking how you build AI workflows. Instead of a single model call, you’re designing a two-phase pipeline.
Step 1: Identify the Planning Boundary
Look at your workflow and ask: where does reasoning end and execution begin? That boundary is where you switch models. If your workflow currently has one big prompt that asks a model to both figure out what to do and do it, split it into two prompts.
Step 2: Write a Strong Planning Prompt for Fable 5
Your Fable 5 prompt should:
- Give full context about the goal
- Ask explicitly for a structured plan or specification (not the final output)
- Request that the output be formatted in a way Sonnet can consume (e.g., a numbered list, a JSON schema, a set of labeled sections)
The output of this call becomes the input to Sonnet.
Step 3: Write an Execution Prompt for Sonnet
Your Sonnet prompt should:
- Include the plan or spec from Fable 5 verbatim (or embedded)
- Give Sonnet a clear, narrow instruction (“Using the plan above, write the email,” not “What should I do about this email?”)
- Constrain the output format so it’s easy to process downstream
Step 4: Route Conditionally When Needed
Some workflows don’t need Fable 5 at all. If the task is already well-defined and structured, skip the planning call entirely and send it straight to Sonnet. Model routing doesn’t have to mean always using both — it means using Fable 5 when it’s actually needed and defaulting to Sonnet when it’s not.
A simple routing rule:
- Use Fable 5 if: the task involves novel reasoning, ambiguous inputs, multi-step planning, or high-stakes decisions
- Use Sonnet if: the task is structured, templated, high-volume, or follows a plan that already exists
Step 5: Measure and Adjust
After implementing the pattern, track your token spend per workflow and per phase. Most teams find that the planning phase consumes 10–20% of total tokens but represents the majority of reasoning value. The execution phase — often 80%+ of tokens — is where running everything through Fable 5 was burning budget unnecessarily.
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
Common Mistakes Teams Make with Model Routing
Treating It as a One-Time Decision
Model routing isn’t a setting you flip once. As workflows evolve, the boundary between planning and execution shifts. Review your routing logic when you update a workflow significantly.
Making the Planning Prompt Too Short
If you ask Fable 5 to produce a plan in three bullet points, Sonnet won’t have enough to work with. The planning output needs to be detailed enough that Sonnet can execute without backfilling assumptions. A common mistake is optimizing Fable 5’s output for brevity — don’t. That’s the one place you want richness.
Skipping Error Handling Between Phases
If Fable 5 produces a malformed plan (it happens), Sonnet will execute against something broken. Include a simple validation step between the two phases — even just checking that the plan output contains expected structure before passing it forward.
Using Sonnet for Tasks That Actually Need Reasoning
Some execution tasks look simple but aren’t. If Sonnet is consistently producing outputs that need heavy correction, that’s a signal the task is harder than it looks and needs Fable 5’s reasoning depth. Don’t force a cost optimization at the expense of rework.
How MindStudio Makes This Pattern Practical to Build
Implementing a two-model pipeline from scratch — managing API calls, passing state between phases, handling errors, logging token usage — is real engineering work. It’s doable, but it takes time to set up and maintain.
MindStudio’s visual workflow builder makes this pattern much faster to implement. You can build a Fable 5 planning step and a Sonnet execution step as separate blocks in the same workflow, connect them directly, and pass the output of one into the prompt of the other — no code required.
Since MindStudio includes 200+ AI models out of the box, including Claude Fable 5 and Claude Sonnet, you don’t need to manage separate API keys or accounts. You just select the model for each step in the builder.
This also makes it easy to experiment with the routing boundary. You can swap which model handles which phase, test output quality, and compare token costs across runs — all within the same workflow. For teams that want to build AI agents that automate multi-step business processes, having model selection at the step level (rather than the workflow level) is a meaningful capability.
If you want to try it, you can start free at mindstudio.ai.
Real-World Use Cases for This Pattern
Content Production Pipelines
A content team uses Fable 5 to analyze a brief, identify key messages, define the structure, and set the tone. Sonnet writes each section against that structure. The final output requires minimal editing. Token costs drop because the bulk of the word generation (the long sections) runs through Sonnet.
Code Generation Workflows
Fable 5 designs the architecture — file structure, function signatures, data flow, edge cases to handle. Sonnet writes each function. The code is more consistent because the architecture is coherent, and the engineering team spends less time reviewing.
Customer Support Automation
Fable 5 categorizes and analyzes incoming support tickets, identifies the issue type and required resolution path, and generates a response strategy. Sonnet drafts the actual customer-facing reply using that strategy. This keeps response quality high while running most of the token volume through the cheaper model.
Research Summarization
Fable 5 reads a long document, identifies the key themes, and produces a structured outline of findings. Sonnet expands each section of the outline into prose. The final summary is coherent because the structure came from Fable 5, not from Sonnet trying to reason about structure and write at the same time.
Frequently Asked Questions
How much can model routing actually reduce AI costs?
It depends on the workflow, but teams implementing a Fable 5/Sonnet split on high-volume workflows typically report 40–70% reduction in token costs for equivalent output quality. The savings are larger for workflows with high execution volume (many similar outputs) and smaller for workflows that are inherently reasoning-heavy throughout.
Does splitting into two model calls add latency?
Yes, there’s some added latency from running two sequential model calls. In practice, this is often offset by shorter prompts in each phase. The planning prompt is focused, and the execution prompt doesn’t need to include all the context for reasoning — just the plan and the task. Many teams find overall latency is similar or better compared to one large, over-stuffed prompt to Fable 5.
Can I use this pattern with models other than Claude?
Yes. The planning/execution split is a general pattern that works across model families. You could use GPT-4o for planning and GPT-4o-mini for execution, or Gemini 1.5 Pro for planning and Gemini Flash for execution. The underlying logic is the same: use the high-capability model for reasoning, the efficient model for execution. The Fable 5/Sonnet pairing works particularly well because both models share training alignment, which reduces the chance of the execution model misinterpreting the planning model’s output.
What if the planning output from Fable 5 is inconsistent?
Add structure to your Fable 5 prompt. Ask it to return a JSON object, a numbered list with labeled fields, or a structured template rather than freeform prose. Consistent output format from Fable 5 makes Sonnet’s execution much more reliable. If you’re still seeing inconsistency, add a validation step that checks for required fields before proceeding to execution.
Is this the same as prompt chaining?
It’s a form of it. Prompt chaining refers to any workflow where the output of one model call becomes the input of the next. Model routing adds a specific dimension: deliberately choosing different models for different steps based on the nature of the task. You can chain two Sonnet calls, two Fable 5 calls, or mix them — the routing pattern specifically refers to the deliberate assignment of model tier based on task type.
When should I just use Fable 5 for everything?
One coffee. One working app.
You bring the idea. Remy manages the project.
When the entire workflow is reasoning-intensive and volume is low. If you’re building an internal tool that runs a handful of times per day and every step requires genuine judgment, the added complexity of routing may not be worth the savings. Model routing pays off at scale and when there’s a clear planning/execution split. For low-volume, high-complexity workflows, simplicity often wins.
Key Takeaways
- The plan-with-Fable-5, build-with-Sonnet pattern routes complex reasoning to a high-capability model and routine execution to a cost-efficient one.
- The planning phase — decomposing problems, designing architecture, producing structured specs — is where Fable 5’s reasoning depth creates real value.
- The execution phase — generating output against a clear plan — is where Sonnet handles the volume efficiently.
- Most teams implementing this pattern see 40–70% token cost reduction on applicable workflows without meaningful quality loss.
- Effective implementation requires a strong planning prompt, a well-structured plan output, and a focused execution prompt.
- MindStudio’s visual builder makes this pattern straightforward to implement without managing infrastructure — model selection is per-step, not per-workflow.
If you’re running AI workflows at any meaningful scale, this pattern is one of the most direct levers you have on cost. Start with your highest-volume workflow, identify the planning/execution boundary, and run the split. The numbers tend to speak for themselves.
