Claude Opus 4

Generates production-ready code across 40+ programming languages by maintaining coherent context across multiple files and project structures. Uses transformer-based reasoning to understand dependencies, imports, and architectural patterns within a codebase, enabling it to generate code that integrates seamlessly with existing systems rather than isolated snippets. Achieves 72.5% on SWE-bench by combining extended thinking for complex refactoring decisions with parallel tool-use for validation and testing.

Exposes internal reasoning process through structured thinking tokens that show step-by-step problem decomposition, hypothesis testing, and error correction before generating final output. The model allocates computation dynamically based on task complexity, spending more thinking tokens on harder problems and responding quickly to simpler ones. This transparency enables developers to audit decision-making, identify reasoning errors, and understand why the model chose a particular solution path.

Maintains conversation state across multiple turns, enabling natural multi-turn interactions where the model remembers previous messages, context, and decisions. Each turn is a separate API call, but the model receives the full conversation history, allowing it to reference earlier statements and maintain coherence. This is implemented through the messages API, where developers pass the full conversation history with each request, and the model generates the next response in context.

Processes enterprise documents (PDFs, Excel spreadsheets, Word documents) by extracting text, structure, and metadata, then analyzing or transforming the content. The model can read multi-page PDFs with layout preservation, extract tables from spreadsheets, and understand document structure (headers, sections, etc.). This enables workflows like contract review, invoice processing, or data extraction from business documents without manual transcription.

Implements safety mechanisms that prevent harmful outputs by refusing requests that violate content policies and streaming refusals (stopping generation mid-response if harmful content is detected). The model is trained to recognize and decline requests for illegal activities, violence, abuse, or other harmful content. Refusals are streamed in real-time, allowing applications to stop processing immediately rather than waiting for a full response. This is implemented through training-time alignment and runtime filtering.

Reduces false or fabricated information by grounding responses in provided context (documents, code, web search results) and providing citations that link claims to sources. The model is trained to distinguish between information from its training data and information from the provided context, and to cite sources when making claims. This is implemented through training-time techniques and runtime citation generation, where the model includes source references in its output.

Enables the model to operate autonomously for extended periods (hours) by maintaining state across multiple tool-use cycles, making decisions, and executing complex workflows without human intervention. The model can break down long-running tasks into subtasks, execute them sequentially or in parallel, handle failures, and adapt based on results. This is implemented through the tool-use protocol combined with persistent state management, allowing the model to maintain context and decision history across many API calls.

Executes multiple tool calls in parallel within a single API response by defining tools as JSON schemas that the model understands structurally. The model can invoke multiple tools simultaneously (e.g., fetch data from three APIs at once), wait for results, and then chain subsequent calls based on outcomes. This is implemented through a tool-use protocol where each tool is defined with input/output schemas, and the model generates structured tool-call objects that the client executes and feeds back as tool results.

Analyzes images, screenshots, diagrams, and PDFs by processing visual input through a multimodal transformer that extracts text, structure, and semantic meaning. The model can read handwritten notes, interpret flowcharts, extract tables from screenshots, and answer questions about visual content. PDF support enables processing of multi-page documents with layout preservation, making it suitable for document-heavy workflows like contract review, form extraction, or architectural diagram analysis.

Augments responses with current web search results by invoking a search tool that retrieves and summarizes relevant information from the internet. The model decides when to search based on the query, fetches results, and incorporates them into its response with citations. This enables the model to answer questions about recent events, current prices, or breaking news that fall outside its training data cutoff, without requiring the user to manually provide links or context.

Executes code (Python, JavaScript, etc.) in a sandboxed runtime and returns results, enabling the model to test solutions, validate outputs, and iterate on code without human intervention. The model can write code, run it, inspect results, and modify the code based on errors or unexpected behavior. This is implemented as a tool that the model invokes, making it part of the agentic workflow—the model can execute code, see the output, and reason about whether the solution is correct.

Generates outputs that conform to user-defined JSON schemas, ensuring that responses are machine-parseable and structurally valid. The model understands the schema constraints and generates JSON that matches the specified structure, enabling reliable downstream processing without parsing errors. This is useful for extracting structured data from unstructured text, generating API payloads, or ensuring consistent output formats across multiple requests.

Processes and reasons over extremely large contexts (200K tokens in Opus 4, 1M tokens in Opus 4.7) without losing coherence or forgetting earlier information. This enables the model to analyze entire codebases, long documents, or multi-turn conversations without summarization or chunking. The model maintains attention across the full context, enabling it to reference details from the beginning of the context when making decisions at the end, critical for tasks like codebase refactoring or document analysis.

Caches large input contexts (code, documents, system prompts) so that repeated requests with the same context incur only 10% of the input token cost. The model stores the cached context in a session and reuses it for subsequent requests, reducing costs for workflows where the same large context is queried multiple times. This is implemented at the API level; developers specify which parts of the input to cache, and Anthropic's infrastructure handles storage and retrieval.

Processes multiple requests asynchronously in batches, reducing costs by 50% compared to real-time API calls. Developers submit a batch of requests (e.g., 100 code generation tasks), and Anthropic processes them during off-peak hours, returning results within 24 hours. This is ideal for non-urgent, high-volume workloads where latency is not critical but cost optimization is important. Batch processing is implemented as a separate API endpoint that accepts JSONL-formatted request batches.