Claude Sonnet 4

Enables step-by-step reasoning through an explicit API parameter that activates extended thinking mode, allowing the model to work through complex problems with visible intermediate reasoning steps before producing final output. The model allocates computational budget to internal reasoning chains, trading increased latency and token consumption for improved accuracy on multi-step reasoning tasks. This is distinct from standard inference where reasoning is implicit and opaque.

Generates, refactors, and debugs code with awareness of multi-file project structure and dependencies, leveraging the 1M token context window to ingest entire codebases and reason about cross-file impacts. The model can analyze import chains, identify refactoring opportunities across modules, and generate changes that maintain consistency across the codebase. This is implemented through context-aware code analysis rather than single-file isolation.

Supports reasoning and text generation across 40+ languages with comparable quality to English, enabling multilingual applications without language-specific fine-tuning. The model handles language detection, translation-adjacent reasoning, and code-switching (mixing languages) within the same request. Multilingual support is built into the base model rather than requiring separate language-specific models.

Returns API responses as token-by-token streams rather than waiting for complete generation, enabling real-time feedback and reduced perceived latency. Streaming is implemented at the token level, allowing developers to process and display output as it's generated. This is particularly useful for long-form content generation, chat interfaces, and applications where user experience benefits from immediate feedback.

Provides enhanced reasoning and knowledge for specialized domains (finance, cybersecurity, and others) through domain-specific training or fine-tuning, enabling more accurate analysis and recommendations in these areas. The model has deeper knowledge of domain-specific concepts, terminology, regulations, and best practices compared to general-purpose reasoning. This is implemented through targeted training data inclusion and domain-aware reasoning patterns.

Executes code (Python, JavaScript, and other languages) directly through a native code execution tool, enabling the model to run code, test hypotheses, and verify outputs without requiring external code execution infrastructure. The model can write code, execute it, analyze results, and iterate based on output. Code execution results are returned to the model for further reasoning.

Implements function calling through a schema-based tool registry that supports parallel tool invocation (multiple tools in a single response) and strict mode enforcement (model output strictly conforms to schema, no extraneous text). Tools are defined via JSON schema and executed through the Claude Managed Agents infrastructure or via developer-managed tool loops in the Messages API. The model selects appropriate tools based on task requirements and can chain multiple tool calls in a single turn.

Enables autonomous interaction with digital environments (web browsers, desktop applications) through a computer use API that provides screenshot capture, mouse/keyboard control, and OCR-based element detection. The model receives visual feedback (screenshots) and can navigate web pages, fill forms, click buttons, and execute multi-step workflows without direct API integration. This is implemented as a native tool within the Claude API, allowing the model to reason about visual state and execute actions iteratively.

Analyzes images and visual content through native vision capabilities that support multiple image formats (JPEG, PNG, GIF, WebP) and can process images embedded in conversations or provided via URLs. The model can extract text (OCR), identify objects, analyze diagrams, read charts, and reason about visual content in context of text prompts. Vision is integrated into the standard Messages API without requiring separate endpoints.

Provides real-time web search capability as a native tool within the Claude API, allowing the model to query the internet and retrieve current information without relying on training data cutoff. The model can autonomously decide when to search, formulate search queries, and integrate results into responses. Search results are returned as structured data that the model can reason about and synthesize.

Generates structured outputs (JSON, XML, or other formats) that conform to developer-provided JSON schemas, ensuring output can be reliably parsed and integrated into downstream systems. The model receives a schema definition and produces output that strictly adheres to the schema structure, types, and constraints. This is implemented through schema-aware generation where the model's output is validated against the schema before being returned.

Reduces API costs by caching frequently-used context (system prompts, documents, code files) at the API level, so repeated requests with the same context only pay for the cached portion once. Cached tokens are charged at 10% of the standard input token rate, enabling 90% cost savings for requests reusing the same context. Caching is transparent to developers — no code changes required beyond initial setup.

Processes multiple API requests asynchronously in batches, reducing costs by 50% compared to standard API pricing. Requests are submitted as a batch and processed during off-peak hours, with results returned asynchronously. This is ideal for non-time-sensitive workloads where latency is acceptable in exchange for cost savings. Batch processing is implemented as a separate API endpoint with different pricing and SLA.

Provides a fully-managed agent infrastructure (Claude Managed Agents) that handles conversation state, tool execution loops, and multi-turn reasoning without requiring developers to implement agent logic. Agents maintain state across requests within a session, automatically manage tool calling and result integration, and support long-running autonomous tasks. This abstracts away the complexity of building agent loops manually.