Skip to main content

​
Available models

For the model setting in Claude Code, you can configure either:
  • A model alias
  • A model name
    • Anthropic API: A full model name
    • Bedrock: an inference profile ARN
    • Foundry: a deployment name
    • Vertex: a version name

​
Model aliases

Model aliases provide a convenient way to select model settings without remembering exact version numbers:
Model aliasBehavior
defaultSpecial value that clears any model override and reverts to the recommended model for your account type. Not itself a model alias
bestUses the most capable available model, currently equivalent to opus
sonnetUses the latest Sonnet model for daily coding tasks
opusUses the latest Opus model for complex reasoning tasks
haikuUses the fast and efficient Haiku model for simple tasks
sonnet[1m]Uses Sonnet with a 1 million token context window for long sessions
opus[1m]Uses Opus with a 1 million token context window for long sessions
opusplanSpecial mode that uses opus during plan mode, then switches to sonnet for execution
On the Anthropic API, opus resolves to Opus 4.7 and sonnet resolves to Sonnet 4.6. On Bedrock, Vertex, and Foundry, opus resolves to Opus 4.6 and sonnet resolves to Sonnet 4.5; newer models are available on those providers by selecting the full model name explicitly or setting ANTHROPIC_DEFAULT_OPUS_MODEL or ANTHROPIC_DEFAULT_SONNET_MODEL. Aliases point to the recommended version for your provider and update over time. To pin to a specific version, use the full model name (for example, claude-opus-4-7) or set the corresponding environment variable like ANTHROPIC_DEFAULT_OPUS_MODEL.
Opus 4.7 requires Claude Code v2.1.111 or later. Run claude update to upgrade.

​
Setting your model

You can configure your model in several ways, listed in order of priority:
  1. During session - Use /model <alias|name> to switch immediately, or run /model with no argument to open the picker. The picker asks for confirmation when the conversation has prior output, since the next response re-reads the full history without cached context
  2. At startup - Launch with claude --model <alias|name>
  3. Environment variable - Set ANTHROPIC_MODEL=<alias|name>
  4. Settings - Configure permanently in your settings file using the model field.
Example usage: 
# Start with Opus
claude --model opus

# Switch to Sonnet during session
/model sonnet
Example settings file: 
{
    "permissions": {
        ...
    },
    "model": "opus"
}

​
Restrict model selection

Enterprise administrators can use availableModels in managed or policy settings to restrict which models users can select. When availableModels is set, users cannot switch to models not in the list via /model, --model flag, Config tool, or ANTHROPIC_MODEL environment variable. 
{
  "availableModels": ["sonnet", "haiku"]
}

​
Default model behavior

The Default option in the model picker is not affected by availableModels. It always remains available and represents the system’s runtime default based on the user’s subscription tier. Even with availableModels: [], users can still use Claude Code with the Default model for their tier.

​
Control the model users run on

The model setting is an initial selection, not enforcement. It sets which model is active when a session starts, but users can still open /model and pick Default, which resolves to the system default for their tier regardless of what model is set to. To fully control the model experience, combine three settings:
  • availableModels: restricts which named models users can switch to
  • model: sets the initial model selection when a session starts
  • ANTHROPIC_DEFAULT_SONNET_MODEL / ANTHROPIC_DEFAULT_OPUS_MODEL / ANTHROPIC_DEFAULT_HAIKU_MODEL: control what the Default option and the sonnet, opus, and haiku aliases resolve to
This example starts users on Sonnet 4.5, limits the picker to Sonnet and Haiku, and pins Default to resolve to Sonnet 4.5 rather than the latest release: 
{
  "model": "claude-sonnet-4-5",
  "availableModels": ["claude-sonnet-4-5", "haiku"],
  "env": {
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-5"
  }
}
Without the env block, a user who selects Default in the picker would get the latest Sonnet release, bypassing the version pin in model and availableModels.

​
Merge behavior

When availableModels is set at multiple levels, such as user settings and project settings, arrays are merged and deduplicated. To enforce a strict allowlist, set availableModels in managed or policy settings which take highest priority.

​
Mantle model IDs

When the Bedrock Mantle endpoint is enabled, entries in availableModels that start with anthropic. are added to the /model picker as custom options and routed to the Mantle endpoint. This is an exception to the alias-only matching described in Pin models for third-party deployments. The setting still restricts the picker to listed entries, so include the standard aliases alongside any Mantle IDs.

​
Special model behavior

​
default model setting

The behavior of default depends on your account type:
  • Max and Team Premium: defaults to Opus 4.7
  • Pro, Team Standard, Enterprise, and Anthropic API: defaults to Sonnet 4.6
  • Bedrock, Vertex, and Foundry: defaults to Sonnet 4.5
