Claude Opus 4

Enables Claude to expose its internal chain-of-thought process by allocating compute budget to explicit reasoning steps before generating responses. The model spends configurable thinking tokens on problem decomposition, hypothesis testing, and self-correction before committing to output, making reasoning transparent and auditable. This is distinct from standard token generation as thinking tokens are processed separately and can be streamed or hidden from end users.

Automatically adjusts reasoning effort based on detected task complexity without explicit user configuration. The model analyzes incoming requests and allocates thinking tokens proportionally — spending minimal compute on straightforward queries (e.g., factual lookups) and deep reasoning on complex problems (e.g., multi-step code debugging). This is implemented as a learned routing mechanism that estimates problem difficulty before committing reasoning budget.

Caches frequently-accessed context (e.g., large documents, code repositories, system prompts) to reduce token costs by up to 90% on subsequent requests. When the same context is reused, cached tokens are charged at 10% of the normal rate. This is implemented via a token-level caching mechanism that identifies repeated token sequences and stores them server-side, avoiding re-processing on subsequent requests.

Processes multiple requests in batch mode with 50% cost savings compared to real-time API calls. Batch requests are queued and processed during off-peak hours, trading latency for cost reduction. This is useful for non-time-sensitive workloads like data analysis, content generation, or code review where responses can be delayed by hours or days.

Processes documents and codebases up to 200,000 tokens (approximately 150,000 words or 50,000 lines of code) in a single request. This enables the model to analyze entire repositories, long documents, or multiple files without truncation. The large context window is implemented via efficient attention mechanisms and is available across all deployment options (API, web, mobile).

Processes PDF documents, extracting text and analyzing visual layouts, charts, and images within PDFs. The model can read multi-page PDFs, understand document structure, and extract information from both text and visual elements. PDFs are converted to a format compatible with the vision and text processing capabilities, enabling unified multimodal analysis.

Generates structured outputs (JSON, XML, etc.) that conform to a provided schema, ensuring outputs are valid and parseable. The model is constrained to generate only outputs that match the schema, preventing malformed or invalid responses. This is implemented via output token constraints that restrict generation to valid schema tokens.

Enables the model to interact with computer interfaces (screenshots, mouse clicks, keyboard input) to automate UI-based tasks. The model can see the current screen state, click buttons, type text, and navigate applications. This is implemented as a tool that provides screen capture and input simulation capabilities, allowing the model to autonomously operate applications.

Provides a memory tool that allows the model to store and retrieve information across multiple conversations or sessions. The model can save facts, preferences, or context to memory and retrieve them in future interactions, enabling persistent personalization and context accumulation. Memory is implemented as a key-value store that the model can read and write to via tool calls.

Orchestrates complex multi-step workflows by chaining tool calls across extended interactions, maintaining coherence and state across dozens of steps. The model can invoke tools in parallel, handle tool failures with retry logic, and maintain context about previous tool results to inform subsequent decisions. This is implemented via a managed agent infrastructure that persists session state, tracks tool execution history, and enables autonomous operation for hours without human intervention.

Invokes multiple tools concurrently within a single model response, with fine-grained streaming of tool calls and results. The model can batch independent tool invocations (e.g., fetch 5 URLs in parallel) and stream results back to the client as they complete, rather than waiting for all tools to finish. This reduces latency for I/O-bound workflows and enables real-time progress feedback.

Enforces that the model MUST invoke a specified tool before generating free-form text, preventing the model from bypassing tool use or hallucinating tool results. When strict mode is enabled, the model's output is constrained to valid tool invocations only — it cannot refuse to use the tool or generate text that pretends the tool was called. This is implemented via output token constraints that restrict the model's generation vocabulary to valid tool schemas.

Generates production-ready code with specialized optimization for software engineering tasks, achieving 72.5% on SWE-bench (solving real GitHub issues in open-source repositories). The model is trained to understand large codebases, identify root causes of bugs, generate minimal diffs, and test changes before committing. This is distinct from generic code generation because it combines extended thinking for problem analysis with tool use for code execution and testing.

Analyzes images, diagrams, charts, and screenshots by processing visual input alongside text prompts. The model can extract text from images (OCR), identify objects and relationships, analyze code in screenshots, and reason about visual layouts. Vision is integrated into the same API as text, allowing seamless multimodal workflows where images and text are processed together in a single request.

Provides built-in web search and web fetch tools that the model can invoke to retrieve current information from the internet. The model can search for information, fetch full page content, and synthesize results into responses. These tools are available through the standard tool-use API, allowing the model to autonomously decide when to search the web based on the user's query.

Executes code (Python, Bash, and other languages) in a sandboxed environment and returns output to the model. The model can write code, execute it, see results, and iterate based on output. This enables the model to test hypotheses, validate changes, and debug code interactively. Code execution is provided as a tool that the model can invoke, not as a native capability.

Provides a managed agent infrastructure that persists session state, maintains event history, and enables autonomous operation across multiple API calls. Sessions store conversation history, tool execution results, and agent state, allowing the agent to resume work without losing context. This is implemented as a stateful service layer above the base model API, handling session management, event logging, and recovery.