Multi-Model Strategy
Claude Code v2.1.321 added Fable 5.2 as the default Fable model, and saved Fable 5.1 selections may move to the fable alias depending on plan and organization settings. This does not change Claude Code's overall default model. Fable 5.2 has a 1M context window, high default effort, and API pricing of $8/$40 per MTok with $0.20/MTok cache reads. Check /model for models available to your account and provider.
Claude offers Opus, Sonnet, and Haiku families, plus Fable for demanding reasoning and long-horizon agentic work. The latest API model is Fable 5.2; Mythos 5.2 with the same specifications is available to organizations in Anthropic verification programs. Model availability in Claude Code varies by plan and provider, so check /model. A multi-model strategy matches the model to the task and balances quality with cost.
Model comparisonโ
| Model | Characteristics | Best for | Relative cost |
|---|---|---|---|
| Fable 5.2 | API: 1M context, $8/$40 input/output, $0.20 cache reads | Hard reasoning or long-running agent work when higher-effort Opus evaluations do not meet requirements | $$$$$ |
| Opus 5.5 | Latest Opus API model; 1M context, $4/$20 input/output | Complex coding and reasoning | $$$$ |
| Sonnet 5.5 | Balanced performance; 1M context, $2/$10 input/output | Everyday coding, reviews, documentation | $$$ |
| Haiku 5.5 | Fastest family; pricing varies by prompt length | Simple fixes, formatting, classification | $ |
Prices above are API rates and do not describe subscription usage or every cloud provider. Anthropic recommends starting with its latest Opus model for most workloads and moving to Fable 5.2 when higher-effort Opus evaluations still fall short. See the official model and pricing documentation.
Fable 5.1 has a model-specific cybersecurity safety classifier. Check the current model's official safety and migration notes before relying on this behavior for security work.
The API model ID for Fable 5.2 is claude-fable-5-2. Its API use requires 30-day data retention and is unavailable in zero-data-retention environments unless Anthropic expressly authorizes it.
Use /model to see models enabled for your plan, organization, and provider. The fable alias points to the latest Fable model; starting in v2.1.321, saved Fable 5.1 selections may move to this alias. Use /model claude-fable-5-1 to select Fable 5.1 again where available. The default alias returns to the recommended model for your plan.
You can change models with the /model command or the --model flag. Model aliases (default, best, fable, opus, sonnet, haiku, opusplan, opus[1m], sonnet[1m]) are also supported. best selects the highest-performing model allowed for your account; check the actual selection in /model. From v2.1.153, the model you pick with /model is saved as the default for new sessions.
Claude Code warns you when the requested model is deprecated or will be automatically replaced by a newer model (v2.1.183+). In print mode (-p) the warning goes to stderr, and models specified in agent frontmatter are checked too โ useful for catching model IDs in scripts and CI that would otherwise change silently.
If you're on an organization account, your /model list may differ from a personal account. From v2.1.187+, admins can restrict which models are available via organization settings; picking a restricted model shows a "restricted by your organization's settings" message (applies to the model picker, --model, /model, and ANTHROPIC_MODEL alike). In v2.1.196+, admins can also set an organization default model โ if you haven't picked one yourself, /model shows it as "Org default" (or "Role default"). If a model documented here doesn't appear on your account, it may be organization policy rather than a version issue.
opusplan is a hybrid alias that automatically switches between Opus in Plan mode and Sonnet in execution mode. It combines Opus's reasoning with Sonnet's efficiency.
When to use which modelโ
When to use Opusโ
- Designing overall system architecture
- Root-cause analysis of complex bugs
- Building performance optimization strategies
- Security vulnerability analysis
- Understanding a large, unfamiliar codebase
claude --model claude-opus-4-8 "Analyze the bottlenecks in this microservice architecture and suggest improvements"
When to use Sonnetโ
- Everyday feature implementation
- Code review and refactoring
- Writing test code
- API integration and data processing
- Documentation and comments
# Sonnet is the default, so no flag needed
claude "Implement a user authentication middleware"
When to use Haikuโ
- File formatting and cleanup
- Simple renames and type fixes
- Repetitive boilerplate generation
- Code translation (language conversion)
- Log analysis and simple classification
claude --model claude-haiku-4-5-20251001 "Convert this JSON into TypeScript types"
Multi-model strategies with subagentsโ
Claude Code's Task tool lets you distribute work across multiple models. This is called the orchestrator-subagent pattern.
Pattern: Opus plans, Sonnet executesโ
User request โ Opus (planning) โ Sonnet ร N (parallel execution)
A real CLAUDE.md configuration example:
# Work strategy
- Complex architecture decisions: always create a detailed plan before executing
- Repetitive work (editing 10+ files): consider parallel processing
- Formatting, adding comments: prioritize fast turnaround
Pattern: review hard, implement fastโ
# Step 1: draft quickly with Haiku
claude --model claude-haiku-4-5-20251001 "Generate CRUD API boilerplate"
# Step 2: review and improve with Sonnet
claude "Review the code you just wrote and improve it"
# Step 3: deep analysis with Opus when needed
claude --model claude-opus-4-8 "Analyze this code for security vulnerabilities"
The advisor toolโ
The advisor is a tool where a stronger model looks at your entire current conversation (including tool calls and results) and returns a review. Rather than using the strong model on every turn, it's invoked only at decision points โ before committing to an approach, when errors keep repeating, or before declaring work complete. It suits long multi-step tasks better than short one-off tasks.
How to enable itโ
/advisor opus
Your choice is saved in the advisorModel user setting and persists across sessions. You can also set it directly in your settings file:
{
"advisorModel": "opus"
}
To turn it off, run /advisor off.
Model pairing rulesโ
The advisor must be the same strength as or stronger than the main model. Practical pairings:
| Pairing | When it fits |
|---|---|
| Sonnet main + Opus advisor | Sonnet handles everyday work; planning, repeated errors, and completion reviews are delegated to Opus |
| Opus main + Opus advisor | High-stakes work that needs an independent second review |
| Haiku main + Opus advisor | Lowest-cost main model for routine work, with Opus for strong planning |
| Fable main + Fable advisor | Maximum-performance pairing (requires Fable access) |
Haiku cannot act as an advisor. If Fable 5.2 is the executor, the advisor must be Fable 5.2 or Mythos 5.2; see the migration guide.
Cost structureโ
One invocation is billed as the entire conversation's tokens ร the advisor model's rate. Because it fires only at decision points rather than every turn, it's usually cheaper than running the strong model as your main model from the start.
How it differs from opusplan and subagentsโ
| Method | When the strong model steps in | Who initiates |
|---|---|---|
| Advisor | At decision points during the task | Claude decides to invoke it |
| opusplan | Only when entering Plan mode; execution stays on Sonnet | User enters Plan mode |
| Subagent | For the entire delegated subtask | Claude delegates, or the user invokes directly |
| /model switch | Every turn after the switch | User switches with /model |
- Experimental feature โ behavior, pricing, and availability may change per the official docs.
- Requires Claude Code v2.1.98 or later (upgrade with
claude update) - Anthropic API only โ not supported on Amazon Bedrock, Google Vertex AI, or Microsoft Foundry
- Using Fable 5 as the advisor requires v2.1.170+ and Fable 5 access.
Model selection decision treeโ
When a new task comes in:
1. Is the task ambiguous or creative?
โ YES: explore with Sonnet first, escalate to Opus if needed
2. Do you need to understand the codebase for the first time?
โ YES: use Opus to map out the overall structure
3. Is it repetitive with a clear pattern?
โ YES: Haiku is enough
4. Any other everyday development work?
โ Sonnet (the default)
5. Are errors repeating mid-task, or do you need an independent review before completion?
โ Consider enabling /advisor
In practice: model strategy by project phaseโ
Early project phase โ lean on Opusโ
# Requirements analysis and architecture design
claude --model claude-opus-4-8 "Analyze this requirements document and design
the optimal database schema and API structure: [requirements]"
Development phase โ Sonnet-centeredโ
# Everyday feature implementation (uses the Sonnet default)
claude "Implement the User service based on the designed schema"
claude "Write test code for the signup API"
Repetitive work โ use Haikuโ
# Formatting, comments, simple conversions
claude --model claude-haiku-4-5-20251001 "Add JSDoc comments to every controller file"
Code review phase โ Sonnet, plus Opus when neededโ
# Regular review
claude "Review the changes in this PR"
# Deep security/performance analysis
claude --model claude-opus-4-8 "Run a security audit on the payment module"
Effort Levelโ
Beyond model selection, you can tune response speed and quality with the effort level. It dynamically adjusts thinking based on task complexity. Supported levels vary by model:
| Level | Description | Best for |
|---|---|---|
low | Fast and cheap, minimal thinking | Short, narrowly scoped tasks |
medium | Token-saving, cost-sensitive work | Everyday coding tasks |
high | Balanced (Opus 4.8 default) | Most coding tasks |
xhigh | Deeper reasoning, more tokens (Opus 4.7 default) | Architecture design, hard bugs |
max | Maximum reasoning with no token constraint (session-only) | The hardest tasks. Watch for over-reasoning |
- Fable 5.2 / Opus 5.5 / Opus 5 / Opus 4.8 / Opus 4.7: all 5 levels โ
low,medium,high,xhigh,max - Opus 4.6 / Sonnet 4.6:
low,medium,high,max(xhighunsupported โ falls back tohigh) - Defaults: Fable 5, Opus 4.8, Opus 4.6, and Sonnet 4.6 =
high; Opus 4.7 =xhigh
# Set via environment variable
CLAUDE_CODE_EFFORT_LEVEL=low claude
# Or adjust with the /effort slider, or left/right arrows in the /model menu
The /effort menu includes ultracode. It is not a model effort level but a Claude Code setting โ it sends xhigh to the model and additionally breaks large tasks into dynamic workflows, orchestrating multiple subagents. It applies to the current session only. It consumes a lot of work (tokens), so turn it on only when you need large parallel workloads.
The /fast command speeds up Opus responses (at a higher token cost). On Opus 4.8, the fast-mode rate is lower than before. Useful for rapid iteration and real-time debugging. Combine it with the effort level for maximum speed.
Fast Mode availability depends on the current model and provider. Starting in v2.1.321, /fast, /config, and /model name the current model when Fast Mode is supported; check those labels instead of relying on a fixed model list or assuming an automatic model switch.
From Opus 4.7 onward, adaptive reasoning (dynamically allocating thinking based on task complexity) is always on, and the same applies to Fable 5. The fixed thinking-budget mode you get by setting CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING applies only to Opus 4.6 and Sonnet 4.6.
In particular, thinking cannot be disabled at all on Fable 5.2 โ the session toggle, the alwaysThinkingEnabled setting, and MAX_THINKING_TOKENS=0 all have no effect.
Practical cost-saving tipsโ
1. Scout with Haiku firstโ
When you don't know what needs to be done, don't jump straight to an expensive model:
# First, get a sense of direction with Haiku
claude --model claude-haiku-4-5-20251001 "Briefly explain what's causing this error"
# Once the direction is clear, solve it with Sonnet
claude "Fix this error: [specific error]"
2. Minimize contextโ
Model cost also scales with input tokens. Don't pull in unnecessary files:
# Inefficient: a small fix with the whole codebase in context
# Efficient: name only the relevant file
claude "Only modify the formatDate function in src/utils/format.ts"
3. Batch similar workโ
Bundle similar tasks into a single request:
# Inefficient: one request per file
# Efficient: batch them
claude "Add a timestamps field to every model file in src/models/"
Model capability summaryโ
The difference you actually feel:
Haiku: "Rename this function to camelCase" โ instant and accurate Sonnet: "Improve this service layer architecture" โ grasps context, then makes solid suggestions Opus: "Build a strategy to modernize this 100K-line legacy system" โ deep analysis, step-by-step plan
Sonnet is enough for most everyday coding. Save Opus for "I don't know how to approach this problem." Use Haiku when the task is clearly easy and you just want it done fast.
Have you completed this chapter?
Mark your progress to increase your roadmap completion.