Claude Code may automatically fall back to Sonnet if you hit a usage threshold with Opus.
On April 23, 2026, the default model for Enterprise pay-as-you-go and Anthropic API users will change to Opus 4.7. To keep a different default, set ANTHROPIC_MODEL or the model field in server-managed settings.

​
opusplan model setting

The opusplan model alias provides an automated hybrid approach:
  • In plan mode - Uses opus for complex reasoning and architecture decisions
  • In execution mode - Automatically switches to sonnet for code generation and implementation
This gives you the best of both worlds: Opus’s superior reasoning for planning, and Sonnet’s efficiency for execution. The plan-mode Opus phase runs with the standard 200K context window. The automatic 1M upgrade described in Extended context applies to the opus model setting and does not extend to opusplan.

​
Adjust effort level

Effort levels control adaptive reasoning, which lets the model decide whether and how much to think on each step based on task complexity. Lower effort is faster and cheaper for straightforward tasks, while higher effort provides deeper reasoning for complex problems. Effort is supported on Opus 4.7, Opus 4.6, and Sonnet 4.6. The available levels depend on the model:
ModelLevels
Opus 4.7low, medium, high, xhigh, max
Opus 4.6 and Sonnet 4.6low, medium, high, max
If you set a level the active model does not support, Claude Code falls back to the highest supported level at or below the one you set. For example, xhigh runs as high on Opus 4.6. On Opus 4.7, the default effort is xhigh for all plans and providers. On Opus 4.6 and Sonnet 4.6, the default is high, or medium on Pro and Max. When you first run Opus 4.7, Claude Code applies xhigh even if you previously set a different effort level for Opus 4.6 or Sonnet 4.6. Run /effort again to choose a different level after switching. low, medium, high, and xhigh persist across sessions. max provides the deepest reasoning with no constraint on token spending and applies to the current session only, except when set through the CLAUDE_CODE_EFFORT_LEVEL environment variable.

​
Choose an effort level

Each level trades token spend against capability. The default suits most coding tasks; adjust when you want a different balance.
LevelWhen to use it
lowReserve for short, scoped, latency-sensitive tasks that are not intelligence-sensitive
mediumReduces token usage for cost-sensitive work that can trade off some intelligence
highBalances token usage and intelligence. Use as a minimum for intelligence-sensitive work, or to reduce token spend relative to xhigh
xhighBest results for most coding and agentic tasks. Recommended default on Opus 4.7
maxCan improve performance on demanding tasks but may show diminishing returns and is prone to overthinking. Test before adopting broadly
The effort scale is calibrated per model, so the same level name does not represent the same underlying value across models. For one-off deep reasoning without changing your session setting, include “ultrathink” in your prompt. This adds an in-context instruction telling the model to reason more on that turn; it does not change the effort level sent to the API.

​
Set the effort level

You can change effort through any of the following:
  • /effort: run /effort with no arguments to open an interactive slider, /effort followed by a level name to set it directly, or /effort auto to reset to the model default
  • In /model: use left/right arrow keys to adjust the effort slider when selecting a model
  • --effort flag: pass a level name to set it for a single session when launching Claude Code
  • Environment variable: set CLAUDE_CODE_EFFORT_LEVEL to a level name or auto
  • Settings: set effortLevel in your settings file
  • Skill and subagent frontmatter: set effort in a skill or subagent markdown file to override the effort level when that skill or subagent runs
The environment variable takes precedence over all other methods, then your configured level, then the model default. Frontmatter effort applies when that skill or subagent is active, overriding the session level but not the environment variable. The effort slider appears in /model when a supported model is selected. The current effort level is also displayed next to the logo and spinner, for example “with low effort”, so you can confirm which setting is active without opening /model.

​
Adaptive reasoning and fixed thinking budgets

Adaptive reasoning makes thinking optional on each step, so Claude can respond faster to routine prompts and reserve deeper thinking for steps that benefit from it. If you want Claude to think more or less often than the current level produces, you can say so directly in your prompt or in CLAUDE.md; the model responds to that guidance within its effort setting. Opus 4.7 always uses adaptive reasoning. The fixed thinking budget mode and CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING do not apply to it. On Opus 4.6 and Sonnet 4.6, you can set CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 to revert to the previous fixed thinking budget controlled by MAX_THINKING_TOKENS. See environment variables.

​
Extended context

