Best model for Claude Code

The best model for Claude Code for most daily repository work is Claude Sonnet 5.5. It costs $2 per million input tokens and $10 per million output tokens, half the price of Opus 5.5, and it still carries a 1M-token context window, so it handles most edits, tests and refactors without losing reach. Move to Opus 5.5 at $4/$20 when the work spans several files or Sonnet stalls. Keep Fable 5.1 at $10/$50 for the hardest, longest agent sessions, and use Haiku 5.5 from $0.10/$0.50 when speed matters more than depth.

Updated October 24, 2026: now covers Sonnet 5.5, Opus 5.5 and Haiku 5.5.

Anthropic's model guide says most work starts with Claude Opus 5.5 (checked October 24, 2026), and its pricing page calls Opus 5.5 the "daily driver for agentic coding". That makes Opus 5.5 a safe default when cost is not your constraint. Sonnet 5.5 is the better default when you count what each finished change costs: same 1M-token window, half the token price, and enough skill for everyday edits, tests and refactors.

For the two 5.5 models side by side, read the Opus 5.5 vs Sonnet 5.5 comparison. It walks through API rates, benchmark conditions and effort settings. For the cheaper tier across providers, the Haiku 4.5 vs GPT-5.6 Luna comparison counts the cost of a solved task instead of the token price alone.

Best model for Claude Code at a glance

All four models take a 1M-token context window and return up to 128K output tokens. Haiku 5.5 has a two-step input price: $0.10 per million tokens for prompts of up to 100K tokens and $0.50 per million above that, with cache reads at $0.01 per million on the smaller tier. The rates are Anthropic's list prices (pricing page checked October 24, 2026); what you pay through OmniaKey is on the pricing page.

Here is what a typical request costs. Take 30,000 input tokens of code and instructions plus 5,000 output tokens of patch and explanation:

• Sonnet 5.5: 0.03 × $2 = $0.06 in, 0.005 × $10 = $0.05 out, so $0.11.
• Opus 5.5: 0.03 × $4 = $0.12 in, 0.005 × $20 = $0.10 out, so $0.22.
• Fable 5.1: 0.03 × $10 = $0.30 in, 0.005 × $50 = $0.25 out, so $0.55.
• Haiku 5.5: 0.03 × $0.10 = $0.003 in, 0.005 × $0.50 = $0.0025 out, so about half a cent.

At 100 requests a day that is $11 a day on Sonnet 5.5, $22 on Opus 5.5, $55 on Fable 5.1 and $0.55 on Haiku 5.5. Over a 20-day month the totals are $220, $440, $1,100 and $11.

One rule that works today: start on Sonnet 5.5 and move up only when a task asks for more.

Why Sonnet 5.5 is the best daily default

Sonnet 5.5 is Anthropic's "high-performance model for coding and agents", and the Claude Code sonnet alias points at it on the Anthropic API. Start here for work such as:

• adding a scoped feature with its tests;
• tracing a familiar error through a few files;
• updating tests next to a local change;
• reviewing a focused pull request;
• turning an agreed design into code;
• running ordinary repository searches through subagents.

Two numbers keep it in the default slot. The price is $2 in and $10 out per million tokens, half of Opus 5.5's $4/$20, so the request above costs $0.11 instead of $0.22. Cache reads cost $0.10 per million tokens, which keeps a long, stable prompt prefix cheap to reuse. The second number is reach: 1M tokens of context and 128K of output, the same headline capacity as Opus 5.5 and Fable 5.1.

Capacity is not skill. A million tokens can hold more of your repository, and the model still has to pick the right file and the right fix. When Sonnet 5.5 misses the same class of problem after a clean attempt, move up a tier instead of pasting in more code.

Pin the exact ID when you want a repeatable result:

/model claude-sonnet-5-5

Sonnet 5.5 needs Claude Code v2.1.284 or later. Run claude update if it does not appear in the picker.

When Claude Opus 5.5 is worth it

Choose Opus 5.5 when the reasoning is the expensive part of the task, not the typing. Anthropic's pricing page calls it the "daily driver for agentic coding and enterprise work", and its model guide says most work should start there. At $4/$20 per million tokens it costs twice what Sonnet 5.5 does, and it runs at medium effort by default rather than high.

The usual signals:

• the bug crosses several services and the obvious explanation is wrong;
• the repository is unfamiliar and the request leaves important choices open;
• an architecture or migration decision will be costly to reverse;
• a broad refactor must preserve behavior nobody wrote down;
• security, billing or data-integrity mistakes are expensive to fix later;
• Sonnet 5.5 had the relevant files, made a serious attempt, and is still wrong.

Per-token price is not the cost of a finished change. A stronger model can reach a correct result in fewer failed loops and fewer minutes of your review time; on a one-file edit with a clear test, that advantage rarely shows up.

/model claude-opus-5-5

Opus 5.5 needs Claude Code v2.1.280 or later.

