MessagesBuilding with Claude
Features overview
Explore Claude’s advanced features and capabilities.
For each feature’s eligibility under zero data retention (ZDR) and HIPAA readiness, see API and data retention.
For administration and governance, see the Admin API, the Usage and Cost Analytics API, and the Compliance API.
Platform features
Features of the Claude Platform that work across its APIs. Each feature’s page says where you can use it.
| Feature | Description |
|---|---|
| Advisor tool | Lets a faster executor model consult a more capable advisor model mid-generation for a plan or a course correction. |
| Agent Skills | Reusable packages of instructions, metadata and optional scripts that Claude uses automatically when they are relevant to a task. |
| Part of Agent Skills: Custom Skills | Skills you write and upload to your workspace. |
| Part of Agent Skills: Pre-built Agent Skills | Anthropic’s pre-built skills for PowerPoint, Excel, Word and PDF files. |
| Batch processing | Processes many Messages API requests asynchronously in one batch, at half the standard price. |
| Browser and computer use SDK toolsets | Classes in the Python and TypeScript SDKs that connect the browser use or computer use tool to a browser or desktop that you supply. |
| Browser use tool | Lets Claude navigate, read, and interact with webpages in your own browser environment. |
| Citations | Claude’s answers about your documents cite the exact passages that support each claim. |
| Classifier refusals | Safety classifiers on some models can decline a request; the decline comes back as a normal response, not an error. |
| Part of Classifier refusals: Client-side fallback | A middleware in the Claude SDKs that retries a refused request on the fallback models you list. |
| Part of Classifier refusals: Fallback credit | Bills a retry of a refused request on another model as if the conversation had been on that model from the start, so you do not pay the prompt-cache write twice. |
| Part of Classifier refusals: Server-side fallback | The API retries a refused request on a fallback model within the same call and returns one response. |
| Computer use tool | Gives Claude screenshot, mouse, and keyboard control of a desktop environment. |
| Custom tools | Tools you define with a name, description and input schema. Claude asks to call them; your code runs them and returns the result. |
| Data residency | Controls for where model inference runs (inference geo) and where data is stored at rest (workspace geo). |
| Effort | A setting that controls how many tokens Claude spends on a response, trading thoroughness for token efficiency. |
| Part of Effort: Per-message effort | Changing the effort level for later turns of a conversation with a per-message output_config, which keeps the prompt cache. |
| Fast mode | Up to 2.5 times more output tokens per second from supported models, at premium pricing. |
| Files API | Upload a file once and refer to it by file_id in later requests, and download files that skills or the code execution tool create. |
| MCP connector | Connect Claude to remote MCP servers so it can call their tools, without running your own MCP client. |
| Part of MCP connector: Client-side MCP helpers | SDK helpers that convert between MCP types and Claude API types, for when you run your own MCP client, for example for local servers, prompts or resources. |
| MCP tunnels | Connect Claude to MCP servers inside your private network over an outbound-only connection, with no inbound ports open. |
| Mid-conversation system messages | A system instruction added partway through a conversation, without changing the top-level system prompt or the cached prefix before it. |
| Part of Mid-conversation system messages: Mid-conversation tool changes | Offer or withdraw tools partway through a conversation without changing the tools array, so the cached prefix stays valid. |
| Part of Mid-conversation system messages: Turn-scoped system messages | A mid-conversation system message that applies only until the next user message, then stays in the history but renders nothing and costs no input tokens. |
| Multilingual support | Claude works in many languages, with strong performance relative to English. |
| OpenTelemetry | Traces your Messages API requests, tool uses, and Managed Agents sessions with OpenTelemetry spans from the Claude SDK and the Claude API. |
| Part of OpenTelemetry: API tracing | OpenTelemetry spans that the Claude API sends to your observability platform for each model request and tool use that it runs. |
| Part of OpenTelemetry: SDK tracing | OpenTelemetry spans that the Claude SDK emits in your application for each request it sends and each tool that its tool runner runs. |
| Parallel tool use | Claude can call several tools in one response. |
| PDF support | Send PDFs to Claude so it can read the text, pictures, charts and tables in them. |
| Programmatic tool calling | Lets Claude call your tools from code in the code execution container, instead of one model round trip for each call. |
| Prompt caching | Reuses a cached prompt prefix from a recent request to reduce processing time and cost. |
| Part of Prompt caching: 1-hour duration | A 1-hour prompt cache lifetime, for a higher cache write price than the 5-minute default. |
| Part of Prompt caching: 5-minute duration (default) | The default prompt cache lifetime. Each use of the cached content refreshes it at no extra cost. |
| Part of Prompt caching: Automatic caching | Prompt caching with one top-level cache_control field: the cache breakpoint goes on the last cacheable block and moves forward as the conversation grows. |
| Part of Prompt caching: Cache diagnostics | Compares a request with your previous one and reports where the prompt prefix changed, to explain cache misses. |
| Part of Prompt caching: Explicit cache breakpoints | Prompt caching with cache_control on individual content blocks, to choose exactly what is cached. |
| SDK middleware | A hook in the Claude SDKs that runs your code before each request is sent and after its response is received. |
| Search results | Content blocks that hold your own search results, with a source and title, so Claude can cite them the same way it cites web search results. |
| Service tiers | Lets a request use your organization’s Priority Tier capacity. |
| Session budgets | A hard spending limit in US dollars on one session, measured at public list prices. |
| Streaming refusals | A streamed response ends with stop_reason "refusal" when streaming classifiers stop it for a possible policy violation. |
| Structured outputs | Constrains Claude’s response to a JSON schema that you give, so the output is valid and parseable. |
| Task budgets | Tells Claude how many tokens it has for a full agentic loop, so it can plan its work and finish before the budget runs out. |
| Thinking | Claude works through a problem in thinking blocks before it writes its answer. |
| Part of Thinking: Adaptive thinking | Thinking mode in which Claude decides, for each request, whether to think and how much. |
| Part of Thinking: Extended thinking | Manual thinking mode in which you set a fixed thinking token budget (budget_tokens) on each request. |
| Part of Thinking: Preserved thinking | Claude uses thinking blocks from earlier turns only if the current model can read them and nothing before them (system prompt, tools, earlier messages) has changed. |
| Threshold compaction | Automatic compaction: when a conversation reaches a token threshold, the API summarizes older context inside the request. |
| Token counting | Counts the tokens in a message before you send it to Claude. |
| Tool runner | An SDK helper that runs the tool-use loop for you: it runs your tools when Claude calls them and sends the results back. |
| Tool search tool | Lets Claude search your tool catalog and load only the tool definitions it needs. |
| Vision (images) | Claude can read and analyze images that you send to it. |
| Web domain restrictions | Lists of allowed or blocked domains that control which sites the web search and web fetch tools can reach. |
| Web fetch tool | A server tool that lets Claude get the full content of web pages and PDF documents at given URLs. |
| Web search tool | A server tool that lets Claude search the web for current information. |
Messages API features
| Feature | Description |
|---|---|
| Apple Foundation Models | A Swift package that makes Claude available as a language model in Apple’s Foundation Models framework. |
| Bash tool | Lets Claude request shell commands, which run in a bash session that keeps its state between commands. |
| Code execution tool | Lets Claude run Python and Bash code in a sandboxed container. |
| Context editing | Clears selected content, such as old tool results or old thinking blocks, from the conversation history as it grows. |
| Forced tool use | Makes Claude call a tool, or one specific tool, instead of answering directly. |
| Memory tool | Lets Claude store and read information across conversations in a directory of memory files. |
| Part of Memory tool: Memory tool helpers | SDK helpers that handle the memory tool’s interface and tool-use loop, so your code supplies only the storage. |
| Message streaming | Receiving a Messages API response incrementally, as server-sent events, while it is generated. |
| Part of Message streaming: Fine-grained tool streaming | Streams a tool’s input to your client as Claude writes it, without the server first buffering and checking the JSON. |
| Message threads | Give long-running agents a faster time to first token, especially in long conversations, by sending only the new messages on each request. |
| On-demand compaction | Replaces the earlier messages of a conversation with a summary that Claude writes when your application asks for it. |
| Part of On-demand compaction: Background compaction | Runs the on-demand compaction request while the conversation continues on its full history, then swaps in the summary when it arrives. |
| Part of On-demand compaction: Compaction and preserved thinking | Thinking blocks in the turns you keep after on-demand compaction can stay valid, under stated conditions, on models with preserved thinking. |
| Part of On-demand compaction: Keep-tail compaction | On-demand compaction that summarizes the older turns and keeps the last few turns word for word after the summary. |
| Part of On-demand compaction: Tool runner compaction helper | A method on the SDK tool runner that sends the compaction request for you once the current turn and its tool calls finish. |
| OpenAI SDK compatibility | A compatibility layer that lets you call the Claude API with the OpenAI SDK, meant for testing and comparing models. |
| Strict tool use | Makes Claude’s tool inputs always match the tool’s JSON Schema. |
| Text editor tool | Lets Claude view, create, and edit text files with an Anthropic-defined tool. |
| Typed structured output helpers | SDK helpers that build the JSON schema from a type in your code and parse Claude’s response into that type. |
Managed Agents features
| Feature | Description |
|---|---|
| Agent configurations | A reusable, versioned configuration of the model, system prompt, tools, MCP servers and skills that a session runs. |
| Agent toolset | A set of built-in tools (bash, read, write, edit, glob, grep, web fetch and web search) that the agent uses in its sandbox. |
| Cloud sandboxes | Isolated Linux containers on Anthropic-managed infrastructure where a session’s tools and code run. |
| Console agent builder | A visual interface in the Claude Console to create, configure and test agents. |
| Dreams | A job that reads a memory store and past session transcripts and writes a new, reorganized memory store. |
| Event deltas | Live previews of the agent’s response text on the session event stream while the model is still generating it. |
| GitHub access | Access to GitHub from a session: repositories mounted in the sandbox, and the GitHub MCP server for pull requests. |
| Memory stores | Collections of text documents that an agent reads and writes, so that information persists across sessions. |
| Multiagent orchestration | Lets the agent of a session hand work to other agents, as subagents or in workflows, and consult an advisor model. |
| Part of Multiagent orchestration: Dynamic workflows | Programs that an agent writes to run many agents in the background and combine their results. |
| Part of Multiagent orchestration: Session threads | The thread in which each agent of a multiagent session works, which you can list, stream, interrupt and archive. |
| Outcomes | A target result for a session, with a rubric that a separate grader uses to check the agent’s work until the target is met. |
| Permission policies | Settings that control whether the agent’s built-in tools and MCP tools run automatically, wait for your approval, or are checked by the server on each call. |
| Scheduled deployments | Runs an agent on a cron schedule, so that the agent starts sessions by itself. |
| Self-hosted sandboxes | Sandboxes on your own infrastructure that run the agent’s tool calls, while Claude still runs on Anthropic’s side. |
| Part of Self-hosted sandboxes: Self-hosted workers | A process that you run on your own infrastructure to claim sessions from a self-hosted environment’s queue and run their tool calls. |
| Session viewer | A session viewer in the Claude Console and per-session usage totals, to see what an agent did and what it used. |
| Vaults | Stores of per-user credentials for third-party services that you register once and reference by ID when you create a session. |
| Webhooks | Notifications to your HTTPS endpoint when events happen in your Managed Agents resources, such as a change in a session’s status. |
Was this page helpful?
