Skip to main content

Multi-Model Strategy

Claude Fable 5.2 (November 9, 2026)

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โ€‹

ModelCharacteristicsBest forRelative cost
Fable 5.2API: 1M context, $8/$40 input/output, $0.20 cache readsHard reasoning or long-running agent work when higher-effort Opus evaluations do not meet requirements$$$$$
Opus 5.5Latest Opus API model; 1M context, $4/$20 input/outputComplex coding and reasoning$$$$
Sonnet 5.5Balanced performance; 1M context, $2/$10 input/outputEveryday coding, reviews, documentation$$$
Haiku 5.5Fastest family; pricing varies by prompt lengthSimple 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.

Check your account's available models

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:

PairingWhen it fits
Sonnet main + Opus advisorSonnet handles everyday work; planning, repeated errors, and completion reviews are delegated to Opus
Opus main + Opus advisorHigh-stakes work that needs an independent second review
Haiku main + Opus advisorLowest-cost main model for routine work, with Opus for strong planning
Fable main + Fable advisorMaximum-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โ€‹

MethodWhen the strong model steps inWho initiates
AdvisorAt decision points during the taskClaude decides to invoke it
opusplanOnly when entering Plan mode; execution stays on SonnetUser enters Plan mode
SubagentFor the entire delegated subtaskClaude delegates, or the user invokes directly
/model switchEvery turn after the switchUser 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:

LevelDescriptionBest for
lowFast and cheap, minimal thinkingShort, narrowly scoped tasks
mediumToken-saving, cost-sensitive workEveryday coding tasks
highBalanced (Opus 4.8 default)Most coding tasks
xhighDeeper reasoning, more tokens (Opus 4.7 default)Architecture design, hard bugs
maxMaximum 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 (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 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.

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

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.

Have you completed this chapter?

Mark your progress to increase your roadmap completion.