---
title: Features overview
url: https://platform.claude.com/docs/en/build-with-claude/overview
description: 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](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#feature-eligibility).

For administration and governance, see the [Admin API](https://platform.claude.com/docs/en/manage-claude/admin-api), the [Usage and Cost Analytics API](https://platform.claude.com/docs/en/manage-claude/usage-cost-analytics-api), and the [Compliance API](https://platform.claude.com/docs/en/manage-claude/compliance-api).

## Platform features

Features of the Claude Platform that work across its APIs. Each feature’s page says where you can use it.

<Tip>
  You can discover which capabilities a model supports programmatically. The [Models API](https://platform.claude.com/docs/en/api/models/list) returns `max_input_tokens`, `max_tokens`, and a `capabilities` object for every available model.
</Tip>

| Feature                                                                                                                                                 | Description                                                                                                                                                          |
| :------------------------------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool)                                                              | Lets a faster executor model consult a more capable advisor model mid-generation for a plan or a course correction.                                                  |
| [Agent Skills](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)                                                              | Reusable packages of instructions, metadata and optional scripts that Claude uses automatically when they are relevant to a task.                                    |
| ↳ [Custom Skills](https://platform.claude.com/docs/en/build-with-claude/skills-guide#managing-custom-skills)                                            | Skills you write and upload to your workspace.                                                                                                                       |
| ↳ [Pre-built Agent Skills](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview#pre-built-agent-skills)                           | Anthropic’s pre-built skills for PowerPoint, Excel, Word and PDF files.                                                                                              |
| [Batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing)                                                              | Processes many Messages API requests asynchronously in one batch, at half the standard price.                                                                        |
| [Browser and computer use SDK toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-sdk)                                  | 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](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool)                                                      | Lets Claude navigate, read, and interact with webpages in your own browser environment.                                                                              |
| [Citations](https://platform.claude.com/docs/en/build-with-claude/citations)                                                                            | Claude’s answers about your documents cite the exact passages that support each claim.                                                                               |
| [Classifier refusals](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback)                                                      | Safety classifiers on some models can decline a request; the decline comes back as a normal response, not an error.                                                  |
| ↳ [Client-side fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#client-side-fallback)                              | A middleware in the Anthropic SDKs that retries a refused request on the fallback models you list.                                                                   |
| ↳ [Fallback credit](https://platform.claude.com/docs/en/build-with-claude/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.    |
| ↳ [Server-side fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#server-side-fallback)                              | The API retries a refused request on a fallback model within the same call and returns one response.                                                                 |
| [Computer use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool)                                                    | Gives Claude screenshot, mouse, and keyboard control of a desktop environment.                                                                                       |
| [Custom tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-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](https://platform.claude.com/docs/en/manage-claude/data-residency)                                                                      | Controls for where model inference runs (inference geo) and where data is stored at rest (workspace geo).                                                            |
| [Effort](https://platform.claude.com/docs/en/build-with-claude/effort)                                                                                  | A setting that controls how many tokens Claude spends on a response, trading thoroughness for token efficiency.                                                      |
| ↳ [Per-message effort](https://platform.claude.com/docs/en/build-with-claude/effort-per-message)                                                        | Changing the effort level for later turns of a conversation with a per-message `output_config`, which keeps the prompt cache.                                        |
| [Fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode)                                                                            | Up to 2.5 times more output tokens per second from supported models, at premium pricing.                                                                             |
| [Files API](https://platform.claude.com/docs/en/build-with-claude/files)                                                                                | 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](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector)                                                                     | Connect Claude to remote MCP servers so it can call their tools, without running your own MCP client.                                                                |
| ↳ [Client-side MCP helpers](https://platform.claude.com/docs/en/agents-and-tools/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](https://platform.claude.com/docs/en/agents-and-tools/mcp-tunnels/overview)                                                                | Connect Claude to MCP servers inside your private network over an outbound-only connection, with no inbound ports open.                                              |
| [Mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/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.                              |
| ↳ [Mid-conversation tool changes](https://platform.claude.com/docs/en/build-with-claude/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.                                           |
| ↳ [Turn-scoped system messages](https://platform.claude.com/docs/en/build-with-claude/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](https://platform.claude.com/docs/en/build-with-claude/multilingual-support)                                                      | Claude works in many languages, with strong performance relative to English.                                                                                         |
| [OpenTelemetry](https://platform.claude.com/docs/en/manage-claude/opentelemetry)                                                                        | Traces your Messages API requests, tool uses, and Managed Agents sessions with OpenTelemetry spans from the Anthropic SDK and the Claude API.                        |
| ↳ [API tracing](https://platform.claude.com/docs/en/manage-claude/opentelemetry/api)                                                                    | OpenTelemetry spans that the Claude API sends to your observability platform for each model request and tool use that it runs.                                       |
| ↳ [SDK tracing](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk)                                                                    | OpenTelemetry spans that the Anthropic SDK emits in your application for each request it sends and each tool that its tool runner runs.                              |
| [Parallel tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/parallel-tool-use)                                                    | Claude can call several tools in one response.                                                                                                                       |
| [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support)                                                                        | Send PDFs to Claude so it can read the text, pictures, charts and tables in them.                                                                                    |
| [Programmatic tool calling](https://platform.claude.com/docs/en/agents-and-tools/tool-use/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](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)                                                                  | Reuses a cached prompt prefix from a recent request to reduce processing time and cost.                                                                              |
| ↳ [1-hour duration](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#1-hour-cache-duration)                                         | A 1-hour prompt cache lifetime, for a higher cache write price than the 5-minute default.                                                                            |
| ↳ [5-minute duration (default)](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#how-prompt-caching-works)                          | The default prompt cache lifetime. Each use of the cached content refreshes it at no extra cost.                                                                     |
| ↳ [Automatic caching](https://platform.claude.com/docs/en/build-with-claude/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.          |
| ↳ [Cache diagnostics](https://platform.claude.com/docs/en/build-with-claude/cache-diagnostics)                                                          | Compares a request with your previous one and reports where the prompt prefix changed, to explain cache misses.                                                      |
| ↳ [Explicit cache breakpoints](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#explicit-cache-breakpoints)                         | Prompt caching with `cache_control` on individual content blocks, to choose exactly what is cached.                                                                  |
| [SDK middleware](https://platform.claude.com/docs/en/cli-sdks-libraries/middleware)                                                                     | A hook in the Anthropic SDKs that runs your code before each request is sent and after its response is received.                                                     |
| [Search results](https://platform.claude.com/docs/en/build-with-claude/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](https://platform.claude.com/docs/en/api/service-tiers)                                                                                  | Lets a request use your organization’s Priority Tier capacity.                                                                                                       |
| [Session budgets](https://platform.claude.com/docs/en/managed-agents/budgets)                                                                           | A hard spending limit in US dollars on one session, measured at public list prices.                                                                                  |
| [Streaming refusals](https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/handle-streaming-refusals)                             | A streamed response ends with `stop_reason` `"refusal"` when streaming classifiers stop it for a possible policy violation.                                          |
| [Structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs)                                                          | Constrains Claude’s response to a JSON schema that you give, so the output is valid and parseable.                                                                   |
| [Task budgets](https://platform.claude.com/docs/en/build-with-claude/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](https://platform.claude.com/docs/en/build-with-claude/thinking)                                                                              | Claude works through a problem in thinking blocks before it writes its answer.                                                                                       |
| ↳ [Adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking-steering-and-cost)                                                 | Thinking mode in which Claude decides, for each request, whether to think and how much.                                                                              |
| ↳ [Extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking)                                                          | Manual thinking mode in which you set a fixed thinking token budget (`budget_tokens`) on each request.                                                               |
| ↳ [Preserved thinking](https://platform.claude.com/docs/en/build-with-claude/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](https://platform.claude.com/docs/en/build-with-claude/compaction-threshold)                                                      | Automatic compaction: when a conversation reaches a token threshold, the API summarizes older context inside the request.                                            |
| [Token counting](https://platform.claude.com/docs/en/build-with-claude/token-counting)                                                                  | Counts the tokens in a message before you send it to Claude.                                                                                                         |
| [Tool runner](https://platform.claude.com/docs/en/agents-and-tools/tool-use/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](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool)                                                      | Lets Claude search your tool catalog and load only the tool definitions it needs.                                                                                    |
| [Vision (images)](https://platform.claude.com/docs/en/build-with-claude/vision)                                                                         | Claude can read and analyze images that you send to it.                                                                                                              |
| [Web domain restrictions](https://platform.claude.com/docs/en/managed-agents/tools-web-restrictions)                                                    | Lists of allowed or blocked domains that control which sites the web search and web fetch tools can reach.                                                           |
| [Web fetch tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/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](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool)                                                        | A server tool that lets Claude search the web for current information.                                                                                               |

## Messages API features

| Feature                                                                                                                         | Description                                                                                                                                  |
| :------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------- |
| [Apple Foundation Models](https://platform.claude.com/docs/en/cli-sdks-libraries/libraries/apple-foundation-models)             | A Swift package that makes Claude available as a language model in Apple’s Foundation Models framework.                                      |
| [Bash tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool)                                            | Lets Claude request shell commands, which run in a bash session that keeps its state between commands.                                       |
| [Code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool)                        | Lets Claude run Python and Bash code in a sandboxed container.                                                                               |
| [Context editing](https://platform.claude.com/docs/en/build-with-claude/context-editing)                                        | Clears selected content, such as old tool results or old thinking blocks, from the conversation history as it grows.                         |
| [Forced tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools#forcing-tool-use)                  | Makes Claude call a tool, or one specific tool, instead of answering directly.                                                               |
| [Memory tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool)                                        | Lets Claude store and read information across conversations in a directory of memory files.                                                  |
| ↳ [Memory tool helpers](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool#implement-the-memory-handler) | SDK helpers that handle the memory tool’s interface and tool-use loop, so your code supplies only the storage.                               |
| [Message streaming](https://platform.claude.com/docs/en/build-with-claude/streaming)                                            | Receiving a Messages API response incrementally, as server-sent events, while it is generated.                                               |
| ↳ [Fine-grained tool streaming](https://platform.claude.com/docs/en/agents-and-tools/tool-use/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](https://platform.claude.com/docs/en/build-with-claude/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](https://platform.claude.com/docs/en/build-with-claude/compaction-on-demand)                              | Replaces the earlier messages of a conversation with a summary that Claude writes when your application asks for it.                         |
| ↳ [Background compaction](https://platform.claude.com/docs/en/build-with-claude/compaction-background)                          | Runs the on-demand compaction request while the conversation continues on its full history, then swaps in the summary when it arrives.       |
| ↳ [Compaction and preserved thinking](https://platform.claude.com/docs/en/build-with-claude/compaction-thinking-blocks)         | Thinking blocks in the turns you keep after on-demand compaction can stay valid, under stated conditions, on models with preserved thinking. |
| ↳ [Keep-tail compaction](https://platform.claude.com/docs/en/build-with-claude/compaction-keep-recent-turns)                    | On-demand compaction that summarizes the older turns and keeps the last few turns word for word after the summary.                           |
| ↳ [Tool runner compaction helper](https://platform.claude.com/docs/en/build-with-claude/compaction-on-demand#compact-in-a-loop) | 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](https://platform.claude.com/docs/en/cli-sdks-libraries/libraries/openai-sdk)                         | A compatibility layer that lets you call the Claude API with the OpenAI SDK, meant for testing and comparing models.                         |
| [Strict tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/strict-tool-use)                                | Makes Claude’s tool inputs always match the tool’s JSON Schema.                                                                              |
| [Text editor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool)                              | Lets Claude view, create, and edit text files with an Anthropic-defined tool.                                                                |
| [Typed structured output helpers](https://platform.claude.com/docs/en/build-with-claude/structured-outputs#usage)               | 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](https://platform.claude.com/docs/en/managed-agents/agent-setup)                    | A reusable, versioned configuration of the model, system prompt, tools, MCP servers and skills that a session runs.                                          |
| [Agent toolset](https://platform.claude.com/docs/en/managed-agents/tools)                                 | 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](https://platform.claude.com/docs/en/managed-agents/environments)                        | Isolated Linux containers on Anthropic-managed infrastructure where a session’s tools and code run.                                                          |
| [Console agent builder](https://platform.claude.com/docs/en/managed-agents/onboarding)                    | A visual interface in the Claude Console to create, configure and test agents.                                                                               |
| [Dreams](https://platform.claude.com/docs/en/managed-agents/dreams)                                       | A job that reads a memory store and past session transcripts and writes a new, reorganized memory store.                                                     |
| [Event deltas](https://platform.claude.com/docs/en/managed-agents/event-deltas)                           | Live previews of the agent’s response text on the session event stream while the model is still generating it.                                               |
| [GitHub access](https://platform.claude.com/docs/en/managed-agents/github)                                | Access to GitHub from a session: repositories mounted in the sandbox, and the GitHub MCP server for pull requests.                                           |
| [Memory stores](https://platform.claude.com/docs/en/managed-agents/memory)                                | Collections of text documents that an agent reads and writes, so that information persists across sessions.                                                  |
| [Multiagent orchestration](https://platform.claude.com/docs/en/managed-agents/multiagent-orchestration)   | Lets the agent of a session hand work to other agents, as subagents or in workflows, and consult an advisor model.                                           |
| ↳ [Dynamic workflows](https://platform.claude.com/docs/en/managed-agents/workflow-runs)                   | Programs that an agent writes to run many agents in the background and combine their results.                                                                |
| ↳ [Session threads](https://platform.claude.com/docs/en/managed-agents/session-threads)                   | The thread in which each agent of a multiagent session works, which you can list, stream, interrupt and archive.                                             |
| [Outcomes](https://platform.claude.com/docs/en/managed-agents/define-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](https://platform.claude.com/docs/en/managed-agents/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](https://platform.claude.com/docs/en/managed-agents/scheduled-deployments)         | Runs an agent on a cron schedule, so that the agent starts sessions by itself.                                                                               |
| [Self-hosted Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/self-hosted)       | The whole Managed Agents service on your own infrastructure: you host the API, the agent loop, the storage, and the sandboxes.                               |
| [Self-hosted sandboxes](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes)         | Sandboxes on your own infrastructure that run the agent’s tool calls, while Claude still runs on Anthropic’s side.                                           |
| ↳ [Self-hosted workers](https://platform.claude.com/docs/en/managed-agents/self-hosted-sandboxes-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](https://platform.claude.com/docs/en/managed-agents/session-observability)                | A session viewer in the Claude Console and per-session usage totals, to see what an agent did and what it used.                                              |
| [Vaults](https://platform.claude.com/docs/en/managed-agents/vaults)                                       | Stores of per-user credentials for third-party services that you register once and reference by ID when you create a session.                                |
| [Webhooks](https://platform.claude.com/docs/en/managed-agents/webhooks)                                   | Notifications to your HTTPS endpoint when events happen in your Managed Agents resources, such as a change in a session’s status.                            |