For the current generation, the Opus 5.5 vs Sonnet 5.5 comparison is the direct call. If you still pin the previous snapshot, the Opus 5 review and the Opus 5 vs Sonnet 5 comparison describe that generation, and older models such as Opus 5 remain on Anthropic's pricing page at $5/$25.

When Fable 5.1 earns its premium

Fable 5.1 is Anthropic's most capable widely released model: "next generation intelligence for long-running agents", at $10/$50 per million tokens with a $0.25 cache read and high effort by default. The fable alias resolves to it unless ANTHROPIC_DEFAULT_FABLE_MODEL is set, and best follows whatever fable resolves to.

That makes Fable 5.1 a specialist rather than the everyday choice. Test it when:

• a root-cause investigation is still open after a careful Opus 5.5 attempt;
• Opus 5.5 at higher effort still misses a demanding evaluation;
• the work must stay coherent for hours across many tools and files;
• a failure is expensive enough that your own numbers justify the premium.

Do not pay the Fable rate just because a repository is large. Clear scope, focused context and a reliable test usually matter more than the tier. Fable earns its price when the problem itself stretches Opus, not when the prompt is vague.

/model claude-fable-5-1

Fable 5.1 needs Claude Code v2.1.255 or later. No account type defaults to it, and whether it shows in the picker depends on your organization, your provider and your usage credits.

The Fable 5.1 review and API guide covers its always-on adaptive thinking, the lower cache-read price and the exact IDs. Waiting for a newer Fable? The Fable 5.5 status tracker lists what Anthropic has confirmed so far, and Fable 5.1 is the newest Fable you can run today. Still testing the older Fable 5? Its rates and model ID are in the Fable 5 pricing guide.

Where Haiku 5.5 fits

Haiku 5.5 is Anthropic's "fastest, most cost-efficient model": from $0.10 per million input tokens and $0.50 per million output tokens, with a 1M-token context window and medium effort by default. It fits narrow work with a clear check:

• locating files or symbols before the main agent starts;
• summarizing bounded logs or test output;
• classifying issues into a known list of labels;
• making repetitive edits protected by a deterministic test;
• answering focused questions about code already in context.

Haiku 5.5 stops paying off when one small mistake starts a chain of retries. Move up as soon as it misses relationships across files, misreads an unfamiliar domain, or needs the same correction twice. The cheap tier also has a step: prompts above 100K tokens cost $0.50 per million input tokens instead of $0.10, so send only the files the task needs.

For a dedicated lightweight subagent, set the model in its frontmatter:

---
name: quick-researcher
description: Finds files and summarizes notes for a scoped repository question
model: haiku
---

Subagents inherit the main model when model is missing. Pinning haiku keeps every delegated lookup off your Opus 5.5 or Fable 5.1 budget. For implementation and review subagents, start with Sonnet 5.5.

Model versus effort: change the right control

Model choice and effort fix different failures. Fable 5.1 and Sonnet 5.5 start at high effort; Opus 5.5 and Haiku 5.5 start at medium. Begin at the default and change one thing at a time.

Change the model when the task is too hard. If Claude has the files, the tools and the instructions, explores properly, and still lands on the wrong answer, move from Haiku 5.5 to Sonnet 5.5, from Sonnet 5.5 to Opus 5.5, or from Opus 5.5 to Fable 5.1.

Raise effort when the chosen model needs more thinking. A higher setting helps with deeper planning and longer analysis, and it also adds latency and output cost.

Fix the prompt first. A vague request, a stale CLAUDE.md, missing docs or a tool that is not connected will not improve with a bigger model. State the success condition and put the needed files in front of the model.

Anthropic's selection guide says tuning effort is often a better lever than switching models. Check that on your own tasks: if a high-effort Opus 5.5 run still fails your test, Fable 5.1 is the next tier.

What best, fable, and opusplan actually select

On the Anthropic API, opus, sonnet and haiku resolve to Opus 5.5, Sonnet 5.5 and Haiku 5.5. Amazon Bedrock and Google Cloud can point the same aliases at older versions such as Sonnet 4.5 and Haiku 4.5, so read the model name in the response before you trust a result.

ANTHROPIC_BASE_URL changes where requests go, not which model answers. A gateway that does not serve claude-fable-5-1 rejects that request, and /model claude-fable-5-1 works only when the gateway serves it.

Use aliases for interactive work. Use exact IDs in evaluations, automation and incident notes.

A practical plan for switching models

Switch at task changes, not every few turns:

1. Start routine features and maintenance on Sonnet 5.5 at its default effort.
2. Keep Haiku 5.5 for small, isolated subagents with a deterministic check.
3. Start on Opus 5.5 when ambiguity, architecture or failure cost is already high.
4. Try more Opus 5.5 effort before paying for Fable 5.1.
5. Move to Fable 5.1 when a demanding task or your own results justify it.
6. Drop back to Sonnet 5.5 once the hard decision is made and the rest is mechanical.

