Best model for Claude Code

The best model for Claude Code for most daily repository work is Claude Sonnet 5. It is the efficiency-first default: fast, capable, equipped with a native 1-million-token context window, and less expensive per token than Opus or Fable. Start with Claude Opus 5 instead when correctness matters more than throughput or the task is ambiguous, architectural, or costly to get wrong. Use Claude Haiku 4.5 for narrow work with a clear check, and reserve Claude Fable 5.1 for demanding, long-horizon tasks that remain beyond Opus.

That recommendation is a routing policy, not a universal leaderboard. Anthropic's general model guide says most workloads can start with Opus 5, while Claude Code's aliases describe Sonnet as the daily-coding option and Opus as the complex-reasoning option. This guide chooses Sonnet as the daily default for readers optimizing accepted-change cost; a capability-first team can reasonably start on Opus.

For the budget cross-provider decision, read the Claude Haiku 4.5 vs GPT-5.6 Luna coding comparison. It separates Claude Code protocol fit from token price and compares accepted-task cost instead of declaring a universal winner.

Best model for Claude Code at a glance

Prices are USD per million input and output tokens, before prompt-cache, long-context, fast-mode, or tool charges. Anthropic and OmniaKey are separate billing boundaries: the OmniaKey column is the gateway quote in the repository catalog checked on September 8, 2026, not a calculation from Anthropic's current list price or a subscription allowance. Confirm the current route and rate in the model catalog before budgeting production work.

If you want one rule to apply today, use Sonnet 5 as the efficiency-first default and escalate by task. The best model is the least expensive one that reliably produces an accepted change, not the one with the largest benchmark number.

Why Sonnet 5 is the best daily default

Anthropic describes Sonnet 5 as its best combination of speed and intelligence, and the Claude Code sonnet alias is intended for daily coding. It is a sensible starting point for work such as:

• implementing a scoped feature with clear acceptance criteria;
• tracing a familiar error through a few files;
• writing or updating tests alongside a local change;
• reviewing a focused pull request;
• translating a decided design into code;
• coordinating ordinary repository research through subagents.

Sonnet 5 has a native 1M context window, so choosing it no longer means giving up the long context available on current Opus and Fable models. Context capacity is not the same as capability, however. A million tokens can hold more evidence; it does not guarantee that the model will identify the right architecture or a subtle failure mode.

Use the exact model ID when you want a pinned evaluation:

/model claude-sonnet-5

Dateless Claude 5 API IDs are pinned snapshots. Claude Code aliases can still resolve differently by provider or change as recommendations evolve, so an exact ID makes an evaluation easier to reproduce.

When Claude Opus 5 is worth the higher price

Choose Claude Opus 5 when the expensive part of the task is reasoning rather than typing. Typical signals include:

• 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 implicit behavior across many files;
• security, billing, or data-integrity mistakes have a high correction cost;
• Sonnet has the relevant context, made a serious attempt, and is still wrong.

Opus 5 costs more per token, but per-token price is not completed-task cost. On difficult work, a stronger model may reach an accepted result in fewer failed loops and with less human correction. On a precise one-file edit, that advantage may never have a chance to appear.

/model claude-opus-5

Anthropic's capability-first guidance starts most workloads on Opus 5 and then optimizes downward. That is a defensible policy when a missed edge case is expensive. For published evidence, effort behavior, migration notes, and limits, read the Claude Opus 5 review. For a direct two-model decision, use the Claude Opus 5 vs Sonnet 5 comparison.

When Fable 5.1 earns its premium

Claude Fable 5.1 is Anthropic's most capable widely released model. Claude Code positions the Fable family for work larger than a single sitting: long autonomous sessions, demanding reasoning, and tasks that benefit from investigating before acting and verifying throughout.

That makes Fable 5.1 a specialist rather than the routine default. Test it when:

• a root-cause investigation remains unresolved after a careful Opus 5 attempt;
• Opus 5 at xhigh or max still misses a demanding evaluation;
• the work must stay coherent for hours across many tools and artifacts;
• failure is expensive enough that your evaluation data justifies the premium.

Do not pay the Fable rate merely because a repository contains many files. Clear scope, focused context, and a reliable acceptance test often matter more than model tier. Fable is valuable when the problem itself stretches Opus, not when the prompt is underspecified.

/model claude-fable-5-1

Fable 5.1 requires Claude Code v2.1.255 or later. The fable alias resolves to Fable 5.1 unless it is overridden; before v2.1.255 it resolved to Fable 5. The model is never the account-type default, and picker visibility can depend on organization, provider, and usage-credit availability.

The Claude Fable 5.1 review and API guide covers its always-on adaptive thinking, lower cache-read price, migration constraints, and exact IDs. The older Fable 5 model page and Fable 5 pricing guide remain useful only when you deliberately evaluate the previous model.

Where Haiku 4.5 fits

Claude Haiku 4.5 is the fastest model in Anthropic's current comparison and has a 200K context window. It is a good fit when the task is narrow, the success condition is explicit, and a mistake is cheap to catch:

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

Haiku is not economical if a small mistake creates several expensive retries. Escalate when it misses relationships across files, misunderstands an unfamiliar domain, or needs repeated correction. The current model table does not expose the same effort control for Haiku 4.5, so do not design a routing policy that assumes it can be tuned like Sonnet, Opus, or Fable.

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

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

Claude Code subagents inherit the main model when model is omitted. Pinning haiku for bounded research prevents every delegated lookup from using the main session's Opus or Fable tier. For implementation or review subagents, Sonnet is the safer starting point.

Model versus effort: change the right control

Model selection and effort solve different failures. Fable 5.1, Opus 5, and Sonnet 5 support adaptive thinking and an effort control; the current Claude API default is high for all three. Start there and change one variable at a time.

