Claude Opus 4.8 Fast Mode Deprecation: Migration to Opus 5.5
Anthropic announced the deprecation of fast mode for Claude Opus 4.8. Learn how to migrate fast inference workflows to Claude Opus 5.5 before November 30, 2026.
- Anthropic announced on 2026-10-30 that fast mode for Claude Opus 4.8 is deprecated and will be removed on November 30, 2026.
- Requests sent to claude-opus-4-8 with speed: “fast” will return an error after the removal date.
- Continuing fast inference requires migrating to claude-opus-5-5, where fast mode is stable across Start, Build, and Scale tiers without a beta header.
- Upgrading to Claude Opus 5.5 introduces required architectural updates, including adaptive thinking on every request, effort controls, and strict content block filtering.
Deprecation Details and Key Timeline Milestones
On 2026-10-30, Anthropic published release notes announcing the deprecation of fast mode for claude-opus-4-8. The capability remains accessible during a brief transition period until its scheduled removal date on November 30, 2026. After that date passes, any call directed to claude-opus-4-8 that contains the parameter speed: "fast" will fail with an API error. The change directly affects applications requiring low token-generation latency that currently rely on the older Opus generation.
To keep using accelerated inference, teams must transition their workloads to claude-opus-5-5. Fast mode on Claude Opus 4.8 and Claude Opus 5 operated under research preview status and mandated the fast-mode-2026-02-01 beta header. In contrast, Claude Opus 5.5 offers stable fast mode support directly through the standard Messages API and Claude Managed Agents without requiring the preview header.
| Model Name | Model ID | Fast Mode Status | Required Beta Header | Removal Date |
|---|---|---|---|---|
| Claude Opus 4.8 | claude-opus-4-8 | Deprecated (Research preview) | fast-mode-2026-02-01 | November 30, 2026 |
| Claude Opus 5 | claude-opus-5 | Research preview | fast-mode-2026-02-01 | None announced |
| Claude Opus 5.5 | claude-opus-5-5 | Stable | None required | Active |
How Fast Mode Operates Across Usage Tiers and Limits
Fast mode delivers up to 2.5x higher output tokens per second compared with standard inference speed. The optimization focuses specifically on output tokens per second (OTPS) rather than time to first token (TTFT). Because the underlying weights and capabilities are identical, fast mode preserves model intelligence while providing quicker completions. The performance boost is particularly evident when using streaming connections, as described in streaming LLM responses.
Fast mode allocations operate under a dedicated rate limit pool separate from standard Opus quotas. With claude-opus-5-5, default fast mode rate limits are provisioned automatically for organizations in the Start, Build, and Scale usage tiers. Accounts in the Evaluation tier must graduate to at least the Start tier to access fast mode on Opus 5.5. Real-time consumption is exposed through specific response headers:
anthropic-fast-input-tokens-limit: The maximum fast mode input tokens allowed per minute.anthropic-fast-input-tokens-remaining: The number of remaining fast mode input tokens in the current window.anthropic-fast-input-tokens-reset: The exact timestamp indicating when the fast input token limit replenishes.anthropic-fast-output-tokens-limit: The maximum fast mode output tokens allowed per minute.anthropic-fast-output-tokens-remaining: The quantity of remaining fast mode output tokens.anthropic-fast-output-tokens-reset: The timestamp when the fast mode output token quota resets.
Fast mode pricing sits at a premium tier. Standard token rates for Claude Opus 5.5 are $4 / $20 USD per million input / output tokens (or $4 input, $0.2 cached input, and $20 output per 1M tokens), which is lower than the standard rate for Claude Opus 5 at $5 / $25 USD. You can track exact token costs and limits through the Usage and Cost Analytics API or model operational costs using the /tools/llm-api-cost-calculator/.
Executing Requests and Verifying Speed Settings
Activating fast mode on claude-opus-5-5 requires adding speed: "fast" to your JSON payload. If you use Managed Agents, define speed: "fast" inside the model object: {"id": "claude-opus-5-5", "speed": "fast"}. When a request succeeds, the returned usage object contains a speed attribute set to "fast". If you attempt to call speed: "fast" on an unsupported model or on claude-opus-4-8 after November 30, 2026, the endpoint yields an immediate client error.
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"speed": "fast",
"messages": [{
"role": "user",
"content": "Refactor this module to use dependency injection"
}]
}'
In Python, use the official SDK to specify the parameter and inspect response.usage.speed to confirm that your execution ran at the accelerated rate:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
speed="fast",
messages=[
{"role": "user", "content": "Refactor this module to use dependency injection"}
],
)
print(response.usage.speed)
The JSON response confirms both standard token counts and the operational inference speed:
{
"id": "msg_01XFDUDYJgAACzvnptvVoYEL",
"type": "message",
"role": "assistant",
"usage": {
"input_tokens": 8,
"output_tokens": 12,
"speed": "fast"
}
}
Migrating to Opus 5.5: Critical API and Breaking Changes
Moving from claude-opus-4-8 to claude-opus-5-5 involves more than changing the model string and removing the preview header. Requests to claude-opus-5-5 enforce strict parameter schemas. Passing deprecated parameters will cause the API to return a 400 error.
- Fixed Model Identifier: Use
claude-opus-5-5without appending date suffixes. On third-party hosts like Microsoft Foundry or Google Cloud, use the platform-specific identifier. - Mandatory Adaptive Thinking: Adaptive thinking runs on every call to
claude-opus-5-5. Omitting the field or specifyingthinking: {"type": "adaptive"}is accepted. Supplyingthinking: {"type": "disabled"}or a manual token budget{"type": "enabled", "budget_tokens": N}results in an error. - Effort Controls: Thinking depth is adjusted using
output_config.effort. Available values arelow,medium,high,xhigh, andmax. The default value ismedium. - Restricted Sampling: Parameters such as
temperature,top_p, andtop_kare rejected onclaude-opus-5-5. Model responses must be directed through prompt instructions. - Tool Choice Restrictions: Only
tool_choicesettings{"type": "auto"}and{"type": "none"}are accepted. Enforcing a forced tool selection withanyor{"type": "tool", "name": "..."}will return an error. - No Assistant Prefill: Ending conversations with a prefilled assistant message is not supported. Structure outputs using structured outputs or system prompt directives.
- Computer Use Updates: The Claude API requires declaring
computer_toolset_20260801without beta headers; legacy declarations likecomputer_20251124return errors. - Standard 1M Context: The 1M token context window is enabled by default without needing beta headers.
This example illustrates a request meeting all standard parameters for claude-opus-5-5:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[
{"role": "user", "content": "Analyze the trade-offs between microservices and monolithic architectures"}
],
output_config={"effort": "medium"},
)
Handling Output Blocks, Token Budgets, and Prompt Caching
Because adaptive thinking runs on every Opus 5.5 request, code that assumes the first content item is always text will break. Responses frequently begin with thinking blocks followed by text blocks. Extract text by checking block types rather than indexing content[0]:
for block in response.content:
if block.type == "text":
print(block.text)
By default, thinking.display is set to "omitted", delivering empty thinking blocks alongside a signature. To expose intermediate reasoning steps in your application interface, configure display: "summarized" inside the adaptive thinking dictionary. In interactive agent workflows, you must return all received thinking blocks unmodified to avoid a 400 error.
Because max_tokens governs the combined total of thinking tokens and response text, systems upgrading from claude-opus-4-8 may experience truncated responses if budgets are set too low. For intensive reasoning at xhigh or max effort, setting max_tokens to 64k provides sufficient headroom. Note that thinking tokens are billed as output tokens even when thinking.display is omitted.
Prompt caching entries start at 512 tokens. A crucial architectural constraint exists between inference speeds: requests operating at different speeds do not share cache prefixes. Transitioning an interaction between fast mode and standard mode produces a prompt cache miss, as explained in our guide to prompt caching.
Rate Limits, SDK Retries, and Standard Fallback Patterns
When fast mode token limits are saturated, the endpoint returns an HTTP 429 error accompanied by a retry-after header. Anthropic SDKs automatically retry fast mode rate limit errors up to 2 times by default. Because token replenishments are continuous, these pauses are generally brief.
If immediate execution is prioritized over token velocity, you can catch rate limit exceptions and fall back to standard speed by stripping the speed: "fast" attribute. Setting max_retries=0 allows the application to capture the 429 immediately without waiting for retry attempts:
import anthropic
client = anthropic.Anthropic()
def create_message_with_fast_fallback(max_retries=0, max_attempts=3, **params):
try:
return client.with_options(max_retries=max_retries).messages.create(**params)
except anthropic.RateLimitError:
if params.get("speed") == "fast":
del params["speed"]
return create_message_with_fast_fallback(max_retries=max_retries, **params)
raise
except (anthropic.APIStatusError, anthropic.APIConnectionError) as error:
if isinstance(error, anthropic.APIStatusError) and error.status_code < 500:
raise
if max_attempts > 1:
return create_message_with_fast_fallback(
max_retries=max_retries, max_attempts=max_attempts - 1, **params
)
raise
Keep in mind that dropping back to standard speed triggers a cache miss, requiring the prompt cache prefix to be repopulated under standard speed inference. Detailed error-handling patterns for Anthropic services are covered in handling API errors and retries.
Step-by-Step Opus 4.8 to Opus 5.5 Migration Checklist
To ensure production pipelines running on claude-opus-4-8 continue operating before the November 30, 2026 cutoff, complete the following steps:
- Update the Model ID: Change model strings from
claude-opus-4-8toclaude-opus-5-5across all client configs and environment variables. - Remove Beta Headers: Discard the
fast-mode-2026-02-01header from HTTP client configurations. - Verify Organization Tiers: Confirm that the API organization belongs to the Start, Build, or Scale tier to access default fast mode rate limits on Claude Opus 5.5.
- Clean Incompatible Request Parameters: Remove sampling controls (
temperature,top_p,top_k), forced tool use (any,tool), and assistant prefill turns. - Implement Effort Configuration: Define explicit effort levels (
low,medium,high,xhigh,max) viaoutput_config.effortinstead of attempting to disable thinking. - Refactor Content Block Parsing: Iterate over
response.contentcheckingblock.type == 'text'rather than reading index0. - Preserve Thinking Blocks in Agent Loops: Ensure tool-calling agent loops pass intermediate thinking blocks back to the API without modifying or filtering them.
- Recalibrate Output Limits: Increase
max_tokensbudgets to account for thinking token generation alongside response text. - Test Error Fallback Behaviors: Confirm that standard-speed fallbacks work gracefully when encountering 429 errors or capacity exhaustion.