Switching models mid-conversation can cut prompt-cache reuse, which makes the next turn slower and dearer. Switch at a clean break, and use /clear for an unrelated task instead of carrying an old session into a new model.

Compare models on accepted changes, not impressions

The Claude Code token-usage guide covers the context and session controls behind this number without making the test easier.

A fair local test uses the same repository state, prompt, tools, permissions, effort and pass/fail check for every model. Build a small set that looks like your real work:

Run each task more than once, because agent output varies. Record the result, your correction minutes, elapsed time, input tokens, cache tokens, output tokens and tool calls. A model that costs twice as much per token can still be cheaper per finished change, and a cheaper model that passes the same check wins that task class.

Do not change model and effort in the same first comparison. Hold effort at the default while you compare models, then sweep effort on the model you plan to use. Otherwise you cannot tell whether skill or thinking budget made the difference.

How to switch models on OmniaKey

Setup lives in the Claude Code setup guide. Once the Anthropic-compatible endpoint is configured, point Claude Code at OmniaKey with two variables:

ANTHROPIC_BASE_URL=https://api.omniakey.com
ANTHROPIC_AUTH_TOKEN=<your OmniaKey API key>

Then pick a model:

/model claude-haiku-5-5
/model claude-sonnet-5-5
/model claude-opus-5-5
/model claude-fable-5-1

Update Claude Code if a model is missing: Sonnet 5.5 needs v2.1.284 or later, Opus 5.5 needs v2.1.280 or later, and Fable 5.1 needs v2.1.255 or later. Run claude update, reopen the picker and confirm the model in the live model catalog.

For work you need to reproduce, request the exact ID and read the model name in the response. Availability shifts by provider and organization, so an error should stop the run instead of looking like a finished task.

Claude Code is built for Claude models, and Anthropic does not support pointing it at GPT or Gemini through a gateway. If you are choosing between families, start with the coding-model guide, then compare the products in Claude Code vs Codex. For the everyday cross-provider call, read the Sonnet 5 vs GPT-5.6 Terra comparison.

Final recommendation

For most developers who pay for daily throughput, Sonnet 5.5 is the best default model for Claude Code at $2/$10. Start Opus 5.5 at $4/$20 when a task is already ambiguous or expensive to get wrong, keep Haiku 5.5 for quick subagents and short edits, and move to Fable 5.1 at $10/$50 only when the longest, hardest sessions justify it.

Treat that as a starting point. Your own accepted-change data should decide where each threshold sits.

Frequently asked questions

What is the best model for Claude Code?

Claude Sonnet 5.5 is the best default for daily coding at $2/$10 per million tokens. Opus 5.5 at $4/$20 is the stronger starting point for complex multi-file work and expensive failures. Fable 5.1 at $10/$50 covers the hardest long sessions, and Haiku 5.5 from $0.10/$0.50 handles quick edits, subagents and sorting.

Is Opus 5.5 better than Sonnet 5.5?

Opus 5.5 is stronger on hard, ambiguous work; Sonnet 5.5 is faster and half the price on routine tasks. Anthropic's model guide starts most work on Opus 5.5, while Claude Code gives Sonnet the daily-coding role. Choose by what a wrong answer costs, then count finished changes.

Do I need a newer Claude Code for the 5.5 models?

Yes. Sonnet 5.5 needs v2.1.284 or later and Opus 5.5 needs v2.1.280 or later. Run claude update, reopen the picker and check that the model name appears.

Should every large repository use Fable 5.1?

No. Size alone does not justify the $10/$50 rate. Give Sonnet 5.5 or Opus 5.5 focused context first, then test Fable 5.1 when the task is genuinely long, open-ended and beyond the cheaper models.

Which model should Claude Code subagents use?

Haiku 5.5 for narrow searches, classification and summaries with a clear check. Sonnet 5.5 for implementation, review and coordination. Let a subagent inherit Opus 5.5 or Fable 5.1 only when its own task needs that skill.

Does higher effort equal a better model?

No. The model sets the ceiling; effort sets how much thinking the model spends. Raise effort when a task needs deeper analysis, and change the model when it has tried properly and still cannot pass.

Can Claude Code use GPT or Gemini models?

No. Anthropic builds Claude Code for Claude models and does not support sending it to GPT or Gemini through a gateway. Use Codex, Cursor, Cline, aider or another compatible agent for those models.

Sources checked

Rates, aliases and version floors come from Anthropic's docs and pricing page, opened on October 24, 2026.

• Anthropic: Claude Code model configuration
• Anthropic: choosing the right Claude model
• Anthropic: Claude models overview
• Anthropic: API pricing
• Anthropic: Claude Fable 5.1 overview
• Anthropic: manage Claude Code costs
• Anthropic: Claude Code subagents
• Anthropic: Claude Code prompt caching
• Anthropic: LLM gateways