Opus 4.7, Opus 4.6, and Sonnet 4.6 support a 1 million token context window for long sessions with large codebases. Availability varies by model and plan. On Max, Team, and Enterprise plans, Opus is automatically upgraded to 1M context with no additional configuration. This applies to both Team Standard and Team Premium seats.
PlanOpus with 1M contextSonnet with 1M context
Max, Team, and EnterpriseIncluded with subscriptionRequires extra usage
ProRequires extra usageRequires extra usage
API and pay-as-you-goFull accessFull access
To disable 1M context entirely, set CLAUDE_CODE_DISABLE_1M_CONTEXT=1. This removes 1M model variants from the model picker. See environment variables. The 1M context window uses standard model pricing with no premium for tokens beyond 200K. For plans where extended context is included with your subscription, usage remains covered by your subscription. For plans that access extended context through extra usage, tokens are billed to extra usage. If your account supports 1M context, the option appears in the model picker (/model) in the latest versions of Claude Code. If you don’t see it, try restarting your session. You can also use the [1m] suffix with model aliases or full model names: 
# Use the opus[1m] or sonnet[1m] alias
/model opus[1m]
/model sonnet[1m]

# Or append [1m] to a full model name
/model claude-opus-4-7[1m]

​
Checking your current model

You can see which model you’re currently using in several ways:
  1. In status line (if configured)
  2. In /status, which also displays your account information.

​
Add a custom model option

Use ANTHROPIC_CUSTOM_MODEL_OPTION to add a single custom entry to the /model picker without replacing the built-in aliases. This is useful for LLM gateway deployments or testing model IDs that Claude Code does not list by default. This example sets all three variables to make a gateway-routed Opus deployment selectable: 
export ANTHROPIC_CUSTOM_MODEL_OPTION="my-gateway/claude-opus-4-7"
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="Opus via Gateway"
export ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION="Custom deployment routed through the internal LLM gateway"
The custom entry appears at the bottom of the /model picker. ANTHROPIC_CUSTOM_MODEL_OPTION_NAME and ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION are optional. If omitted, the model ID is used as the name and the description defaults to Custom model (<model-id>). Claude Code skips validation for the model ID set in ANTHROPIC_CUSTOM_MODEL_OPTION, so you can use any string your API endpoint accepts.

​
Environment variables

You can use the following environment variables, which must be full model names (or equivalent for your API provider), to control the model names that the aliases map to.
Environment variableDescription
ANTHROPIC_DEFAULT_OPUS_MODELThe model to use for opus, or for opusplan when Plan Mode is active.
ANTHROPIC_DEFAULT_SONNET_MODELThe model to use for sonnet, or for opusplan when Plan Mode is not active.
ANTHROPIC_DEFAULT_HAIKU_MODELThe model to use for haiku, or background functionality
CLAUDE_CODE_SUBAGENT_MODELThe model to use for subagents
Note: ANTHROPIC_SMALL_FAST_MODEL is deprecated in favor of ANTHROPIC_DEFAULT_HAIKU_MODEL.

​
Pin models for third-party deployments

When deploying Claude Code through Bedrock, Vertex AI, or Foundry, pin model versions before rolling out to users. Without pinning, Claude Code uses model aliases (sonnet, opus, haiku) that resolve to the latest version. When Anthropic releases a new model that isn’t yet enabled in a user’s account, Bedrock and Vertex AI users see a notice and fall back to the previous version for that session, while Foundry users see errors because Foundry has no equivalent startup check.
Set all three model environment variables to specific version IDs as part of your initial setup. Pinning lets you control when your users move to a new model.
Use the following environment variables with version-specific model IDs for your provider:
ProviderExample
Bedrockexport ANTHROPIC_DEFAULT_OPUS_MODEL='us.anthropic.claude-opus-4-7'
Vertex AIexport ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-7'
Foundryexport ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-7'
Apply the same pattern for ANTHROPIC_DEFAULT_SONNET_MODEL and ANTHROPIC_DEFAULT_HAIKU_MODEL. For current and legacy model IDs across all providers, see Models overview. To upgrade users to a new model version, update these environment variables and redeploy. To enable extended context for a pinned model, append [1m] to the model ID in ANTHROPIC_DEFAULT_OPUS_MODEL or ANTHROPIC_DEFAULT_SONNET_MODEL: 
export ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-7[1m]'
The [1m] suffix applies the 1M context window to all usage of that alias, including opusplan. Claude Code strips the suffix before sending the model ID to your provider. Only append [1m] when the underlying model supports 1M context, such as Opus 4.7 or Sonnet 4.6.
The settings.availableModels allowlist still applies when using third-party providers. Filtering matches on the model alias (opus, sonnet, haiku), not the provider-specific model ID.

​
Customize pinned model display and capabilities