Change the model when the problem is too hard. If Claude has the relevant files, tools, and instructions, explores the task properly, and still reaches the wrong conclusion, move from Haiku to Sonnet, Sonnet to Opus, or Opus to Fable.

Raise effort when the selected model needs more reasoning. Use a higher level when the task requires deeper planning, longer-horizon analysis, or more checking. Higher effort can improve completion, but it can also increase latency and output-token cost.

Fix the context before either. A vague request, stale CLAUDE.md, missing documentation, or unavailable tool cannot be repaired reliably by spending more tokens. First make the success condition and evidence available.

Anthropic's current selection guide says tuning effort is often a better lever than switching models. Test that claim on your workload: if a higher-effort Opus run still misses the acceptance test, Fable 5.1 becomes the next capability tier.

What best, fable, and opusplan actually select

Claude Code aliases are convenient, but they are not all fixed model IDs.

On the direct Anthropic API, opus and sonnet currently resolve to Opus 5 and Sonnet 5. Other providers can resolve those aliases to earlier versions. A gateway changes the destination and may define its own model options; it does not turn an alias into a cross-provider guarantee.

Use aliases for interactive convenience. Use exact IDs in evaluations, automation, incident reproduction, and any record that must say which model actually ran.

A practical routing policy

Use task boundaries instead of switching models every few turns:

1. Start routine feature and maintenance work on Sonnet 5 at its default effort.
2. Keep Haiku 4.5 for small, isolated subagents with deterministic output.
3. Start on Opus 5 when ambiguity, architectural scope, or failure cost is already high.
4. Try more Opus effort before paying for Fable when the failure is insufficient reasoning depth.
5. Use Fable 5.1 when a demanding task or your evaluation set justifies the premium.
6. Drop back to Sonnet when the difficult decision is resolved and execution becomes mechanical.

Switching models inside a long conversation can reduce prompt-cache reuse, making the next turn slower and more expensive. Switch at a clean task boundary when possible. For unrelated work, /clear is usually better than carrying an old session into a new model.

Compare models on accepted changes, not impressions

For the context and session controls behind that metric, use the Claude Code token-usage guide. It explains how to reduce repeated context without making the evaluation artificially easy.

A fair local evaluation needs the same repository state, prompt, tools, permissions, effort, and acceptance test for every model. Build a small set that represents your actual work:

Run each task more than once because agent results vary. Record accepted outcome, human 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 accepted change; a cheaper model that passes the same test is the better choice for that task class.

Do not mix model and effort changes in the same first comparison. Hold effort at the default while comparing models, then sweep effort on the model you intend to deploy. Otherwise you cannot tell whether capability or reasoning budget caused the result.

How to switch models on OmniaKey

The connection steps belong in the Claude Code setup guide. Once the Anthropic-compatible endpoint is configured, use /model with an exact supported ID:

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

Update Claude Code if a current model is missing: Sonnet 5 requires v2.1.197 or later, Opus 5 requires v2.1.219 or later, and Fable 5.1 requires v2.1.255 or later. Run claude update, reopen the model picker, and confirm the route in the live catalog.

For reproducible work, request the exact model and inspect the returned model and usage instead of assuming an alias or silent fallback. Availability can change by provider, organization, and route; an error should stop the run rather than be treated as evidence that another model completed it.

Claude Code is designed for Claude models. Anthropic says a gateway can proxy supported API formats but does not support routing Claude Code to non-Claude models. If the decision is Claude versus GPT or Gemini, choose an agent that supports the required protocol. The coding-model family guide covers that broader question, while Claude Code vs Codex compares the agent products.

For the direct everyday cross-provider decision, use the Claude Sonnet 5 vs GPT-5.6 Terra coding comparison. It keeps the model question separate from the Claude Code-versus-Codex harness question.

Final recommendation

For most developers optimizing daily throughput and cost, Claude Sonnet 5 is the best default model for Claude Code. Start with Opus 5 when a task is already ambiguous or expensive to get wrong, use Haiku 4.5 for bounded support work, and move to Fable 5.1 only for demanding long-horizon work that Opus cannot pass at an appropriate effort.

Treat that as a routing baseline. 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 is the best efficiency-first default for most daily coding. Claude Opus 5 is the better capability-first starting point for complex architecture, subtle debugging, and expensive failures. Fable 5.1 targets the hardest long-running work, while Haiku 4.5 fits simple, bounded tasks.

Is Opus better than Sonnet for Claude Code?

Opus is more capable on difficult and ambiguous work, but Sonnet is faster and cheaper for routine tasks. Anthropic's general model guide starts most workloads on Opus; Claude Code labels Sonnet for daily coding. Choose according to failure cost and measure accepted changes.

Should I use Fable 5.1 or Fable 5?

Use Fable 5.1 for new evaluations. It is the newer release, the fable alias resolves to it on supported current clients, and it keeps the same base input and output price while lowering cache-read cost. Pin Fable 5 only when you need to reproduce a result on the previous model.

Should every large repository use Fable 5.1?

No. Repository size alone does not justify Fable. Use focused context and try Sonnet or Opus first, then test Fable when the task is genuinely long, ambiguous, and beyond the cheaper models.

Which model should Claude Code subagents use?

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

Does higher effort equal a better model?

No. The model controls the underlying capability; effort controls how much reasoning the supported model applies. Upgrade the model when it tried at an appropriate effort and still could not solve the problem. Raise effort before switching when the task simply needs deeper analysis.

Can Claude Code use GPT or Gemini models?

No. Anthropic documents Claude Code as designed for Claude models and does not support routing it to non-Claude models through a gateway. Use Codex, Cursor, Cline, aider, or another compatible agent for GPT or Gemini.

Sources checked

• 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