Multi-Model Strategy

Sonnet 5 released (2026-06-30) · Fable 5 access restored (2026-07-01)

Sonnet 5 has been released and is now the new default model in Claude Code (v2.1.197+). In addition, access to Fable 5 and Mythos 5 — suspended on 6/12 under a US government export-control directive — was restored as of 7/1 (official announcement: anthropic.com/news/redeploying-fable-5). For Pro, Max, Team, and some Enterprise plans, Fable 5 is included in the subscription up to 50% of your weekly limit through 7/7, after which it switches to usage credits. Everything below reflects both changes.

Both changes are rolling out gradually — right after the announcement, they may not appear in your /model menu depending on your account and version (run claude update and check again).

Claude offers three model families — Opus, Sonnet, and Haiku — plus a tier above Opus called Mythos-class (the generally available model is Fable 5, released June 2026). Using the most powerful model for everything inflates cost, while using only the weakest hurts quality. A multi-model strategy picks the right model for each type of task, optimizing performance and cost at the same time.

Model comparison

Model	Characteristics	Best for	Relative cost
Fable 5	Highest performance among generally available models (Mythos-class), 1M context by default	The hardest reasoning tasks, long autonomous runs	$$$$$$
Opus 4.8	Top of the Opus tier, complex reasoning, 1M context	Architecture design, complex algorithms	$$$$$
Sonnet 5	Successor to Sonnet 4.6 (released 2026-06-30), balanced performance, 1M context by default, close to Opus 4.8 performance at a lower price	Everyday coding, reviews, documentation	$$$
Haiku 4.5	Fast and cheap	Simple fixes, formatting, classification	$

Fable 5 is priced at $10/$50 (per MTok input/output) on the API — twice Opus 4.8's standard price ($5/$25). The official docs still recommend Opus 4.8 as the default starting point; Fable 5 is the premium option for "workloads that need the highest available performance."

Fable 5 ships with a cybersecurity safety classifier — it blocks not only prohibited uses like ransomware and malware development, but also high-risk dual-use requests such as penetration testing and exploit development, so security-related tasks may be refused (secure coding, debugging, patch management, and incident response remain allowed).

Sonnet 5 has an introductory API price of $2/$10 (per MTok input/output, through 2026-08-31), then moves to a standard price of $3/$15 (from 2026-09-01; cache write $2.50/$4, cache read $0.20). The model ID is claude-sonnet-5 (Bedrock: anthropic.claude-sonnet-5).

The default model depends on your plan

• Max / Team Premium / Enterprise pay-as-you-go / API: default is Opus 4.8 (falls back to Sonnet automatically when a usage threshold is reached)
• Pro / Team Standard / Enterprise subscription seats: default is Sonnet 5 (replacing Sonnet 4.6 from 2026-06-30, Claude Code v2.1.197+)

Fable 5 is not the default model on any plan. You must select it explicitly with /model fable; once selected, it is saved in your user settings and later sessions start with Fable 5. Fable 5 requires Claude Code v2.1.170 or later and is not available in zero data retention environments.

The default alias automatically returns you to the recommended model for your plan. Opus 4.8 requires Claude Code v2.1.154 or later (upgrade with claude update).

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 uses Fable 5 if your organization has access to it, otherwise the latest Opus. 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 (v2.1.170+, requires Fable 5 access)

Haiku cannot act as an advisor. If Fable 5 is the main model, only Fable 5 is allowed as the advisor.

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

Limitations

• 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 / Opus 4.8 / Opus 4.7: all 5 levels — low, medium, high, xhigh, max
• Opus 4.6 / Sonnet 4.6: low, medium, high, max (xhigh unsupported → falls back to high)
• 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

ultracode — a Claude Code setting, not an effort level

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.

Fast Mode

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 is Opus-only (4.8, 4.7, 4.6) — Fable 5 does not support it, and enabling fast mode on any other model automatically switches you to Opus.

adaptive reasoning

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 — 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

Practical advice

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.