When you pin a model on a third-party provider, the provider-specific ID appears as-is in the /model picker and Claude Code may not recognize which features the model supports. You can override the display name and declare capabilities with companion environment variables for each pinned model. These variables only take effect on third-party providers such as Bedrock, Vertex AI, and Foundry. They have no effect when using the Anthropic API directly.
Environment variableDescription
ANTHROPIC_DEFAULT_OPUS_MODEL_NAMEDisplay name for the pinned Opus model in the /model picker. Defaults to the model ID when not set
ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTIONDisplay description for the pinned Opus model in the /model picker. Defaults to Custom Opus model when not set
ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIESComma-separated list of capabilities the pinned Opus model supports
The same _NAME, _DESCRIPTION, and _SUPPORTED_CAPABILITIES suffixes are available for ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL, and ANTHROPIC_CUSTOM_MODEL_OPTION. Claude Code enables features like effort levels and extended thinking by matching the model ID against known patterns. Provider-specific IDs such as Bedrock ARNs or custom deployment names often don’t match these patterns, leaving supported features disabled. Set _SUPPORTED_CAPABILITIES to tell Claude Code which features the model actually supports:
Capability valueEnables
effortEffort levels and the /effort command
xhigh_effortThe xhigh effort level
max_effortThe max effort level
thinkingExtended thinking
adaptive_thinkingAdaptive reasoning that dynamically allocates thinking based on task complexity
interleaved_thinkingThinking between tool calls
When _SUPPORTED_CAPABILITIES is set, listed capabilities are enabled and unlisted capabilities are disabled for the matching pinned model. When the variable is unset, Claude Code falls back to built-in detection based on the model ID. This example pins Opus to a Bedrock custom model ARN, sets a friendly name, and declares its capabilities: 
export ANTHROPIC_DEFAULT_OPUS_MODEL='arn:aws:bedrock:us-east-1:123456789012:custom-model/abc'
export ANTHROPIC_DEFAULT_OPUS_MODEL_NAME='Opus via Bedrock'
export ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION='Opus 4.7 routed through a Bedrock custom endpoint'
export ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES='effort,xhigh_effort,max_effort,thinking,adaptive_thinking,interleaved_thinking'

​
Override model IDs per version

The family-level environment variables above configure one model ID per family alias. If you need to map several versions within the same family to distinct provider IDs, use the modelOverrides setting instead. modelOverrides maps individual Anthropic model IDs to the provider-specific strings that Claude Code sends to your provider’s API. When a user selects a mapped model in the /model picker, Claude Code uses your configured value instead of the built-in default. This lets enterprise administrators route each model version to a specific Bedrock inference profile ARN, Vertex AI version name, or Foundry deployment name for governance, cost allocation, or regional routing. Set modelOverrides in your settings file: 
{
  "modelOverrides": {
    "claude-opus-4-7": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/opus-prod",
    "claude-opus-4-6": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/opus-46-prod",
    "claude-sonnet-4-6": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/sonnet-prod"
  }
}
Keys must be Anthropic model IDs as listed in the Models overview. For dated model IDs, include the date suffix exactly as it appears there. Unknown keys are ignored. Overrides replace the built-in model IDs that back each entry in the /model picker. On Bedrock, overrides take precedence over any inference profiles that Claude Code discovers automatically at startup. Values you supply directly through ANTHROPIC_MODEL, --model, or the ANTHROPIC_DEFAULT_*_MODEL environment variables are passed to the provider as-is and are not transformed by modelOverrides. modelOverrides works alongside availableModels. The allowlist is evaluated against the Anthropic model ID, not the override value, so an entry like "opus" in availableModels continues to match even when Opus versions are mapped to ARNs.

​
Prompt caching configuration

Claude Code automatically uses prompt caching to optimize performance and reduce costs. You can disable prompt caching globally or for specific model tiers:
Environment variableDescription
DISABLE_PROMPT_CACHINGSet to 1 to disable prompt caching for all models (takes precedence over per-model settings)
DISABLE_PROMPT_CACHING_HAIKUSet to 1 to disable prompt caching for Haiku models only
DISABLE_PROMPT_CACHING_SONNETSet to 1 to disable prompt caching for Sonnet models only
DISABLE_PROMPT_CACHING_OPUSSet to 1 to disable prompt caching for Opus models only
These environment variables give you fine-grained control over prompt caching behavior. The global DISABLE_PROMPT_CACHING setting takes precedence over the model-specific settings, allowing you to quickly disable all caching when needed. The per-model settings are useful for selective control, such as when debugging specific models or working with cloud providers that may have different caching implementations.