One read of Claude Developer Platform

 
 ### Migrating to Claude Opus 5 from Claude Opus 4.7
 
-Claude Opus 5 should have strong out-of-the-box performance on existing Claude Opus 4.7 prompts and evals, at the same pricing of $5 per million input tokens and $25 per million output tokens. It supports the same set of features as Claude Opus 4.7, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows), [128k max output tokens](https://platform.claude.com/docs/en/about-claude/models/overview), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview), with two exceptions: [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool) is not available on Claude Opus 5, and [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5. It also adds [mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) and publicly documents [refusal stop details](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#refusal-response).
+Claude Opus 5 should have strong out-of-the-box performance on existing Claude Opus 4.7 prompts and evals, at the same pricing of $5 per million input tokens and $25 per million output tokens. It supports the same set of features as Claude Opus 4.7, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows), [128k max output tokens](https://platform.claude.com/docs/en/about-claude/models/overview), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview), with two exceptions: [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool) is not available on Claude Opus 5, and [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5. It also adds [mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) and publicly documents [refusal stop details](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#refusal-response). On the Claude API, Claude Opus 5 also supports [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) as the generally available `computer_toolset_20260801` toolset and the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) for tasks inside webpages, neither of which Claude Opus 4.7 supports; existing integrations on the earlier `computer_20251124` version continue to work unchanged on both models. To upgrade an existing integration, see [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).
 
 <Note>
   If your code is on Claude Opus 4.6 or earlier, use [Migrating to Claude Opus 5 from Claude Opus 4.6 and earlier Opus models](https://platform.claude.com/docs/en/about-claude/models/migration-guide#migrating-from-claude-opus-46) instead. That section includes breaking changes (sampling parameters rejected, manual extended thinking rejected, new tokenizer) that the upgrade from Claude Opus 4.7 alone does not cover.

 * [Vision](https://platform.claude.com/docs/en/build-with-claude/vision)
 * Server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview) ([bash](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool), [code execution](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool), [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool), [text editor](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool), [web search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool), [MCP connector](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector), [memory](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool))
 
-Two exceptions: [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool) is not available on Claude Opus 5, and [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5.
+Two exceptions: [web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool) is not available on Claude Opus 5, and [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not supported on Claude Opus 5. On the Claude API, Claude Opus 5 also supports [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) as the generally available `computer_toolset_20260801` toolset and the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) for tasks inside webpages, neither of which Claude Opus 4.6 or earlier Opus models support; existing integrations on the earlier `computer_20251124` version continue to work unchanged on Claude Opus 5. To upgrade an existing integration, see [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).
 
 #### Update your model name
 

 
 Claude Sonnet 5 offers the best combination of speed and intelligence in the Claude model family. It builds on Claude Sonnet 4.6.
 
-Claude Sonnet 5 is a drop-in upgrade for Claude Sonnet 4.6, priced at $2/$10 USD per million input/output tokens; see [Pricing](https://platform.claude.com/docs/en/about-claude/pricing) for details. There are two breaking API changes for code already running on Claude Sonnet 4.6: manual extended thinking (`thinking: {type: "enabled", budget_tokens: N}`) and sampling parameters (`temperature`, `top_p`, `top_k`) set to non-default values are no longer accepted and return a 400 error. Use [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) with the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) instead. Claude Sonnet 5 supports the same set of features as Claude Sonnet 4.6, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and the full set of server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview). [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not available on Claude Sonnet 5. Claude Sonnet 5 also uses a new tokenizer.
+Claude Sonnet 5 is a drop-in upgrade for Claude Sonnet 4.6, priced at $2/$10 USD per million input/output tokens; see [Pricing](https://platform.claude.com/docs/en/about-claude/pricing) for details. There are two breaking API changes for code already running on Claude Sonnet 4.6: manual extended thinking (`thinking: {type: "enabled", budget_tokens: N}`) and sampling parameters (`temperature`, `top_p`, `top_k`) set to non-default values are no longer accepted and return a 400 error. Use [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) with the [effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) instead. Claude Sonnet 5 supports the same set of features as Claude Sonnet 4.6, including the [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows), [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking), [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching), [batch processing](https://platform.claude.com/docs/en/build-with-claude/batch-processing), the [Files API](https://platform.claude.com/docs/en/build-with-claude/files), [PDF support](https://platform.claude.com/docs/en/build-with-claude/pdf-support), [vision](https://platform.claude.com/docs/en/build-with-claude/vision), and the full set of server-side and client-side [tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview). On the Claude API, Claude Sonnet 5 also supports [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) as the generally available `computer_toolset_20260801` toolset and the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) for tasks inside webpages, neither of which Claude Sonnet 4.6 supports; existing integrations on the earlier `computer_20251124` version continue to work unchanged on both models. To upgrade an existing integration, see [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124). [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models) is not available on Claude Sonnet 5. Claude Sonnet 5 also uses a new tokenizer.
 
 ### Migrating to Claude Sonnet 5 from Claude Sonnet 4.6
 

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Skills API under the beta namespace; field names can differ from other SDKs.
   // List Anthropic-managed Skills
   $skills = $client->beta->skills->list(source: 'anthropic');
 

   ```
 
   ```php PHP
+  // The PHP SDK supports container skills only through $client->beta->messages with the skills beta.
   // Create a message with the PowerPoint Skill
   $response = $client->beta->messages->create(
       model: 'claude-opus-5',

 * **`tools`:** Enables code execution (required for Skills)
 
 <Note>
-  Skills are generally available on the Claude API and don't require a beta header. This covers the Skills API, the `container.skills` parameter, and the Files API. Requests that still send the `skills-2025-10-02` or `files-api-2025-04-14` header keep working, and the Skills API and Files API return the earlier response format for them. The PHP tabs in this quickstart still call the SDK's `beta` namespace and send those headers, so their printed output shows the earlier response fields.
-
-  The examples use the `code_execution_20260521` tool version, and the Step 3 code parses the result types that current tool versions return. Skills also work with older [code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) versions such as `code_execution_20250825`: any current code execution tool version satisfies the Skills requirement without a beta header. If you use a different version, use the tool `type` listed on the code execution tool page.
+  The examples use the `code_execution_20260521` tool version, and the Step 3 code parses the result types that current tool versions return. Skills also work with older [code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) versions such as `code_execution_20250825`: any current code execution tool version satisfies the Skills requirement. If you use a different version, use the tool `type` listed on the code execution tool page.
 </Note>
 
 When you make this request, Claude automatically matches your task to the relevant Skill. Because you asked for a presentation, Claude determines the PowerPoint Skill is relevant and loads its full instructions: the second level of progressive disclosure. Then Claude runs the Skill's code to create your presentation.

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Files API under the beta namespace; field names can differ from other SDKs.
   // Extract the file ID. The code execution tool runs the Skill's code through
   // its Bash sub-tool, and generated files appear as bash_code_execution_output
   // items inside the bash_code_execution_tool_result block.

   ```
 
   ```php PHP
+  // The PHP SDK supports container skills only through $client->beta->messages with the skills beta.
   $response = $client->beta->messages->create(
       model: 'claude-opus-5',
       maxTokens: 16000,

   ```
 
   ```php PHP
+  // The PHP SDK supports container skills only through $client->beta->messages with the skills beta.
   $response = $client->beta->messages->create(
       model: 'claude-opus-5',
       maxTokens: 16000,

   ```
 
   ```php PHP
+  // The PHP SDK supports container skills only through $client->beta->messages with the skills beta.
   $response = $client->beta->messages->create(
       model: 'claude-opus-5',
       maxTokens: 16000,

 
 ### Upload and analyze your own files
 
-To analyze your own data files (such as CSV, Excel, or images), upload them through the Files API and reference them in your request:
+To analyze your own data files (such as CSV, Excel, or images), upload them through the Files API and reference them in your request.
 
-<Note>
-  This workflow doesn't require a beta header: uploading and downloading files through the Files API and referencing them in `container_upload` blocks are all generally available.
-</Note>
-
 The Python environment can process various file types uploaded through the Files API, including:
 
 * CSV

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Files API under the beta namespace; field names can differ from other SDKs.
   $client = new Client();
 
   // Upload a file

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Files API under the beta namespace; field names can differ from other SDKs.
   $client = new Client();
 
   // Request code execution that creates files

 
 Computer use follows the standard [tool use pricing](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview#pricing). When using the computer use tool:
 
-**System prompt overhead:** The computer use beta adds 466–499 tokens to the system prompt
+**Toolset definition overhead:** Declaring `computer_toolset_20260801` with its default members adds about 4,500 input tokens to a request (about 4,520 on Claude Fable 5, Claude Mythos 5, Claude Opus 5, and Claude Opus 4.8, and about 4,590 on Claude Sonnet 5), which covers the member tool definitions and the tool use system prompt. Disabling `zoom` with `configs` removes about 410 of those tokens. The exact count for a request is reported in the response `usage`, and you can estimate it in advance with the [token counting endpoint](https://platform.claude.com/docs/en/build-with-claude/token-counting).
 
-**Computer use tool token usage:**
+**Earlier tool versions:** The following figures apply to the `computer_20251124` and `computer_20250124` tool versions, not to `computer_toolset_20260801`:
 
-| Model             | Input tokens per tool definition |
-| ----------------- | -------------------------------- |
-| Claude 4.x models | 735 tokens                       |
+* System prompt overhead: 466–499 tokens added to the system prompt
+* Tool definition: about 735 input tokens per tool definition (measured with `computer_20250124`)
 
 **Additional token consumption:**
 
-* Screenshot images (see [Vision pricing](https://platform.claude.com/docs/en/build-with-claude/vision))
+* Screenshot and zoom images returned in tool results, billed as image input (see [Vision pricing](https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size))
 * Tool execution results returned to Claude
 
 <Note>
   If you're also using bash or text editor tools alongside computer use, those tools have their own token costs as documented in their respective pages.
+</Note>
+
+#### Browser use tool
+
+Browser use follows the standard [tool use pricing](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview#pricing). When using the browser use tool:
+
+**Toolset definition overhead:** Declaring `browser_toolset_20260801` with its default members adds about 6,600 input tokens to a request (about 6,610 on Claude Fable 5, Claude Mythos 5, Claude Opus 5, and Claude Opus 4.8, and about 6,670 on Claude Sonnet 5), which covers the member tool definitions and the tool use system prompt. Enabling all four optional members adds about 880 tokens, and disabling members with `configs` reduces the count. The exact count for a request is reported in the response `usage`, and you can estimate it in advance with the [token counting endpoint](https://platform.claude.com/docs/en/build-with-claude/token-counting).
+
+**Additional token consumption:**
+
+* Screenshot and zoom images returned in tool results, billed as image input (see [Vision pricing](https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size))
+* Text tool results returned to Claude, such as accessibility trees, page text, and console or network entries
+
+<Note>
+  If you also use the computer use tool, bash tool, text editor tool, or your own tools alongside browser use, those tools have their own token costs as documented on their respective pages.
 </Note>
 
 ## Claude Managed Agents pricing

 ---
 title: Computer use tool
 url: https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool
-description: Give Claude screenshot, mouse, and keyboard control of a desktop environment with the computer use tool.
+description: Give Claude screenshot, mouse, and keyboard control of a desktop environment with the computer use tool, the computer_toolset_20260801 client toolset.
 ---
 
 ## Compatibility
-- Status: Beta
-- [Beta header](https://platform.claude.com/docs/en/api/beta-headers): `computer-use-2025-11-24`
 - [ZDR](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention): eligible (excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements))
-- Supported models: `claude-opus-5`, `claude-sonnet-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-opus-4-6`, `claude-sonnet-4-6`, `claude-opus-4-5-20251101`
-- Platforms: Claude API (beta), Claude Platform on AWS (beta), Amazon Bedrock (beta), Google Cloud (beta), Microsoft Foundry (beta)
+- Supported models: `claude-fable-5`, `claude-mythos-5`, `claude-opus-5`, `claude-sonnet-5`, `claude-opus-4-8`
+- Platforms: Claude API, Claude Platform on AWS (beta), Amazon Bedrock (beta), Google Cloud (beta), Microsoft Foundry (beta)
+- Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, and Claude Opus 4.5 support computer use only through the earlier `computer_20251124` tool version, which requires a beta header; see [Earlier tool versions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions).
+- Platforms other than the Claude API currently offer only the [earlier beta tool versions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions).
 
 Claude can interact with computer environments through the computer use tool, which provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.
 
+The computer use tool is an Anthropic-defined [client toolset](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets): one `{"type": "computer_toolset_20260801"}` entry in `tools` gives Claude 17 member tools such as `screenshot`, `left_click`, `type`, and `zoom`, and your application runs every call in an environment you control. It isn't currently available in [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/tools). Claude's calls are `tool_use` blocks whose `name` is the member and which carry `"toolset_name": "computer"`, often several per turn (a [batch action](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions)).
+
+For tasks that stay inside webpages, the [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) is the closer fit: its member tools read and act on the page itself, and it doesn't need a full desktop environment.
+
 <Note>
-  On Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.1 ([retired, except on Bedrock and Google Cloud](https://platform.claude.com/docs/en/about-claude/model-deprecations)), Claude Sonnet 4 ([retired, except on Bedrock and Google Cloud](https://platform.claude.com/docs/en/about-claude/model-deprecations)), and Claude Opus 4 ([retired, except on Google Cloud](https://platform.claude.com/docs/en/about-claude/model-deprecations)), use the earlier `computer-use-2025-01-24` [beta header](https://platform.claude.com/docs/en/api/beta-headers) instead of `computer-use-2025-11-24`.
-
-  Reach out through the [feedback form](https://forms.gle/H6UFuXaaLywri9hz6) to share your feedback on this feature.
+  Computer use is generally available on the Claude API as the `computer_toolset_20260801` toolset, with no beta header; see [Compatibility](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#compatibility) for the supported models.
+
+  Existing `computer_20251124` integrations keep working, and earlier tool versions remain available in beta for models and platforms that don't support the toolset. See [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) to upgrade, or [Earlier tool versions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) for the beta headers.
 </Note>
 
-## Overview
-
-Computer use is a beta feature that enables Claude to interact with desktop environments. This tool provides:
-
-* **Screenshot capture:** See what's currently displayed on screen
-* **Mouse control:** Click, drag, and move the cursor
-* **Keyboard input:** Type text and use keyboard shortcuts
-* **Desktop automation:** Interact with any application or interface
-
-While computer use can be augmented with other tools such as bash and text editor for more comprehensive automation workflows, computer use specifically refers to the computer use tool's capability to see and control desktop environments.
-
-For model support, see the [Tool reference](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference).
-
 ## Security considerations
 
-Computer use is a beta feature with unique risks distinct from standard API features. These risks are heightened when interacting with the internet.
+Computer use has unique risks distinct from standard API features. These risks are heightened when interacting with the internet.
 
 <Warning>
   To minimize risks, consider taking precautions such as:

 
 Inform end users of relevant risks and obtain their consent prior to enabling computer use in your own products.
 
-<Card title="Computer use reference implementation" icon="computer" href="https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo">
-  Get started with the computer use reference implementation that includes a web interface, Docker container, example tool implementations, and an agent loop.
-</Card>
-
 ## Quick start
 
-Here's how to get started with computer use:
+Add the computer use toolset to the `tools` array of a [Messages API](https://platform.claude.com/docs/en/api/messages/create) request as `{"type": "computer_toolset_20260801"}`. The request needs no beta header. This example also declares the [text editor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool) and [bash tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool), which Claude typically uses alongside computer use:
 
 <CodeGroup>
   ```bash cURL

     -H "content-type: application/json" \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
-    -H "anthropic-beta: computer-use-2025-11-24" \
     -d '{
       "model": "claude-opus-5",
       "max_tokens": 1024,
       "tools": [
         {
-          "type": "computer_20251124",
-          "name": "computer",
-          "display_width_px": 1024,
-          "display_height_px": 768,
-          "display_number": 1
+          "type": "computer_toolset_20260801"
         },
         {
           "type": "text_editor_20250728",

   ```
 
   ```bash CLI
-  ant beta:messages create --beta computer-use-2025-11-24 <<'YAML'
+  ant messages create <<'YAML'
   model: claude-opus-5
   max_tokens: 1024
   tools:
-    - type: computer_20251124
-      name: computer
-      display_width_px: 1024
-      display_height_px: 768
-      display_number: 1
+    - type: computer_toolset_20260801
     - type: text_editor_20250728
       name: str_replace_based_edit_tool
     - type: bash_20250124

   ```python Python
   client = anthropic.Anthropic()
 
-  response = client.beta.messages.create(
-      model="claude-opus-5",  # or another compatible model
+  response = client.messages.create(
+      model="claude-opus-5",
       max_tokens=1024,
       tools=[
-          {
-              "type": "computer_20251124",
-              "name": "computer",
-              "display_width_px": 1024,
-              "display_height_px": 768,
-              "display_number": 1,
-          },
+          {"type": "computer_toolset_20260801"},
           {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
           {"type": "bash_20250124", "name": "bash"},
       ],
       messages=[{"role": "user", "content": "Save a picture of a cat to my desktop."}],
-      betas=["computer-use-2025-11-24"],
   )
   print(response)
   ```

   ```typescript TypeScript
   const client = new Anthropic();
 
-  const response = await client.beta.messages.create({
+  const response = await client.messages.create({
     model: "claude-opus-5",
     max_tokens: 1024,
     tools: [
       {
-        type: "computer_20251124",
-        name: "computer",
-        display_width_px: 1024,
-        display_height_px: 768,
-        display_number: 1
+        type: "computer_toolset_20260801"
       },
       {
         type: "text_editor_20250728",

         name: "bash"
       }
     ],
-    messages: [{ role: "user", content: "Save a picture of a cat to my desktop." }],
-    betas: ["computer-use-2025-11-24"]
+    messages: [{ role: "user", content: "Save a picture of a cat to my desktop." }]
   });
 
   console.log(response);
   ```
 
   ```csharp C#
-  using Anthropic.Models.Beta.Messages;
-  using Messages = Anthropic.Models.Messages;
-
   var client = new AnthropicClient();
 
   var parameters = new MessageCreateParams
   {
-      Model = Messages::Model.ClaudeOpus5,
+      Model = Model.ClaudeOpus5,
       MaxTokens = 1024,
-      Tools = new BetaToolUnion[]
-      {
-          new BetaToolComputerUse20251124
-          {
-              DisplayWidthPx = 1024,
-              DisplayHeightPx = 768,
-              DisplayNumber = 1
-          },
-          new BetaToolTextEditor20250728(),
-          new BetaToolBash20250124()
-      },
+      Tools =
+      [
+          new ComputerToolset20260801(),
+          new ToolTextEditor20250728(),
+          new ToolBash20250124(),
+      ],
       Messages =
       [
-          new BetaMessageParam
+          new MessageParam
           {
               Role = Role.User,
-              Content = "Save a picture of a cat to my desktop."
-          }
+              Content = "Save a picture of a cat to my desktop.",
+          },
       ],
-      Betas = ["computer-use-2025-11-24"]
   };
 
-  var response = await client.Beta.Messages.Create(parameters);
+  var response = await client.Messages.Create(parameters);
   Console.WriteLine(response);
   ```
 
   ```go Go
   client := anthropic.NewClient()
 
-  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
+  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
   	Model:     anthropic.ModelClaudeOpus5,
   	MaxTokens: 1024,
-  	Tools: []anthropic.BetaToolUnionParam{
-  		{OfComputerUseTool20251124: &anthropic.BetaToolComputerUse20251124Param{
-  			DisplayWidthPx:  1024,
-  			DisplayHeightPx: 768,
-  			DisplayNumber:   anthropic.Int(1),
-  		}},
-  		{OfTextEditor20250728: &anthropic.BetaToolTextEditor20250728Param{}},
-  		{OfBashTool20250124: &anthropic.BetaToolBash20250124Param{}},
+  	Tools: []anthropic.ToolUnionParam{
+  		{OfComputerToolset20260801: &anthropic.ComputerToolset20260801Param{}},
+  		{OfTextEditor20250728: &anthropic.ToolTextEditor20250728Param{}},
+  		{OfBashTool20250124: &anthropic.ToolBash20250124Param{}},
   	},
-  	Messages: []anthropic.BetaMessageParam{
-  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Save a picture of a cat to my desktop.")),
-  	},
-  	Betas: []anthropic.AnthropicBeta{
-  		"computer-use-2025-11-24", // no SDK exposes a named constant for this beta yet
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(anthropic.NewTextBlock("Save a picture of a cat to my desktop.")),
   	},
   })
   if err != nil {
   	log.Fatal(err)
   }
-  fmt.Println(response)
+  fmt.Println(response.RawJSON())
   ```
 
   ```java Java
-  import com.anthropic.models.beta.messages.BetaMessage;
-  import com.anthropic.models.beta.messages.BetaToolBash20250124;
-  import com.anthropic.models.beta.messages.BetaToolComputerUse20251124;
-  import com.anthropic.models.beta.messages.BetaToolTextEditor20250728;
-  import com.anthropic.models.beta.messages.MessageCreateParams;
-  import com.anthropic.models.messages.Model;
+  import com.anthropic.models.messages.ComputerToolset20260801;
+  // ...
+  import com.anthropic.models.messages.ToolBash20250124;
+  import com.anthropic.models.messages.ToolTextEditor20250728;
 
   void main() {
       AnthropicClient client = AnthropicOkHttpClient.fromEnv();

       MessageCreateParams params = MessageCreateParams.builder()
           .model(Model.CLAUDE_OPUS_5)
           .maxTokens(1024L)
-          .addTool(BetaToolComputerUse20251124.builder()
-              .displayWidthPx(1024L)
-              .displayHeightPx(768L)
-              .displayNumber(1L)
-              .build())
-          .addTool(BetaToolTextEditor20250728.builder().build())
-          .addTool(BetaToolBash20250124.builder().build())
+          .addTool(ComputerToolset20260801.builder().build())
+          .addTool(ToolTextEditor20250728.builder().build())
+          .addTool(ToolBash20250124.builder().build())
           .addUserMessage("Save a picture of a cat to my desktop.")
-          .addBeta("computer-use-2025-11-24")
           .build();
 
-      BetaMessage response = client.beta().messages().create(params);
+      Message response = client.messages().create(params);
       IO.println(response);
   }
   ```

   ```php PHP
   $client = new Client();
 
-  $response = $client->beta->messages->create(
+  $response = $client->messages->create(
       maxTokens: 1024,
       messages: [
           ['role' => 'user', 'content' => 'Save a picture of a cat to my desktop.'],
       ],
       model: 'claude-opus-5',
       tools: [
-          [
-              'type' => 'computer_20251124',
-              'name' => 'computer',
-              'display_width_px' => 1024,
-              'display_height_px' => 768,
-              'display_number' => 1,
-          ],
+          ['type' => 'computer_toolset_20260801'],
           [
               'type' => 'text_editor_20250728',
               'name' => 'str_replace_based_edit_tool',

               'name' => 'bash',
           ],
       ],
-      betas: ['computer-use-2025-11-24'],
   );
 
   echo $response;

   ```ruby Ruby
   client = Anthropic::Client.new
 
-  response = client.beta.messages.create(
+  response = client.messages.create(
     model: "claude-opus-5",
     max_tokens: 1024,
     tools: [
-      {
-        type: "computer_20251124",
-        name: "computer",
-        display_width_px: 1024,
-        display_height_px: 768,
-        display_number: 1
-      },
+      { type: "computer_toolset_20260801" },
       {
         type: "text_editor_20250728",
         name: "str_replace_based_edit_tool"

     ],
     messages: [
       { role: "user", content: "Save a picture of a cat to my desktop." }
-    ],
-    betas: ["computer-use-2025-11-24"]
+    ]
   )
 
   puts response
   ```
 </CodeGroup>
 
-<Note>
-  A beta header is only required for the computer use tool.
-
-  The preceding example shows all three tools being used together, which requires the beta header because it includes the computer use tool.
-</Note>
+When Claude acts on the desktop, the response has a `stop_reason` of `tool_use` and contains one or more member `tool_use` blocks, each naming a member tool and carrying `"toolset_name": "computer"`. Partway through this task, after Claude has seen a screenshot of the desktop, a response might look like this:
+
+```json Output
+{
+  "id": "msg_01UZ3bXcQH8mTqNhVfL9eK2p",
+  "type": "message",
+  "role": "assistant",
+  "model": "claude-opus-5",
+  "content": [
+    {
+      "type": "text",
+      "text": "I'll open the web browser to find a picture of a cat."
+    },
+    {
+      "type": "tool_use",
+      "id": "toolu_01WkoTUvSHDzTBu2xnGk8Ep8",
+      "name": "left_click",
+      "toolset_name": "computer",
+      "input": { "coordinate": [512, 742] }
+    },
+    {
+      "type": "tool_use",
+      "id": "toolu_017nJn3RgSCkTMwuZDb4uUov",
+      "name": "screenshot",
+      "toolset_name": "computer",
+      "input": {}
+    }
+  ],
+  "stop_reason": "tool_use",
+  "stop_sequence": null
+}
+```
+
+Your application runs each call in order in your own environment, returns one `tool_result` block per `tool_use` block, and calls the API again; [How computer use works](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#how-computer-use-works) describes that loop, and the rest of this page shows how to implement it.
 
 ***
 

 
 <Steps>
   <Step title="Provide Claude with the computer use tool and a user prompt" icon="tool">
-    * Add the computer use tool (and optionally other tools) to your API request.
+    * Add the computer use toolset (and optionally other tools) to the `tools` array of your API request.
     * Include a user prompt that requires desktop interaction, for example, "Save a picture of a cat to my desktop."
   </Step>
 
-  <Step title="Claude selects the computer use tool" icon="wrench">
-    * Claude assesses if the computer use tool can help with the user's query.
-    * If yes, Claude constructs a properly formatted tool use request.
+  <Step title="Claude responds with member tool calls" icon="wrench">
+    * Claude assesses whether acting on the desktop can help with the user's query.
+    * If so, Claude responds with one or more member `tool_use` blocks, such as `screenshot`, `left_click`, or `type`, each carrying `"toolset_name": "computer"`. A response with several of these blocks is a [batch action](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions).
     * The API response has a `stop_reason` of `tool_use`, signaling a tool use request.
   </Step>
 
-  <Step title="Extract tool input, evaluate the tool on a computer, and return results" icon="computer">
-    * On your end, extract the tool name and input from Claude's request.
-    * Use the tool on a container or virtual machine.
-    * Continue the conversation with a new `user` message containing a `tool_result` content block.
+  <Step title="Run the calls in order and return results" icon="computer">
+    * Iterate over every `tool_use` block in the response, in order. For each one, dispatch on the member `name` together with `toolset_name`, and perform that action with the block's `input` on your container or virtual machine.
+    * Continue the conversation with a new `user` message that contains one `tool_result` block per `tool_use` block, matched by `tool_use_id` and each echoing `"toolset_name": "computer"`. Return an image for `screenshot` and `zoom`; a short text such as `OK` is enough for the other actions.
+    * If an action fails, return `is_error: true` for that block and answer the rest of the batch as described in [Batch actions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions).
   </Step>
 
-  <Step title="Claude continues calling computer use tools until it's completed the task" icon="arrows-clockwise">
-    * Claude analyzes the tool results to determine if more tool use is needed or the task has been completed.
-    * If Claude determines another tool is needed, it responds with another `tool_use` `stop_reason` and you should return to step 3.
-    * Otherwise, it crafts a text response to the user.
+  <Step title="Claude continues until the task is complete" icon="arrows-clockwise">
+    * Claude analyzes the tool results to determine if more actions are needed or the task has been completed.
+    * If Claude determines more actions are needed, it responds with another `tool_use` `stop_reason` and you should return to step 3.
+    * Otherwise, it returns a text response to the user.
   </Step>
 </Steps>
 
 The repetition of steps 3 and 4 without user input is referred to as the "agent loop" (that is, Claude responding with a tool use request and your application responding to Claude with the results of evaluating that request).
+
+### Batch actions
+
+Claude can plan a short sequence of actions, such as click, type, and then take a screenshot, and return them together in one response. This is called a batch action; it uses the same response shape as [parallel tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/parallel-tool-use) with one difference: you run the blocks in order rather than concurrently.
+
+A response with a three-action batch looks like this:
+
+```json
+{
+  "role": "assistant",
+  "content": [
+    {
+      "type": "tool_use",
+      "id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
+      "name": "left_click",
+      "toolset_name": "computer",
+      "input": { "coordinate": [640, 60] }
+    },
+    {
+      "type": "tool_use",
+      "id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
+      "name": "type",
+      "toolset_name": "computer",
+      "input": { "text": "pictures of cats" }
+    },
+    {
+      "type": "tool_use",
+      "id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
+      "name": "screenshot",
+      "toolset_name": "computer",
+      "input": {}
+    }
+  ]
+}
+```
+
+Return one `tool_result` block for each `tool_use` block, matched by `tool_use_id`, all in the next `user` message. Every result for a member tool must carry `"toolset_name": "computer"`; a result that omits it, or that names a different toolset than its `tool_use` block, is rejected. Only `screenshot` and `zoom` results need an image; for the other members, a short text acknowledgment such as `OK` is enough (`cursor_position` returns the coordinates as text):
+
+```json
+{
+  "role": "user",
+  "content": [
+    {
+      "type": "tool_result",
+      "tool_use_id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
+      "toolset_name": "computer",
+      "content": [{ "type": "text", "text": "OK" }]
+    },
+    {
+      "type": "tool_result",
+      "tool_use_id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
+      "toolset_name": "computer",
+      "content": [{ "type": "text", "text": "OK" }]
+    },
+    {
+      "type": "tool_result",
+      "tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
+      "toolset_name": "computer",
+      "content": [
+        {
+          "type": "image",
+          "source": {
+            "type": "base64",
+            "media_type": "image/png",
+            "data": "iVBORw0KGgo..."
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+**Run blocks in order and stop at the first failure.** Later actions in a batch usually depend on earlier ones: the `type` in this example enters text into whatever the preceding click focused. Run the blocks sequentially in the order they appear in `content`, and if one fails, don't run the rest. Every `tool_use` block still needs a `tool_result`, so answer the batch as follows:
+
+* For each action that succeeded, return its normal result.
+* For the action that failed, return `is_error: true` with a text description of what went wrong.
+* For every later action in the batch, return `is_error: true` with exactly this text (the browser use tool uses its own [halt text](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool#batch-actions)):
+
+```json
+{
+  "type": "tool_result",
+  "tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
+  "toolset_name": "computer",
+  "is_error": true,
+  "content": "Not executed: an earlier computer action in this turn failed."
+}
+```
+
+Claude then sees which actions succeeded, which one failed, and which were skipped, and replans on its next turn. A request that leaves any `tool_use` block in the batch unanswered is rejected with an `invalid_request_error`, so an agent loop that reads only the first block fails on its next call. If your application asks a human to confirm consequential actions, make that check before each block runs, because a batch can complete a multistep action within one turn.
+
+Claude typically finishes a batch with `screenshot` so it can observe the outcome before deciding what to do next. When a batch doesn't end with one, your application can attach a screenshot as an extra `image` block on the last result in the batch so that Claude always sees the current state of the screen, which saves a round trip compared with waiting for Claude to ask. You can also prompt Claude to end every batch with a screenshot (see [Optimize model performance with prompting](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#optimize-model-performance-with-prompting)).
 
 ### The computing environment
 

 
 ## How to implement computer use
 
-### Start with the reference implementation
-
-A [reference implementation](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo) is available that includes everything you need to get started with computer use:
-
-* A [containerized environment](https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/Dockerfile) suitable for computer use with Claude
-* Implementations of [the computer use tools](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo/computer_use_demo/tools)
-* An [agent loop](https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/computer_use_demo/loop.py) that interacts with the Claude API and runs the computer use tools
-* A web interface to interact with the container, agent loop, and tools.
+Upgrading an existing `computer_20251124` integration? Start with [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124); the rest of this section applies to both new and migrated integrations.
+
+<Tip>
+  The [computer use reference implementation](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo) is a complete working example: a [containerized environment](https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/Dockerfile) suitable for computer use, implementations of [the computer use tools](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo/computer_use_demo/tools), an [agent loop](https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/computer_use_demo/loop.py) that calls the Claude API and runs the tools, and a web interface for the container, loop, and tools.
+</Tip>
 
 ### Understand the agent loop
 
-The core of computer use is the "agent loop": a cycle where Claude requests tool actions, your application runs them, and returns results to Claude. The loop uses the client you created in the [Quick start](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#quick-start), a tool list shaped like the Quick start's `tools` array, and the tool-call processing helper defined in [Process Claude's tool calls](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#implement-the-computer-use-tool). Here's a simplified example:
-
-<CodeGroup>
-  ```bash cURL
-  # The agent loop is a stateful, multi-turn pattern that doesn't translate to a
-  # one-off shell command. See the SDK tabs for the implementation.
-  ```
-
-  ```bash CLI
-  # The agent loop is a stateful, multi-turn pattern that doesn't translate to a
-  # one-off shell command. See the SDK tabs for the implementation.
-  ```
-
+The core of computer use is the "agent loop": a cycle where Claude requests tool actions, your application runs them, and returns results to Claude. The loop uses the client you created in the [Quick start](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#quick-start), a `tools` array that declares only the computer use toolset, and the tool-call processing helper under [Implement the computer use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#implement-the-computer-use-tool). If you also declare other tools, such as the Quick start's bash and text editor tools, dispatch their `tool_use` blocks in the same pass; the helper answers only computer use member calls, and the loop treats a turn with no answered calls as finished. Here's a simplified example:
+
+<CodeGroup exclude="shell">
   ```python Python
-  def sampling_loop(model, messages, max_iterations=10):
+  def sampling_loop(model: str, messages: list[MessageParam], max_iterations: int = 10):
       """
       Run the computer-use agent loop until Claude stops requesting tools
       or the iteration limit is reached.
       """
       for _ in range(max_iterations):
-          response = client.beta.messages.create(
+          response = client.messages.create(
               model=model,
               max_tokens=4096,
               messages=messages,
               tools=TOOLS,
-              betas=["computer-use-2025-11-24"],
           )
 
           # Add Claude's response to the conversation history
           messages.append({"role": "assistant", "content": response.content})
 
-          # Run any tools Claude requested and collect results
+          # Run the actions Claude requested, in order, and collect the results
           tool_results = process_tool_calls(response)
           if not tool_results:
               return messages  # No more tool use; task complete
 
-          # Send tool results back to Claude for the next iteration
+          # Send every result back to Claude in a single user message
           messages.append({"role": "user", "content": tool_results})
 
       return messages

   ```typescript TypeScript
   async function samplingLoop(
     model: string,
-    messages: Anthropic.Beta.BetaMessageParam[],
+    messages: Anthropic.MessageParam[],
     maxIterations = 10,
-  ): Promise<Anthropic.Beta.BetaMessageParam[]> {
+  ): Promise<Anthropic.MessageParam[]> {
     // Run the computer-use agent loop until Claude stops requesting tools
     // or the iteration limit is reached.
     for (let i = 0; i < maxIterations; i++) {
-      const response = await client.beta.messages.create({
+      const response = await client.messages.create({
         model,
         max_tokens: 4096,
         messages,
         tools,
-        betas: ["computer-use-2025-11-24"],
       });
 
       // Add Claude's response to the conversation history

   ```
 
   ```csharp C#
-  async Task<List<BetaMessageParam>> SamplingLoop(
+  async Task<List<MessageParam>> SamplingLoop(
       Model model,
-      List<BetaMessageParam> messages,
+      List<MessageParam> messages,
       int maxIterations = 10
   )
   {

       // or the iteration limit is reached.
       for (var i = 0; i < maxIterations; i++)
       {
-          var response = await client.Beta.Messages.Create(
+          var response = await client.Messages.Create(
               new MessageCreateParams
               {
                   Model = model,
                   MaxTokens = 4096,
                   Messages = messages,
                   Tools = tools,
-                  Betas = ["computer-use-2025-11-24"],
               }
           );
 

               {
                   Role = Role.Assistant,
                   Content = response
-                      .Content.Select(block => new BetaContentBlockParam(block.Json))
+                      .Content.Select(block => new ContentBlockParam(block.Json))
                       .ToList(),
               }
           );

   ```go Go
   // samplingLoop runs the computer-use agent loop until Claude stops
   // requesting tools or the iteration limit is reached.
-  func samplingLoop(ctx context.Context, model anthropic.Model, messages []anthropic.BetaMessageParam, maxIterations int) ([]anthropic.BetaMessageParam, error) {
+  func samplingLoop(ctx context.Context, model anthropic.Model, messages []anthropic.MessageParam, maxIterations int) ([]anthropic.MessageParam, error) {
   	for range maxIterations {
-  		response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
+  		response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
   			Model:     model,
   			MaxTokens: 4096,
   			Messages:  messages,
   			Tools:     tools,
-  			Betas:     []anthropic.AnthropicBeta{"computer-use-2025-11-24"},
   		})
   		if err != nil {
   			return nil, err

   		// Add Claude's response to the conversation history
   		messages = append(messages, response.ToParam())
 
-  		// Run any tools Claude requested and collect results
+  		// Run the actions Claude requested, in order, and collect the results
   		toolResults := processToolCalls(response)
   		if len(toolResults) == 0 {
   			return messages, nil // No more tool use; task complete
   		}
 
-  		// Send tool results back to Claude for the next iteration
-  		messages = append(messages, anthropic.BetaMessageParam{
-  			Role:    anthropic.BetaMessageParamRoleUser,
-  			Content: toolResults,
-  		})
+  		// Send every result back to Claude in a single user message
+  		messages = append(messages, anthropic.NewUserMessage(toolResults...))
   	}
   	return messages, nil
   }

    * Run the computer-use agent loop until Claude stops requesting tools
    * or the iteration limit is reached.
    */
-  List<BetaMessageParam> samplingLoop(Model model, List<BetaMessageParam> messages, int maxIterations) {
+  List<MessageParam> samplingLoop(Model model, List<MessageParam> messages, int maxIterations) {
       for (int i = 0; i < maxIterations; i++) {
-          BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
+          Message response = client.messages().create(MessageCreateParams.builder()
                   .model(model)
                   .maxTokens(4096)
                   .messages(messages)
-                  .addTool(COMPUTER_TOOL)
-                  .addBeta("computer-use-2025-11-24")
+                  .addTool(COMPUTER_TOOLSET)
                   .build());
 
           // Add Claude's response to the conversation history
-          messages.add(BetaMessageParam.builder()
-                  .role(BetaMessageParam.Role.ASSISTANT)
-                  .contentOfBetaContentBlockParams(
-                          response.content().stream().map(BetaContentBlock::toParam).toList())
+          messages.add(MessageParam.builder()
+                  .role(MessageParam.Role.ASSISTANT)
+                  .contentOfBlockParams(response.content().stream().map(ContentBlock::toParam).toList())
                   .build());
 
           // Run any tools Claude requested and collect results
-          List<BetaContentBlockParam> toolResults = processToolCalls(response);
+          List<ContentBlockParam> toolResults = processToolCalls(response);
           if (toolResults.isEmpty()) {
               return messages; // No more tool use; task complete
           }
 
           // Send tool results back to Claude for the next iteration
-          messages.add(BetaMessageParam.builder()
-                  .role(BetaMessageParam.Role.USER)
-                  .contentOfBetaContentBlockParams(toolResults)
+          messages.add(MessageParam.builder()
+                  .role(MessageParam.Role.USER)
+                  .contentOfBlockParams(toolResults)
                   .build());
       }
       return messages;

       global $client, $tools;
 
       for ($i = 0; $i < $maxIterations; $i++) {
-          $response = $client->beta->messages->create(
+          $response = $client->messages->create(
               model: $model,
               maxTokens: 4096,
               messages: $messages,
               tools: $tools,
-              betas: ['computer-use-2025-11-24'],
           );
 
           // Add Claude's response to the conversation history
-          $messages[] = BetaMessageParam::with(role: Role::ASSISTANT, content: $response->content);
+          $messages[] = MessageParam::with(role: Role::ASSISTANT, content: $response->content);
 
           // Run any tools Claude requested and collect results
           $toolResults = processToolCalls($response);

           }
 
           // Send tool results back to Claude for the next iteration
-          $messages[] = BetaMessageParam::with(role: Role::USER, content: $toolResults);
+          $messages[] = MessageParam::with(role: Role::USER, content: $toolResults);
       }
 
       return $messages;

   # or the iteration limit is reached.
   def sampling_loop(model, messages, max_iterations: 10)
     max_iterations.times do
-      response = CLIENT.beta.messages.create(
+      response = CLIENT.messages.create(
         model: model,
         max_tokens: 4096,
         messages: messages,
-        tools: TOOLS,
-        betas: ["computer-use-2025-11-24"]
+        tools: TOOLS
       )
 
       # Add Claude's response to the conversation history
-      messages << {role: "assistant", content: response.content}
-
-      # Run any tools Claude requested and collect results
+      messages << { role: "assistant", content: response.content }
+
+      # Run the actions Claude requested, in order, and collect the results
       tool_results = process_tool_calls(response)
       return messages if tool_results.empty? # No more tool use; task complete
 
-      # Send tool results back to Claude for the next iteration
-      messages << {role: "user", content: tool_results}
+      # Send every result back to Claude in a single user message
+      messages << { role: "user", content: tool_results }
     end
 
     messages

 
 The loop continues until either Claude responds without requesting any tools (task completion) or the maximum iteration limit is reached. This safeguard prevents potential infinite loops that could result in unexpected API costs.
 
-Try the reference implementation out before reading the rest of this documentation.
-
 ### Optimize model performance with prompting
-
-Here are some tips on how to get the best quality outputs:
 
 1. Specify simple, well-defined tasks and provide explicit instructions for each step.
 2. Claude sometimes assumes outcomes of its actions without explicitly checking their results. To prevent this you can prompt Claude with `After each step, take a screenshot and carefully evaluate if you have achieved the right outcome. Explicitly show your thinking: "I have evaluated step X..." If not correct, try again. Only when you confirm a step was executed correctly should you move on to the next one.`

 4. For repeatable tasks or UI interactions, include example screenshots and tool calls of successful outcomes in your prompt.
 5. If you need the model to log in, provide it with the username and password in your prompt inside XML tags such as `<robot_credentials>`. Using computer use within applications that require login increases the risk of bad outcomes as a result of prompt injection. Review [Mitigate jailbreaks and prompt injections](https://platform.claude.com/docs/en/test-and-evaluate/strengthen-guardrails/mitigate-jailbreaks) before providing the model with login credentials.
 6. When constructing a user turn's `content` array, place the instruction text *before* the screenshot image. Providing the target description before the image is processed improves click accuracy.
-7. When using `computer_20251124` with `enable_zoom: true` set, Claude zooms in on a region when asked about small text or specific UI elements that aren't legible at the screenshot's default resolution, such as file names in a sidebar, tab titles, status-bar text, line numbers, or button labels. If Claude isn't zooming when you expect, ask about a specific region or element rather than the screen as a whole.
+7. Claude uses the `zoom` action to inspect a region at full resolution when asked about small text or specific UI elements that aren't legible at the screenshot's default resolution, such as file names in a sidebar, tab titles, status-bar text, line numbers, or button labels. If Claude isn't zooming when you expect, ask about a specific region or element rather than the screen as a whole.
+8. If you want every [batch action](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions) to end with a screenshot, say so in the system prompt, for example, `End each group of actions with a screenshot so you can verify the result before continuing.`
 
 <Tip>
   If you repeatedly encounter a clear set of issues or know in advance the tasks Claude will need to complete, use the system prompt to provide Claude with explicit tips or instructions on how to do the tasks successfully.

 
 ### System prompts
 
-When one of the Anthropic-schema tools is requested through the Claude API, a computer use-specific system prompt is generated. It's similar to the [tool use system prompt](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools#tool-use-system-prompt) but starts with:
+When you include the computer use tool in a request, the API generates a computer use-specific system prompt. It's similar to the [tool use system prompt](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools#tool-use-system-prompt) but starts with:
 
 > You have access to a set of functions you can use to answer the user's question. This includes access to a sandboxed computing environment. You do NOT currently have the ability to inspect files or interact with external resources, except by invoking the below functions.
 

 
 ### Available actions
 
-The computer use tool supports these actions:
-
-**Basic actions (all versions)**
-
-* **screenshot:** Capture the current display
-* **left\_click:** Click at coordinates `[x, y]`
-* **type:** Type text string
-* **key:** Press key or key combination (for example, "ctrl+s")
-* **mouse\_move:** Move cursor to coordinates
-
-**Enhanced actions (`computer_20250124` and later)** Available in `computer_20250124` and `computer_20251124`:
-
-* **scroll:** Scroll in any direction with amount control
-* **left\_click\_drag:** Click and drag between coordinates
-* **right\_click**, **middle\_click:** Additional mouse buttons
-* **double\_click**, **triple\_click:** Multiple clicks
-* **left\_mouse\_down**, **left\_mouse\_up:** Fine-grained click control
-* **hold\_key:** Hold down a key for a specified duration (in seconds)
-* **wait:** Pause between actions
-
-**Enhanced actions (`computer_20251124`)** Available in Claude Opus 5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, and Claude Opus 4.5:
-
-* All actions from `computer_20250124`
-* **zoom:** View a specific region of the screen at full resolution. Requires `enable_zoom: true` in tool definition. Takes a `region` parameter with coordinates `[x1, y1, x2, y2]` defining top-left and bottom-right corners of the area to inspect.
+Each action is a member tool of the computer use toolset: Claude names the member in a `tool_use` block that carries `"toolset_name": "computer"`, and the block's `input` holds only that member's parameters, with no `action` field. The toolset has 17 member tools:
+
+| Member                                                        | Input                                                                                                                                                                                                        | Description                                                                                                                                                                                                                                                                   |
+| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `screenshot`                                                  | None (`{}`)                                                                                                                                                                                                  | Capture the full display and return it as an image.                                                                                                                                                                                                                           |
+| `zoom`                                                        | `region`: `[x0, y0, x1, y1]`, the top-left and bottom-right corners of the area to inspect                                                                                                                   | Capture only that region of the display at full resolution and return it as an image, scaled to fit within your usual screenshot dimensions with its aspect ratio preserved. This lets Claude read small text or dense UI that isn't legible in a downscaled full screenshot. |
+| `left_click`                                                  | `coordinate` (optional): `[x, y]`; `text` (optional): modifier keys to hold during the click: `shift`, `ctrl`, `alt`, `super` (the Command or Windows key), or a `+`-joined combination such as `ctrl+shift` | Click the left mouse button at `coordinate`, or at the current cursor position when `coordinate` is omitted.                                                                                                                                                                  |
+| `right_click`, `middle_click`, `double_click`, `triple_click` | Same as `left_click`                                                                                                                                                                                         | Other mouse buttons and multiple clicks.                                                                                                                                                                                                                                      |
+| `left_click_drag`                                             | `start_coordinate`: `[x, y]`; `coordinate`: `[x, y]`; `text` (optional): modifier keys                                                                                                                       | Press at `start_coordinate`, drag to `coordinate`, and release.                                                                                                                                                                                                               |
+| `mouse_move`                                                  | `coordinate`: `[x, y]`                                                                                                                                                                                       | Move the cursor without clicking, for example, to hover.                                                                                                                                                                                                                      |
+| `left_mouse_down`, `left_mouse_up`                            | None (`{}`)                                                                                                                                                                                                  | Press or release the left mouse button at the current cursor position, for drags that `left_click_drag` can't express. Move the cursor with `mouse_move` first.                                                                                                               |
+| `cursor_position`                                             | None (`{}`)                                                                                                                                                                                                  | Report the cursor's current `[x, y]` position as text.                                                                                                                                                                                                                        |
+| `scroll`                                                      | `scroll_direction`: `"up"`, `"down"`, `"left"`, or `"right"`; `scroll_amount`: number of scroll-wheel clicks; `coordinate` (optional): `[x, y]`; `text` (optional): modifier keys                            | Scroll at `coordinate`, or at the current cursor position.                                                                                                                                                                                                                    |
+| `type`                                                        | `text`: the string to type                                                                                                                                                                                   | Type literal text at the current keyboard focus.                                                                                                                                                                                                                              |
+| `key`                                                         | `text`: a key or a `+`-joined combination such as `"Return"`, `"ctrl+s"`, or `"alt+Tab"`; `repeat` (optional): 1 to 100, default 1                                                                           | Press a key or key combination, `repeat` times.                                                                                                                                                                                                                               |
+| `hold_key`                                                    | `text`: a key or combination; `duration`: seconds, up to 300                                                                                                                                                 | Hold a key down for the given duration.                                                                                                                                                                                                                                       |
+| `wait`                                                        | `duration`: seconds, up to 300                                                                                                                                                                               | Pause before the next action, for example, while an application loads.                                                                                                                                                                                                        |
+
+Keep the following in mind when implementing the members:
+
+* **Coordinates are in screenshot pixels.** Every `coordinate`, `start_coordinate`, and `region` value, and the position that `cursor_position` reports, is in the pixel space of the full-display screenshots you return, with the origin at the top left. Zoom images don't change this: after a `zoom`, Claude still expresses coordinates in the full screenshot's space, never relative to the zoomed image. If you scale screenshots down before returning them, scale Claude's coordinates back up before applying them to the real display (see [Size screenshots to fit image limits](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)).
+* **All members are enabled by default, including `zoom`.** If your environment can't produce zoom images, withhold the member with `configs` (see [Tool parameters](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#tool-parameters)) rather than leaving it enabled and returning errors. If Claude calls a member that you have withheld or don't implement, return a `tool_result` with `is_error: true` for that block.
+* **Dispatch on the pair (`toolset_name`, `name`).** `toolset_name` is what marks a block as a computer action: a custom tool in the same request can share a member's name, and a later toolset version can add members (see [Client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets)).
 
 <Accordion title="Example actions">
-  Take a screenshot:
+  Each example is a complete `tool_use` block as it appears in Claude's response.
+
+  Shift+click at a position, for example, to extend a selection. Unlike `hold_key`, `text` holds the modifiers only for the duration of that click or scroll:
 
   ```json
   {
-    "action": "screenshot"
+    "type": "tool_use",
+    "id": "toolu_01Qg8m3XqC5aRy7tD2eS4jUg",
+    "name": "left_click",
+    "toolset_name": "computer",
+    "input": { "coordinate": [500, 300], "text": "shift" }
   }
   ```
 
-  Click at position:
+  Drag from one point to another:
 
   ```json
   {
-    "action": "left_click",
-    "coordinate": [500, 300]
+    "type": "tool_use",
+    "id": "toolu_01Ed6j9VnA3yPw5rB8cQ2gSe",
+    "name": "left_click_drag",
+    "toolset_name": "computer",
+    "input": {
+      "start_coordinate": [200, 300],
+      "coordinate": [600, 300]
+    }
   }
   ```
 
-  Type text:
+  Scroll down three clicks of the wheel:
 
   ```json
   {
-    "action": "type",
-    "text": "Hello, world!"
+    "type": "tool_use",
+    "id": "toolu_01Yc5h8UmZ2xNv4qA7bP9fRd",
+    "name": "scroll",
+    "toolset_name": "computer",
+    "input": {
+      "coordinate": [500, 400],
+      "scroll_direction": "down",
+      "scroll_amount": 3
+    }
   }
   ```
 
-  Scroll down:
+  Press Tab four times:
 
   ```json
   {
-    "action": "scroll",
-    "coordinate": [500, 400],
-    "scroll_direction": "down",
-    "scroll_amount": 3
+    "type": "tool_use",
+    "id": "toolu_01Sb4g7TkY9wLu3pX6zM8eQc",
+    "name": "key",
+    "toolset_name": "computer",
+    "input": { "text": "Tab", "repeat": 4 }
   }
   ```
 
-  Zoom to view region in detail (Claude Opus 5, Sonnet 5, Opus 4.8, Opus 4.7, Opus 4.6, Sonnet 4.6, and Opus 4.5):
+  Zoom in to inspect a region at full resolution:
 
   ```json
   {
-    "action": "zoom",
-    "region": [100, 200, 400, 350]
+    "type": "tool_use",
+    "id": "toolu_01Kf7k2WpB4zQx6sC9dR3hTf",
+    "name": "zoom",
+    "toolset_name": "computer",
+    "input": { "region": [100, 200, 400, 350] }
   }
   ```
-</Accordion>
-
-<Accordion title="Modifier keys with click and scroll actions">
-  To hold modifier keys (such as Shift, Ctrl, or Alt) while performing click or scroll actions, use the `text` parameter on those actions. This is different from `hold_key`, which holds a key for a duration without performing other actions.
-
-  Shift+click (for example, to select a range of items):
+
+  Report the cursor position. Answer this call with a short text result that gives the position in screenshot pixels, for example, `X=512, Y=384`:
 
   ```json
   {
-    "action": "left_click",
-    "coordinate": [500, 300],
-    "text": "shift"
+    "type": "tool_use",
+    "id": "toolu_01Ekh3vqB6yTs2mNc4Rw8pLd",
+    "name": "cursor_position",
+    "toolset_name": "computer",
+    "input": {}
   }
   ```
-
-  Ctrl+click (for example, to multi-select on Windows/Linux):
-
-  ```json
-  {
-    "action": "left_click",
-    "coordinate": [500, 300],
-    "text": "ctrl"
-  }
-  ```
-
-  Cmd+click (for example, to multi-select on macOS):
-
-  ```json
-  {
-    "action": "left_click",
-    "coordinate": [500, 300],
-    "text": "super"
-  }
-  ```
-
-  Shift+scroll (for example, to scroll horizontally):
-
-  ```json
-  {
-    "action": "scroll",
-    "coordinate": [500, 400],
-    "scroll_direction": "down",
-    "scroll_amount": 3,
-    "text": "shift"
-  }
-  ```
-
-  The `text` parameter in click/scroll actions accepts modifier keys such as `shift`, `ctrl`, `alt`, and `super` (for the Command/Windows key).
 </Accordion>
 
 ### Tool parameters
 
-| Parameter           | Required | Description                                                                                                                         |
-| ------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------- |
-| `type`              | Yes      | Tool version (`computer_20251124` or `computer_20250124`)                                                                           |
-| `name`              | Yes      | Must be "computer"                                                                                                                  |
-| `display_width_px`  | Yes      | Display width in pixels                                                                                                             |
-| `display_height_px` | Yes      | Display height in pixels                                                                                                            |
-| `display_number`    | No       | Display number for X11 environments                                                                                                 |
-| `enable_zoom`       | No       | Enable zoom action (`computer_20251124` only). Set to `true` to allow Claude to zoom into specific screen regions. Default: `false` |
-
-<Note>
-  **Important:** Your application must explicitly run the computer use tool; Claude cannot run it directly. You are responsible for implementing the screenshot capture, mouse movements, keyboard inputs, and other actions based on Claude's requests.
-</Note>
+The toolset entry in the `tools` array accepts four parameters; the rules they share with the browser use toolset are listed under [Client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets).
+
+| Parameter         | Required | Description                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ----------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `type`            | Yes      | `computer_toolset_20260801`                                                                                                                                                                                                                                                                                                                                                                                        |
+| `configs`         | No       | Per-member settings keyed by member name; each member accepts `enabled` (default `true` for all 17, including `zoom`) and `defer_loading` (default `false`, for [tool search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool#deferred-tool-loading)), and members you omit keep their defaults.                                                                                    |
+| `cache_control`   | No       | [Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) breakpoint at the toolset definition; entry only. A breakpoint on any `tool_use` or `tool_result` block in a batch takes effect at the end of that batch; see [Tool use with prompt caching](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-use-with-prompt-caching#cache-control-on-tool-definitions). |
+| `allowed_callers` | No       | `["direct"]` only.                                                                                                                                                                                                                                                                                                                                                                                                 |
+
+For example, this entry withholds `zoom` for an environment that doesn't implement it and sets a cache breakpoint at the toolset definition:
+
+```json
+{
+  "type": "computer_toolset_20260801",
+  "configs": {
+    "zoom": { "enabled": false }
+  },
+  "cache_control": { "type": "ephemeral" }
+}
+```
+
+If your agent loop can run only one action per round trip, set `disable_parallel_tool_use` to `true` in `tool_choice`; Claude then returns at most one member `tool_use` block per turn (see [Disable parallel tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/parallel-tool-use#disable-parallel-tool-use)).
+
+The entry rejects these parameters from earlier tool versions, and a request that includes any of them returns an `invalid_request_error`:
+
+* `name`: member names are fixed by the toolset version.
+* `display_width_px`, `display_height_px`, and `display_number`: coordinates are always in the pixel space of the screenshots you return.
+* `enable_zoom`: zoom is a member tool that you control through `configs`.
+
+The entry also can't be declared in the same request as a `computer_20251124` entry or another tool named `computer`. For `strict`, `input_examples`, `defer_loading` placement, `tool_choice`, streaming, and caller restrictions, see [Client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets).
 
 ### Combining with thinking
 
 For combining computer use with thinking, see [Thinking](https://platform.claude.com/docs/en/build-with-claude/thinking).
 
 <Tip>
-  For computer use specifically, internal benchmarking suggests these `effort` settings:
+  For the earlier `computer_20251124` tool, internal benchmarking on the models that use it suggests these `effort` settings:
 
   * **Claude Opus 4.7:** use `high` as the default; use `low` for high-throughput or cost-sensitive workloads.
   * **Claude Sonnet 4.6 and Claude Opus 4.6:** use `medium` as the default (best accuracy-to-cost ratio). Avoid `max`, which adds token cost without improving accuracy on UI tasks. On these models, `low` uses *fewer* output tokens than disabling thinking entirely (fewer mistakes mean fewer retries), making it a strong option for cost-sensitive loops.

 
 To add other tools alongside computer use, include them in the same `tools` array. The [Quick start](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#quick-start) section shows this pattern with the [bash tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool) and [text editor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool). You can add your own [custom tool definitions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools) the same way.
 
+For tasks that stay inside webpages, you can also [declare the browser use tool in the same request](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool#combine-with-other-tools): the two toolsets work independently, each in its own coordinate frame, and calls to members that share a name, such as `screenshot` or `key`, are told apart by `toolset_name`.
+
 ### Build a custom computer use environment
 
 The [reference implementation](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo) is meant to help you get started with computer use. It includes all of the components needed to have Claude use a computer. However, you can build your own environment for computer use to suit your needs. You'll need:
 
 * A virtualized or containerized environment suitable for computer use with Claude
-* An implementation of at least one of the Anthropic-schema computer use tools
+* An implementation of the computer use tool's actions
 * An agent loop that interacts with the Claude API and runs the `tool_use` results using your tool implementations
 * An API or UI that allows user input to start the agent loop
 
-#### Implement the computer use tool
+### Implement the computer use tool
 
 The computer use tool is implemented as a schema-less tool. When using this tool, you don't need to provide an input schema as with other tools; the schema is built into Claude's model and can't be modified.
 

   <Step title="Implement action handlers">
     Create functions to handle each action type that Claude might request:
 
-    <CodeGroup>
-      ```bash cURL
-      # This is application-side helper code with no API request. See the SDK tabs
-      # for the pattern.
-      ```
-
-      ```bash CLI
-      # This is application-side helper code with no API request. See the SDK tabs
-      # for the pattern.
-      ```
-
+    <CodeGroup exclude="shell">
       ```python Python
-      def capture_screenshot():
-          return "<screenshot data>"
-
-
-      def click_at(x, y):
+      # Placeholder image data; a real executor captures the screen and returns the PNG bytes
+      PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+
+
+      def capture_screenshot() -> list[ImageBlockParam]:
+          # screenshot answers with an image block rather than text: return the result content list
+          return [
+              {
+                  "type": "image",
+                  "source": {"type": "base64", "media_type": "image/png", "data": PLACEHOLDER_PNG},
+              }
+          ]
+
+
+      def click(coordinate=None):
+          if coordinate is None:
+              return "clicked at current cursor"
+          x, y = coordinate
           return f"clicked at ({x}, {y})"
 
 

           return f"typed: {text}"
 
 
-      def handle_computer_action(action_type, params):
-          if action_type == "screenshot":
+      def handle_computer_action(name, tool_input):
+          if name == "screenshot":
               return capture_screenshot()
-          elif action_type == "left_click":
-              x, y = params["coordinate"]
-              return click_at(x, y)
-          elif action_type == "type":
-              return type_text(params["text"])
+          elif name == "left_click":
+              # coordinate is optional; without it, click where the cursor already is
+              return click(tool_input.get("coordinate"))
+          elif name == "type":
+              return type_text(tool_input["text"])
           # Handle other actions as needed
-          return f"unhandled action: {action_type}"
+          raise ValueError(f"Unknown or unimplemented member: {name}")
       ```
 
       ```typescript TypeScript
-      function captureScreenshot(): string {
-        return "<screenshot data>";
+      // Placeholder image data; a real executor captures the screen as PNG bytes
+      const PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
+
+      function captureScreenshot(): Anthropic.ImageBlockParam[] {
+        // screenshot answers with an image block rather than text
+        return [
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: PLACEHOLDER_PNG,
+            },
+          },
+        ];
       }
 
       function clickAt(x: number, y: number): string {
         return `clicked at (${x}, ${y})`;
       }
 
+      function clickAtCursor(): string {
+        return "clicked at the current cursor position";
+      }
+
       function typeText(text: string): string {
         return `typed: ${text}`;
       }
 
       function handleComputerAction(
-        actionType: string,
-        params: Record<string, unknown>,
-      ): string {
-        if (actionType === "screenshot") {
+        action: string,
+        input: unknown,
+      ): string | Anthropic.ImageBlockParam[] {
+        const params: object =
+          typeof input === "object" && input !== null ? input : {};
+        if (action === "screenshot") {
           return captureScreenshot();
-        } else if (actionType === "left_click") {
-          const [x, y] = params.coordinate as [number, number];
-          return clickAt(x, y);
-        } else if (actionType === "type") {
-          return typeText(params.text as string);
+        } else if (action === "left_click") {
+          // coordinate is optional on the toolset; without one, click at the cursor
+          if ("coordinate" in params && Array.isArray(params.coordinate)) {
+            const [x, y] = params.coordinate;
+            return clickAt(x, y);
+          }
+          return clickAtCursor();
+        } else if (action === "type" && "text" in params) {
+          return typeText(String(params.text));
         }
         // Handle other actions as needed
-        return `unhandled action: ${actionType}`;
+        throw new Error(`Unknown or unimplemented member: ${action}`);
       }
       ```
 
       ```csharp C#
-      string CaptureScreenshot() => "<screenshot data>";
+      // Placeholder image data; a real executor captures the screen and returns the PNG bytes
+      const string PlaceholderPng = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
+
+      // screenshot answers with an image block rather than text: return the result content list
+      List<Block> CaptureScreenshot() =>
+          [
+              new ImageBlockParam(
+                  new Base64ImageSource { Data = PlaceholderPng, MediaType = MediaType.ImagePng }
+              ),
+          ];
 
       string ClickAt(int x, int y) => $"clicked at ({x}, {y})";
 
+      string ClickAtCursor() => "clicked at the current cursor position";
+
       string TypeText(string text) => $"typed: {text}";
 
-      string HandleComputerAction(string actionType, IReadOnlyDictionary<string, JsonElement> input) =>
-          actionType switch
+      ToolResultBlockParamContent HandleComputerAction(
+          string action,
+          IReadOnlyDictionary<string, JsonElement> input
+      ) =>
+          action switch
           {
               "screenshot" => CaptureScreenshot(),
-              "left_click" => ClickAt(
-                  input["coordinate"][0].GetInt32(),
-                  input["coordinate"][1].GetInt32()
+              // coordinate is optional on click members; without it, click where the cursor is
+              "left_click" when input.TryGetValue("coordinate", out var xy) => ClickAt(
+                  xy[0].GetInt32(),
+                  xy[1].GetInt32()
               ),
+              "left_click" => ClickAtCursor(),
               "type" => TypeText(input["text"].GetString()!),
               // Handle other actions as needed
-              _ => $"unhandled action: {actionType}",
+              _ => throw new NotSupportedException($"Unknown or unimplemented member: {action}"),
           };
       ```
 
       ```go Go
-      func captureScreenshot() string {
-      	return "<screenshot data>"
+      // placeholderPNG stands in for a real capture: an executor returns the
+      // screen as base64-encoded PNG data.
+      const placeholderPNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+
+      // captureScreenshot returns an image block rather than text.
+      func captureScreenshot() []anthropic.ToolResultBlockParamContentUnion {
+      	return []anthropic.ToolResultBlockParamContentUnion{{
+      		OfImage: &anthropic.ImageBlockParam{
+      			Source: anthropic.ImageBlockParamSourceUnion{
+      				OfBase64: &anthropic.Base64ImageSourceParam{
+      					MediaType: anthropic.Base64ImageSourceMediaTypeImagePNG,
+      					Data:      placeholderPNG,
+      				},
+      			},
+      		},
+      	}}
+      }
+
+      // textContent wraps text as tool_result content.
+      func textContent(text string) []anthropic.ToolResultBlockParamContentUnion {
+      	return []anthropic.ToolResultBlockParamContentUnion{
+      		{OfText: &anthropic.TextBlockParam{Text: text}},
+      	}
       }
 
       func clickAt(x, y int) string {
       	return fmt.Sprintf("clicked at (%d, %d)", x, y)
       }
 
+      func clickAtCursor() string {
+      	return "clicked at the current cursor position"
+      }
+
       func typeText(text string) string {
       	return fmt.Sprintf("typed: %s", text)
       }
 
-      func handleComputerAction(actionType string, params map[string]any) string {
-      	switch actionType {
+      func handleComputerAction(action string, params map[string]any) ([]anthropic.ToolResultBlockParamContentUnion, error) {
+      	switch action {
       	case "screenshot":
-      		return captureScreenshot()
+      		return captureScreenshot(), nil
       	case "left_click":
-      		coord := params["coordinate"].([]any)
-      		return clickAt(int(coord[0].(float64)), int(coord[1].(float64)))
+      		// coordinate is optional; without it, click where the cursor already is
+      		coord, ok := params["coordinate"].([]any)
+      		if !ok {
+      			return textContent(clickAtCursor()), nil
+      		}
+      		if len(coord) == 2 {
+      			x, xok := coord[0].(float64)
+      			y, yok := coord[1].(float64)
+      			if xok && yok {
+      				return textContent(clickAt(int(x), int(y))), nil
+      			}
+      		}
       	case "type":
-      		return typeText(params["text"].(string))
+      		if text, ok := params["text"].(string); ok {
+      			return textContent(typeText(text)), nil
+      		}
       	// Handle other actions as needed
       	default:
-      		return fmt.Sprintf("unhandled action: %s", actionType)
+      		return nil, fmt.Errorf("unknown or unimplemented member: %s", action)
       	}
+      	// Reached when a member's input is missing a field or a field has the wrong type
+      	return nil, fmt.Errorf("invalid input for %s", action)
       }
 
       ```
 
       ```java Java
-      String captureScreenshot() {
-          return "<screenshot data>";
+      /** Placeholder pixels; a real executor captures the screen and base64-encodes the PNG. */
+      static final String PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
+
+      ToolResultBlockParam.Content captureScreenshot() {
+          ImageBlockParam image = ImageBlockParam.builder()
+                  .source(Base64ImageSource.builder()
+                          .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
+                          .data(PLACEHOLDER_PNG)
+                          .build())
+                  .build();
+          return ToolResultBlockParam.Content.ofBlocks(
+                  List.of(ToolResultBlockParam.Content.Block.ofImage(image)));
       }
 
       String clickAt(long x, long y) {
           return "clicked at (" + x + ", " + y + ")";
       }
 
+      String clickAtCursor() {
+          return "clicked at current cursor";
+      }
+
       String typeText(String text) {
           return "typed: " + text;
       }
 
-      String handleComputerAction(String actionType, Map<String, JsonValue> params) {
-          return switch (actionType) {
-              case "screenshot" -> captureScreenshot();
+      /** Runs one computer toolset member; {@code action} is the tool_use block's name. */
+      ToolResultBlockParam.Content handleComputerAction(String action, Map<String, JsonValue> input) {
+          if (action.equals("screenshot")) {
+              return captureScreenshot(); // the one member here that answers with an image block
+          }
+          String output = switch (action) {
               case "left_click" -> {
-                  List<JsonValue> coordinate = (List<JsonValue>) params.get("coordinate").asArray().get();
-                  long x = ((Number) coordinate.get(0).asNumber().get()).longValue();
-                  long y = ((Number) coordinate.get(1).asNumber().get()).longValue();
+                  JsonValue coordinate = input.get("coordinate"); // optional on the toolset
+                  if (coordinate == null) {
+                      yield clickAtCursor();
+                  }
+                  List<JsonValue> point = (List<JsonValue>) coordinate.asArray().get();
+                  long x = ((Number) point.get(0).asNumber().get()).longValue();
+                  long y = ((Number) point.get(1).asNumber().get()).longValue();
                   yield clickAt(x, y);
               }
-              case "type" -> typeText(params.get("text").asStringOrThrow());
+              case "type" -> typeText(input.get("text").asStringOrThrow());
               // Handle other actions as needed
-              default -> "unhandled action: " + actionType;
+              default -> throw new UnsupportedOperationException("Unknown or unimplemented member: " + action);
           };
+          return ToolResultBlockParam.Content.ofString(output);
       }
       ```
 
       ```php PHP
-      function captureScreenshot(): string
+      // Stand-in for real PNG bytes; a real executor captures the screen
+      const PLACEHOLDER_PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
+
+      function captureScreenshot(): array
       {
-          return '<screenshot data>';
-      }
-
-      function clickAt(int $x, int $y): string
+          // screenshot answers with an image block rather than text, so return the result content list
+          $image = [
+              'type' => 'image',
+              'source' => ['type' => 'base64', 'media_type' => 'image/png', 'data' => PLACEHOLDER_PNG],
+          ];
+
+          return [$image];
+      }
+
+      function clickAt(?array $coordinate): string
       {
+          // left_click may omit coordinate, in which case the click lands where the cursor already is
+          if ($coordinate === null) {
+              return 'clicked at current cursor';
+          }
+          [$x, $y] = $coordinate;
+
           return "clicked at ({$x}, {$y})";
       }
 

           return "typed: {$text}";
       }
 
-      function handleComputerAction(string $actionType, array $params): string
+      function handleComputerAction(string $name, array $input): string|array
       {
-          return match ($actionType) {
+          return match ($name) {
               'screenshot' => captureScreenshot(),
-              'left_click' => clickAt(...$params['coordinate']),
-              'type' => typeText($params['text']),
+              'left_click' => clickAt($input['coordinate'] ?? null),
+              'type' => typeText($input['text']),
               // Handle other actions as needed
-              default => "unhandled action: {$actionType}",
+              default => throw new RuntimeException("Unknown or unimplemented member: {$name}"),
           };
       }
       ```
 
       ```ruby Ruby
+      # Stand-in image data; a real executor captures the screen as a PNG.
+      PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+
+      # screenshot answers with an image block rather than text
       def capture_screenshot
-        "<screenshot data>"
+        [
+          {
+            type: "image",
+            source: { type: "base64", media_type: "image/png", data: PLACEHOLDER_PNG }
+          }
+        ]
       end
 
-      def click_at(x, y)
+      def click(coordinate = nil)
+        return "clicked at current cursor" if coordinate.nil?
+
+        x, y = coordinate
         "clicked at (#{x}, #{y})"
       end
 

         "typed: #{text}"
       end
 
-      def handle_computer_action(action_type, params)
-        case action_type
+      def handle_computer_action(name, input)
+        case name
         when "screenshot"
           capture_screenshot
         when "left_click"
-          x, y = params[:coordinate]
-          click_at(x, y)
+          # coordinate is optional; without it, click where the cursor already is
+          click(input[:coordinate])
         when "type"
-          type_text(params[:text])
+          type_text(input[:text])
         # Handle other actions as needed
         else
-          "unhandled action: #{action_type}"
+          raise ArgumentError, "Unknown or unimplemented member: #{name}"
         end
       end
       ```

   <Step title="Process Claude's tool calls">
     Extract and run tool calls from Claude's responses:
 
-    <CodeGroup>
-      ```bash cURL
-      # This is application-side helper code with no API request. See the SDK tabs
-      # for the pattern.
-      ```
-
-      ```bash CLI
-      # This is application-side helper code with no API request. See the SDK tabs
-      # for the pattern.
-      ```
-
+    <CodeGroup exclude="shell">
       ```python Python
-      def process_tool_calls(response):
-          tool_results = []
+      NOT_EXECUTED = "Not executed: an earlier computer action in this turn failed."
+
+
+      def process_tool_calls(response: Message) -> list[ToolResultBlockParam]:
+          """
+          Run the computer actions in Claude's response in order and answer each
+          one. After the first failure the rest are skipped, because Claude planned
+          them assuming the earlier actions succeeded.
+          """
+          tool_results: list[ToolResultBlockParam] = []
+          failed = False
           for block in response.content:
-              if block.type == "tool_use":
-                  action = block.input["action"]
-                  result = handle_computer_action(action, block.input)
-                  tool_results.append(
-                      {
-                          "type": "tool_result",
-                          "tool_use_id": block.id,
-                          "content": result,
-                      }
-                  )
+              # Only the computer toolset is declared; route other tools here if you add them
+              if block.type != "tool_use" or block.toolset_name != "computer":
+                  continue
+              result: ToolResultBlockParam = {
+                  "type": "tool_result",
+                  "tool_use_id": block.id,
+                  "toolset_name": "computer",
+              }
+              if failed:
+                  result["content"] = NOT_EXECUTED
+                  result["is_error"] = True
+              else:
+                  try:
+                      # A string, or a list of content blocks such as the screenshot image
+                      result["content"] = handle_computer_action(block.name, block.input)
+                  except Exception as err:
+                      result["content"] = f"Error: {err}"
+                      result["is_error"] = True
+                      failed = True
+              tool_results.append(result)
           return tool_results
       ```
 
       ```typescript TypeScript
+      const HALT_TEXT =
+        "Not executed: an earlier computer action in this turn failed.";
+
+      function computerResult(
+        toolUseId: string,
+        content: string | Anthropic.ImageBlockParam[],
+        isError?: boolean,
+      ): Anthropic.ToolResultBlockParam {
+        return {
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          toolset_name: "computer",
+          content,
+          is_error: isError,
+        };
+      }
+
       function processToolCalls(
-        response: Anthropic.Beta.BetaMessage,
-      ): Anthropic.Beta.BetaToolResultBlockParam[] {
-        const toolResults: Anthropic.Beta.BetaToolResultBlockParam[] = [];
+        response: Anthropic.Message,
+      ): Anthropic.ToolResultBlockParam[] {
+        const toolResults: Anthropic.ToolResultBlockParam[] = [];
+        let failed = false;
         for (const block of response.content) {
-          if (block.type === "tool_use") {
-            const input = block.input as Record<string, unknown>;
-            const action = input.action as string;
-            const result = handleComputerAction(action, input);
-            toolResults.push({
-              type: "tool_result",
-              tool_use_id: block.id,
-              content: result,
-            });
+          if (block.type !== "tool_use") {
+            continue;
+          }
+          if (block.toolset_name !== "computer") {
+            // This example declares only the computer toolset; route other tools
+            // here if you add them.
+            continue;
+          }
+          if (failed) {
+            // A batch stops at its first failure; answer later actions unexecuted
+            toolResults.push(computerResult(block.id, HALT_TEXT, true));
+            continue;
+          }
+          try {
+            // A string, or the image block list that screenshot returns
+            const result = handleComputerAction(block.name, block.input);
+            toolResults.push(computerResult(block.id, result));
+          } catch (error) {
+            failed = true;
+            const message = error instanceof Error ? error.message : String(error);
+            toolResults.push(computerResult(block.id, `Error: ${message}`, true));
           }
         }
         return toolResults;

       ```
 
       ```csharp C#
-      List<BetaContentBlockParam> ProcessToolCalls(BetaMessage response)
+      const string HaltText = "Not executed: an earlier computer action in this turn failed.";
+
+      List<ContentBlockParam> ProcessToolCalls(Message response)
       {
-          List<BetaContentBlockParam> toolResults = [];
+          List<ContentBlockParam> toolResults = [];
+          var failed = false;
           foreach (var block in response.Content)
           {
-              if (block.TryPickToolUse(out var toolUse))
+              if (!block.TryPickToolUse(out var toolUse))
               {
-                  var action = toolUse.Input["action"].GetString()!;
-                  var result = HandleComputerAction(action, toolUse.Input);
-                  toolResults.Add(new BetaToolResultBlockParam(toolUse.ID) { Content = result });
+                  continue;
+              }
+
+              if (toolUse.ToolsetName != "computer")
+              {
+                  // This example declares only the computer toolset; route other tools
+                  // here if you add them.
+                  continue;
+              }
+
+              if (failed)
+              {
+                  // A batch stops at its first failure; answer later actions without running them
+                  toolResults.Add(
+                      new ToolResultBlockParam(toolUse.ID)
+                      {
+                          Content = HaltText,
+                          IsError = true,
+                          ToolsetName = "computer",
+                      }
+                  );
+                  continue;
+              }
+
+              try
+              {
+                  // A string, or the image block list that screenshot returns
+                  var result = HandleComputerAction(toolUse.Name, toolUse.Input);
+                  toolResults.Add(
+                      new ToolResultBlockParam(toolUse.ID) { Content = result, ToolsetName = "computer" }
+                  );
+              }
+              catch (Exception e)
+              {
+                  failed = true;
+                  toolResults.Add(
+                      new ToolResultBlockParam(toolUse.ID)
+                      {
+                          Content = $"Error: {e.Message}",
+                          IsError = true,
+                          ToolsetName = "computer",
+                      }
+                  );
               }
           }
           return toolResults;

       ```
 
       ```go Go
-      func processToolCalls(response *anthropic.BetaMessage) []anthropic.BetaContentBlockParamUnion {
-      	var toolResults []anthropic.BetaContentBlockParamUnion
+      const notExecuted = "Not executed: an earlier computer action in this turn failed."
+
+      // computerToolResult builds the result for one computer action. Unlike an
+      // ordinary tool result, it must echo the toolset name.
+      func computerToolResult(toolUseID string, content []anthropic.ToolResultBlockParamContentUnion, isError bool) anthropic.ContentBlockParamUnion {
+      	result := anthropic.ToolResultBlockParam{
+      		ToolUseID:   toolUseID,
+      		ToolsetName: anthropic.String("computer"),
+      		Content:     content,
+      	}
+      	if isError {
+      		result.IsError = anthropic.Bool(true)
+      	}
+      	return anthropic.ContentBlockParamUnion{OfToolResult: &result}
+      }
+
+      // processToolCalls runs the computer actions in Claude's response in order and
+      // builds one tool_result per tool_use block. After the first failure it skips
+      // the rest: Claude planned them assuming the earlier actions succeeded.
+      func processToolCalls(response *anthropic.Message) []anthropic.ContentBlockParamUnion {
+      	var toolResults []anthropic.ContentBlockParamUnion
+      	failed := false
       	for _, block := range response.Content {
       		switch variant := block.AsAny().(type) {
-      		case anthropic.BetaToolUseBlock:
-      			input := variant.Input.(map[string]any)
-      			action := input["action"].(string)
-      			result := handleComputerAction(action, input)
-      			toolResults = append(toolResults, anthropic.NewBetaToolResultBlock(variant.ID, result, false))
+      		case anthropic.ToolUseBlock:
+      			// This example declares only the computer toolset; route other tools here if you add them.
+      			if variant.ToolsetName != "computer" {
+      				continue
+      			}
+      			if failed {
+      				toolResults = append(toolResults, computerToolResult(variant.ID, textContent(notExecuted), true))
+      				continue
+      			}
+      			var input map[string]any
+      			var content []anthropic.ToolResultBlockParamContentUnion
+      			err := json.Unmarshal(variant.Input, &input)
+      			if err == nil {
+      				// Text, or the image block that screenshot returns
+      				content, err = handleComputerAction(variant.Name, input)
+      			}
+      			if err != nil {
+      				failed = true
+      				content = textContent("Error: " + err.Error())
+      			}
+      			toolResults = append(toolResults, computerToolResult(variant.ID, content, err != nil))
       		}
       	}
       	return toolResults

       ```
 
       ```java Java
-      List<BetaContentBlockParam> processToolCalls(BetaMessage response) {
-          List<BetaContentBlockParam> toolResults = new ArrayList<>();
-          for (BetaContentBlock block : response.content()) {
-              if (block.isToolUse()) {
-                  BetaToolUseBlock toolUse = block.asToolUse();
-                  Map<String, JsonValue> input =
-                          (Map<String, JsonValue>) toolUse._input().asObject().get();
-                  String action = input.get("action").asStringOrThrow();
-                  String result = handleComputerAction(action, input);
-                  toolResults.add(BetaContentBlockParam.ofToolResult(
-                          BetaToolResultBlockParam.builder()
-                                  .toolUseId(toolUse.id())
-                                  .content(result)
-                                  .build()));
+      /** The exact text the toolset contract prescribes for member calls skipped after a failure. */
+      static final String HALT_TEXT = "Not executed: an earlier computer action in this turn failed.";
+
+      /** Every result answering a computer toolset member echoes toolset_name. */
+      ToolResultBlockParam.Builder computerResult(ToolUseBlock toolUse) {
+          return ToolResultBlockParam.builder()
+                  .toolUseId(toolUse.id())
+                  .toolsetName("computer");
+      }
+
+      /**
+       * Run the computer actions in Claude's response in order and build one
+       * tool_result per tool_use block. After the first failure, skip the rest:
+       * Claude planned them assuming the earlier actions succeeded.
+       */
+      List<ContentBlockParam> processToolCalls(Message response) {
+          List<ContentBlockParam> toolResults = new ArrayList<>();
+          boolean failed = false;
+          for (ContentBlock block : response.content()) {
+              // This example declares only the computer toolset; route other tools here if you add them.
+              if (!block.isToolUse() || !block.asToolUse().toolsetName().equals(Optional.of("computer"))) {
+                  continue;
+              }
+              ToolUseBlock toolUse = block.asToolUse();
+              ToolResultBlockParam result;
+              if (failed) {
+                  result = computerResult(toolUse).content(HALT_TEXT).isError(true).build();
+              } else {
+                  try {
+                      Map<String, JsonValue> input =
+                              (Map<String, JsonValue>) toolUse._input().asObject().get();
+                      // A string, or the image block that screenshot returns
+                      ToolResultBlockParam.Content output = handleComputerAction(toolUse.name(), input);
+                      result = computerResult(toolUse).content(output).build();
+                  } catch (RuntimeException e) {
+                      failed = true;
+                      result = computerResult(toolUse).content("Error: " + e.getMessage()).isError(true).build();
+                  }
+              }
+              toolResults.add(ContentBlockParam.ofToolResult(result));
+          }
+          return toolResults;
+      }
+      ```
+
+      ```php PHP
+      const HALT_TEXT = 'Not executed: an earlier computer action in this turn failed.';
+
+      function processToolCalls(Message $response): array
+      {
+          $toolResults = [];
+          $failed = false;
+          foreach ($response->content as $block) {
+              // This example declares only the computer toolset; route other tools here if you add them.
+              // Read toolset_name through array access: the SDK keeps it as raw data until a release types it.
+              if (!($block instanceof ToolUseBlock) || ($block['toolsetName'] ?? $block['toolset_name'] ?? null) !== 'computer') {
+                  continue;
+              }
+              $result = ['type' => 'tool_result', 'tool_use_id' => $block->id, 'toolset_name' => 'computer'];
+              if ($failed) {
+                  // A batch stops at its first failure; the remaining actions are answered without running
+                  $toolResults[] = [...$result, 'content' => HALT_TEXT, 'is_error' => true];
+                  continue;
+              }
+              try {
+                  // A string, or the image block list that screenshot returns
+                  $toolResults[] = [...$result, 'content' => handleComputerAction($block->name, $block->input)];
+              } catch (Throwable $e) {
+                  $failed = true;
+                  $toolResults[] = [...$result, 'content' => 'Error: ' . $e->getMessage(), 'is_error' => true];
               }
           }
-          return toolResults;
-      }
-      ```
-
-      ```php PHP
-      function processToolCalls(BetaMessage $response): array
-      {
-          $toolResults = [];
-          foreach ($response->content as $block) {
-              if ($block instanceof BetaToolUseBlock) {
-                  $action = $block->input['action'];
-                  $result = handleComputerAction($action, $block->input);
-                  $toolResults[] = BetaToolResultBlockParam::with(
-                      toolUseID: $block->id,
-                      content: $result,
-                  );
-              }
-          }
+
           return $toolResults;
       }
       ```
 
       ```ruby Ruby
+      NOT_EXECUTED = "Not executed: an earlier computer action in this turn failed."
+
+      # Run the computer actions in Claude's response in order and build one
+      # tool_result per tool_use block. After the first failure, skip the rest:
+      # Claude planned them assuming the earlier actions succeeded.
       def process_tool_calls(response)
         tool_results = []
+        failed = false
         response.content.each do |block|
-          next unless block.type == :tool_use
-
-          action = block.input[:action]
-          result = handle_computer_action(action, block.input)
-          tool_results << {
-            type: "tool_result",
-            tool_use_id: block.id,
-            content: result
-          }
+          # This example declares only the computer toolset; route other tools here
+          # if you add them.
+          next unless block.type == :tool_use && block.toolset_name == "computer"
+
+          result = { type: "tool_result", tool_use_id: block.id, toolset_name: "computer" }
+          if failed
+            result.update(content: NOT_EXECUTED, is_error: true)
+          else
+            begin
+              # A String, or the image content blocks that screenshot returns
+              result[:content] = handle_computer_action(block.name, block.input)
+            rescue => e
+              result.update(content: "Error: #{e.message}", is_error: true)
+              failed = true
+            end
+          end
+          tool_results << result
         end
         tool_results
       end

   </Step>
 
   <Step title="Implement the agent loop">
-    Create a loop that continues until Claude completes the task:
-
-    <CodeGroup>
-      ```bash cURL
-      # The agent loop is a stateful, multi-turn pattern that doesn't translate to a
-      # one-off shell command. See the SDK tabs for the implementation.
-      ```
-
-      ```bash CLI
-      # The agent loop is a stateful, multi-turn pattern that doesn't translate to a
-      # one-off shell command. See the SDK tabs for the implementation.
-      ```
-
-      ```python Python
-      def sampling_loop(model, messages, max_iterations=10):
-          """
-          Run the computer-use agent loop until Claude stops requesting tools
-          or the iteration limit is reached.
-          """
-          for _ in range(max_iterations):
-              response = client.beta.messages.create(
-                  model=model,
-                  max_tokens=4096,
-                  messages=messages,
-                  tools=TOOLS,
-                  betas=["computer-use-2025-11-24"],
-              )
-
-              # Add Claude's response to the conversation history
-              messages.append({"role": "assistant", "content": response.content})
-
-              # Run any tools Claude requested and collect results
-              tool_results = process_tool_calls(response)
-              if not tool_results:
-                  return messages  # No more tool use; task complete
-
-              # Send tool results back to Claude for the next iteration
-              messages.append({"role": "user", "content": tool_results})
-
-          return messages
-      ```
-
-      ```typescript TypeScript
-      async function samplingLoop(
-        model: string,
-        messages: Anthropic.Beta.BetaMessageParam[],
-        maxIterations = 10,
-      ): Promise<Anthropic.Beta.BetaMessageParam[]> {
-        // Run the computer-use agent loop until Claude stops requesting tools
-        // or the iteration limit is reached.
-        for (let i = 0; i < maxIterations; i++) {
-          const response = await client.beta.messages.create({
-            model,
-            max_tokens: 4096,
-            messages,
-            tools,
-            betas: ["computer-use-2025-11-24"],
-          });
-
-          // Add Claude's response to the conversation history
-          messages.push({ role: "assistant", content: response.content });
-
-          // Run any tools Claude requested and collect results
-          const toolResults = processToolCalls(response);
-          if (toolResults.length === 0) {
-            return messages; // No more tool use; task complete
-          }
-
-          // Send tool results back to Claude for the next iteration
-          messages.push({ role: "user", content: toolResults });
-        }
-
-        return messages;
-      }
-      ```
-
-      ```csharp C#
-      async Task<List<BetaMessageParam>> SamplingLoop(
-          Model model,
-          List<BetaMessageParam> messages,
-          int maxIterations = 10
-      )
-      {
-          // Run the computer-use agent loop until Claude stops requesting tools
-          // or the iteration limit is reached.
-          for (var i = 0; i < maxIterations; i++)
-          {
-              var response = await client.Beta.Messages.Create(
-                  new MessageCreateParams
-                  {
-                      Model = model,
-                      MaxTokens = 4096,
-                      Messages = messages,
-                      Tools = tools,
-                      Betas = ["computer-use-2025-11-24"],
-                  }
-              );
-
-              // Add Claude's response to the conversation history
-              messages.Add(
-                  new()
-                  {
-                      Role = Role.Assistant,
-                      Content = response
-                          .Content.Select(block => new BetaContentBlockParam(block.Json))
-                          .ToList(),
-                  }
-              );
-
-              // Run any tools Claude requested and collect results
-              var toolResults = ProcessToolCalls(response);
-              if (toolResults.Count == 0)
-              {
-                  return messages; // No more tool use; task complete
-              }
-
-              // Send tool results back to Claude for the next iteration
-              messages.Add(new() { Role = Role.User, Content = toolResults });
-          }
-
-          return messages;
-      }
-      ```
-
-      ```go Go
-      // samplingLoop runs the computer-use agent loop until Claude stops
-      // requesting tools or the iteration limit is reached.
-      func samplingLoop(ctx context.Context, model anthropic.Model, messages []anthropic.BetaMessageParam, maxIterations int) ([]anthropic.BetaMessageParam, error) {
-      	for range maxIterations {
-      		response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
-      			Model:     model,
-      			MaxTokens: 4096,
-      			Messages:  messages,
-      			Tools:     tools,
-      			Betas:     []anthropic.AnthropicBeta{"computer-use-2025-11-24"},
-      		})
-      		if err != nil {
-      			return nil, err
-      		}
-
-      		// Add Claude's response to the conversation history
-      		messages = append(messages, response.ToParam())
-
-      		// Run any tools Claude requested and collect results
-      		toolResults := processToolCalls(response)
-      		if len(toolResults) == 0 {
-      			return messages, nil // No more tool use; task complete
-      		}
-
-      		// Send tool results back to Claude for the next iteration
-      		messages = append(messages, anthropic.BetaMessageParam{
-      			Role:    anthropic.BetaMessageParamRoleUser,
-      			Content: toolResults,
-      		})
-      	}
-      	return messages, nil
-      }
-
-      ```
-
-      ```java Java
-      /**
-       * Run the computer-use agent loop until Claude stops requesting tools
-       * or the iteration limit is reached.
-       */
-      List<BetaMessageParam> samplingLoop(Model model, List<BetaMessageParam> messages, int maxIterations) {
-          for (int i = 0; i < maxIterations; i++) {
-              BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
-                      .model(model)
-                      .maxTokens(4096)
-                      .messages(messages)
-                      .addTool(COMPUTER_TOOL)
-                      .addBeta("computer-use-2025-11-24")
-                      .build());
-
-              // Add Claude's response to the conversation history
-              messages.add(BetaMessageParam.builder()
-                      .role(BetaMessageParam.Role.ASSISTANT)
-                      .contentOfBetaContentBlockParams(
-                              response.content().stream().map(BetaContentBlock::toParam).toList())
-                      .build());
-
-              // Run any tools Claude requested and collect results
-              List<BetaContentBlockParam> toolResults = processToolCalls(response);
-              if (toolResults.isEmpty()) {
-                  return messages; // No more tool use; task complete
-              }
-
-              // Send tool results back to Claude for the next iteration
-              messages.add(BetaMessageParam.builder()
-                      .role(BetaMessageParam.Role.USER)
-                      .contentOfBetaContentBlockParams(toolResults)
-                      .build());
-          }
-          return messages;
-      }
-      ```
-
-      ```php PHP
-      /**
-       * Run the computer-use agent loop until Claude stops requesting tools
-       * or the iteration limit is reached.
-       */
-      function samplingLoop(string $model, array $messages, int $maxIterations = 10): array
-      {
-          global $client, $tools;
-
-          for ($i = 0; $i < $maxIterations; $i++) {
-              $response = $client->beta->messages->create(
-                  model: $model,
-                  maxTokens: 4096,
-                  messages: $messages,
-                  tools: $tools,
-                  betas: ['computer-use-2025-11-24'],
-              );
-
-              // Add Claude's response to the conversation history
-              $messages[] = BetaMessageParam::with(role: Role::ASSISTANT, content: $response->content);
-
-              // Run any tools Claude requested and collect results
-              $toolResults = processToolCalls($response);
-              if ($toolResults === []) {
-                  return $messages; // No more tool use; task complete
-              }
-
-              // Send tool results back to Claude for the next iteration
-              $messages[] = BetaMessageParam::with(role: Role::USER, content: $toolResults);
-          }
-
-          return $messages;
-      }
-      ```
-
-      ```ruby Ruby
-      # Run the computer-use agent loop until Claude stops requesting tools
-      # or the iteration limit is reached.
-      def sampling_loop(model, messages, max_iterations: 10)
-        max_iterations.times do
-          response = CLIENT.beta.messages.create(
-            model: model,
-            max_tokens: 4096,
-            messages: messages,
-            tools: TOOLS,
-            betas: ["computer-use-2025-11-24"]
-          )
-
-          # Add Claude's response to the conversation history
-          messages << {role: "assistant", content: response.content}
-
-          # Run any tools Claude requested and collect results
-          tool_results = process_tool_calls(response)
-          return messages if tool_results.empty? # No more tool use; task complete
-
-          # Send tool results back to Claude for the next iteration
-          messages << {role: "user", content: tool_results}
-        end
-
-        messages
-      end
-      ```
-    </CodeGroup>
+    Wrap the two previous steps in a loop that sends the results back and repeats until Claude returns no member tool calls; [Understand the agent loop](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#understanding-the-agentic-loop) shows this loop in each language.
   </Step>
 </Steps>
 
-#### Handle errors
-
-When implementing the computer use tool, various errors might occur. Here's how to handle them:
-
-<AccordionGroup>
-  <Accordion title="Screenshot capture failure">
-    If screenshot capture fails, return an appropriate error message:
-
-    ```json
+### Handle errors
+
+Report a failed action to Claude as a `tool_result` with `is_error: true` and a short description, and include `"toolset_name": "computer"` as on any other member result. If the failed action was part of a [batch action](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions), answer the remaining blocks in the batch with the halt text shown there instead of running them.
+
+For example, when screenshot capture fails:
+
+```json
+{
+  "role": "user",
+  "content": [
     {
-      "role": "user",
-      "content": [
-        {
-          "type": "tool_result",
-          "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
-          "content": "Error: Failed to capture screenshot. Display may be locked or unavailable.",
-          "is_error": true
-        }
-      ]
+      "type": "tool_result",
+      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
+      "toolset_name": "computer",
+      "content": "Error: Failed to capture screenshot. Display may be locked or unavailable.",
+      "is_error": true
     }
-    ```
-  </Accordion>
-
-  <Accordion title="Invalid coordinates">
-    If Claude provides coordinates outside the display bounds:
-
-    ```json
-    {
-      "role": "user",
-      "content": [
-        {
-          "type": "tool_result",
-          "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
-          "content": "Error: Coordinates (1200, 900) are outside display bounds (1024x768).",
-          "is_error": true
-        }
-      ]
-    }
-    ```
-  </Accordion>
-
-  <Accordion title="Action execution failure">
-    If an action fails to run:
-
-    ```json
-    {
-      "role": "user",
-      "content": [
-        {
-          "type": "tool_result",
-          "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
-          "content": "Error: Failed to perform click action. The application may be unresponsive.",
-          "is_error": true
-        }
-      ]
-    }
-    ```
-  </Accordion>
-</AccordionGroup>
-
-#### Size screenshots to fit image limits
-
-Screenshots sent to the computer tool should fit within Claude's image size limits (see [image size limits](https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size)). The API downscales oversized images before Claude sees them, and Claude returns coordinates for the image it sees, so relying on the server-side downscale leaves you without the scale factor you need to map those coordinates back to your screen. Only images over the API's separate [request limits](https://platform.claude.com/docs/en/build-with-claude/vision#request-limits) (for example, more than 8,000 px on a side) are rejected with a validation error rather than downscaled.
+  ]
+}
+```
+
+Use the same shape for coordinates outside the display bounds and for actions that fail to run, with a message that says what went wrong.
+
+### Size screenshots to fit image limits
+
+Screenshots and zoom images that you return to the computer use toolset must already fit within your model's [image size limits](https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size): the toolset takes no display dimensions and the API doesn't downscale for you, so an oversized `tool_result` image is rejected with a validation error. Because Claude returns coordinates in the pixel space of the image it sees, keep the scale factor you used so you can map those coordinates back to your screen.
 
 <Note>
-  Limits vary by model. Claude Opus 5, Claude Sonnet 5, Claude Opus 4.8, and Claude Opus 4.7 accept up to 2576 pixels on the long edge; earlier models accept up to 1568 pixels on the long edge and approximately 1.15 megapixels total. The following example uses the earlier-model 1568 px / 1.15 MP limits; substitute your model's limit.
+  Limits vary by model. Claude Opus 4.7 and later models, including every model that supports `computer_toolset_20260801`, accept up to 2576 pixels on the long edge and 4784 visual tokens total (`⌈width / 28⌉ × ⌈height / 28⌉`, approximately 3.75 megapixels); earlier models accept up to 1568 pixels on the long edge and approximately 1.15 megapixels total (see [Resolution and token cost](https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size) for each model's tier). The following example uses the earlier-model 1568 px / 1.15 MP limits. For a high-resolution-tier model, size to the visual-token limit rather than a pixel total, for example with the resize helper in [Resize your image before uploading](https://platform.claude.com/docs/en/build-with-claude/vision-coordinates#resize-your-image-before-uploading).
 </Note>
 
-If your screen is larger than the limit, resize the screenshot before sending it, set `display_width_px`/`display_height_px` to the resized dimensions, and scale Claude's returned coordinates back to the original screen space:
-
-<CodeGroup>
-  ```bash cURL
-  # Coordinate scaling and screenshot resizing happen in your application code, not
-  # in the API request. See the SDK tabs for the helper pattern.
-  ```
-
-  ```bash CLI
-  # Coordinate scaling and screenshot resizing happen in your application code, not
-  # in the API request. See the SDK tabs for the helper pattern.
-  ```
-
+If your screen is larger than the limit, resize each screenshot before returning it and scale Claude's returned coordinates back to the original screen space. Because the toolset takes no display dimensions, the resize and the coordinate scaling in your application code are all you need:
+
+<CodeGroup exclude="shell">
   ```python Python
   import math
+
+  screen_width, screen_height = 1512, 982
 
 
   def get_scale_factor(width, height):

   ```
 
   ```typescript TypeScript
+  const screenWidth = 1512;
+  const screenHeight = 982;
   const MAX_LONG_EDGE = 1568;
   const MAX_PIXELS = 1_150_000;
 

   ```
 
   ```csharp C#
+  int screenWidth = 1512, screenHeight = 982;
+
   double GetScaleFactor(int width, int height)
   {
       // Calculate scale factor to meet API constraints.

   }
 
   // ...
+  	screenWidth, screenHeight := 1512, 982
+
   	// When capturing screenshot
   	scale := getScaleFactor(screenWidth, screenHeight)
   	scaledWidth := int(float64(screenWidth) * scale)

   }
 
   void main() {
-  // ...
+      int screenWidth = 1512, screenHeight = 982;
+
       // When capturing screenshot
       double scale = getScaleFactor(screenWidth, screenHeight);
       int scaledWidth = (int)(screenWidth * scale);

           sqrt(1_150_000 / ($width * $height)),
       );
   }
-  // ...
+
+  $screenWidth = 1512;
+  $screenHeight = 982;
+
   // When capturing screenshot
   $scale = getScaleFactor($screenWidth, $screenHeight);
   $scaledWidth = (int)($screenWidth * $scale);

   def get_scale_factor(width, height)
     [1.0, 1568.0 / [width, height].max, Math.sqrt(1_150_000.0 / (width * height))].min
   end
-  # ...
+
+  screen_width, screen_height = 1512, 982
+
   # When capturing screenshot
   scale = get_scale_factor(screen_width, screen_height)
   scaled_width = (screen_width * scale).to_i

   **macOS Retina displays** capture screenshots at a device pixel ratio of 2, so the image is twice the resolution of the logical screen coordinates. Either downscale the screenshot by 2x before sending, or halve the coordinates Claude returns before issuing the click.
 </Note>
 
-#### Diagnose click issues
+When you choose a display resolution and return screenshots:
+
+* For general desktop tasks, use 1024x768 or 1280x720; for web applications, use 1280x800 or 1366x768.
+* Avoid resolutions above 1920x1080 to prevent performance issues.
+* Encode screenshots as base64 PNG or JPEG, and consider compressing large screenshots to improve performance.
+* Include relevant metadata such as timestamp or display state.
+* If you use higher resolutions, ensure coordinates are accurately scaled.
+
+### Manage screenshot history
+
+Long agent loops accumulate screenshots quickly (roughly 1,000–1,800 input tokens each). The API's [request limits](https://platform.claude.com/docs/en/build-with-claude/vision#request-limits) also apply. Once a single request carries more than 20 images, every image in it is held to a stricter per-side limit. A loop that keeps its screenshot history reaches that count within a few dozen turns, so either resize each screenshot so that neither side exceeds 2000 px or prune older screenshots to keep 20 or fewer in the request.
+
+To keep [Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) effective while bounding context:
+
+* Place one `cache_control` breakpoint after the system prompt and tool definitions, and up to three more on the last `tool_result` block of each of the most recent turns, advancing them each turn. Within a [batch action](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions), markers on several blocks act as a single breakpoint but each still counts toward the limit of four, so use one per turn.
+* Prune old screenshots in *batches*, not one each turn. Dropping a screenshot every turn changes the prefix every turn and invalidates the cache. A reasonable default is to keep the last three screenshots and prune every 25 turns, so the prefix stays byte-identical between prune events; if your screenshots exceed 2000 px on either side, choose an interval that keeps each request at 20 or fewer images.
+
+### Diagnose click issues
 
 If clicks miss their targets, the cause is usually one of the following:
 
-| Symptom                                           | Likely cause                                                                                  | Try                                                                                                               |
-| ------------------------------------------------- | --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
-| Clicks consistently offset in one direction       | `display_width_px`/`display_height_px` don't match the image dimensions actually sent         | Ensure display dimensions exactly match the screenshot you send                                                   |
-| Clicks land in the right area but miss the target | Target is very small, detail was lost downscaling a 4K+ source, or aspect ratio was distorted | Set `enable_zoom: true`; capture at lower DPI or crop to the relevant region; preserve aspect ratio when resizing |
-| Claude clicks the wrong element entirely          | Ambiguous instruction, or visually similar elements nearby                                    | Use positional prompts ("the blue Submit button in the bottom-right"); break the interaction into smaller steps   |
-| Accuracy is consistently poor                     | Resolution too low                                                                            | Try 1280x720 as a baseline                                                                                        |
+| Symptom                                           | Likely cause                                                                                                                                         | Try                                                                                                                                                                                                                                                                                                                                            |
+| ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Clicks consistently offset in one direction       | Claude's coordinates, which are in the pixel space of the screenshots you return, are being applied to a display of a different size without scaling | Scale each coordinate by the ratio of your screen size to your screenshot size before clicking (see [Size screenshots to fit image limits](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)); on macOS Retina displays, account for the 2x device pixel ratio |
+| Clicks land in the right area but miss the target | Target is very small, detail was lost downscaling a 4K+ source, or aspect ratio was distorted                                                        | Keep the `zoom` member enabled and implement it so Claude can inspect the region at full resolution; capture at lower DPI or crop to the relevant region; preserve aspect ratio when resizing                                                                                                                                                  |
+| Claude clicks the wrong element entirely          | Ambiguous instruction, or visually similar elements nearby                                                                                           | Use positional prompts ("the blue Submit button in the bottom-right"); break the interaction into smaller steps                                                                                                                                                                                                                                |
+| Accuracy is consistently poor                     | Resolution too low                                                                                                                                   | Try 1280x720 as a baseline                                                                                                                                                                                                                                                                                                                     |
 
 <Tip>
-  **Model choice affects click precision.** Claude Sonnet 4.6 is more mechanically precise at clicking than Claude Opus 4.6 and is more robust when screenshots require heavy downscaling. Claude Opus 4.7 narrows that gap: its click precision is roughly comparable to Sonnet 4.6, and its higher resolution limit means less downscaling is needed.
+  **Model choice affects click precision.** Among the models that use the earlier `computer_20251124` tool, Claude Sonnet 4.6 is more mechanically precise at clicking than Claude Opus 4.6 and is more robust when screenshots require heavy downscaling. Claude Opus 4.7 narrows that gap: its click precision is roughly comparable to Sonnet 4.6, and its higher resolution limit means less downscaling is needed.
 </Tip>
 
-#### Follow implementation best practices
+### Follow implementation best practices
 
 <AccordionGroup>
-  <Accordion title="Use appropriate display resolution">
-    Set display dimensions that match your use case while staying within recommended limits:
-
-    * For general desktop tasks: 1024x768 or 1280x720
-    * For web applications: 1280x800 or 1366x768
-    * Avoid resolutions above 1920x1080 to prevent performance issues
-  </Accordion>
-
-  <Accordion title="Implement proper screenshot handling">
-    When returning screenshots to Claude:
-
-    * Encode screenshots as base64 PNG or JPEG
-    * Consider compressing large screenshots to improve performance
-    * Include relevant metadata such as timestamp or display state
-    * If using higher resolutions, ensure coordinates are accurately scaled
-
-    A screenshot goes back as an image content block inside the `tool_result` content array (see [Handle tool calls](https://platform.claude.com/docs/en/agents-and-tools/tool-use/handle-tool-calls)):
-
-    ```json
-    {
-      "role": "user",
-      "content": [
-        {
-          "type": "tool_result",
-          "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
-          "content": [
-            {
-              "type": "image",
-              "source": {
-                "type": "base64",
-                "media_type": "image/png",
-                "data": "iVBORw0KGgo..."
-              }
-            }
-          ]
-        }
-      ]
-    }
-    ```
-  </Accordion>
-
-  <Accordion title="Manage screenshot history for prompt caching">
-    Long agent loops accumulate screenshots quickly (roughly 1,000–1,800 input tokens each). To keep [Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) effective while bounding context:
-
-    * Place one `cache_control` breakpoint after the system prompt and tool definitions, and up to three more on the most recent `tool_result` blocks, advancing them each turn.
-    * Prune old screenshots in *batches*, not one each turn. Dropping a screenshot every turn changes the prefix every turn and invalidates the cache. A reasonable default is to keep the last three screenshots and prune every 25 turns, so the prefix stays byte-identical between prune events.
-  </Accordion>
-
   <Accordion title="Add action delays">
     Some applications need time to respond to actions:
 
-    <CodeGroup>
-      ```bash cURL
-      # This is application-side helper code with no API request. See the SDK tabs for
-      # the pattern.
-      ```
-
-      ```bash CLI
-      # This is application-side helper code with no API request. See the SDK tabs for
-      # the pattern.
-      ```
-
+    <CodeGroup exclude="shell">
       ```python Python
       def click_and_wait(x, y, wait_time=0.5):
           click_at(x, y)

   <Accordion title="Validate actions before running them">
     Check that requested actions are safe and valid:
 
-    <CodeGroup>
-      ```bash cURL
-      # This is application-side helper code with no API request. See the SDK tabs for
-      # the pattern.
-      ```
-
-      ```bash CLI
-      # This is application-side helper code with no API request. See the SDK tabs for
-      # the pattern.
-      ```
-
+    <CodeGroup exclude="shell">
       ```python Python
+      display_width, display_height = 1024, 768
+
+
       def validate_action(action_type, params):
-          if action_type == "left_click":
-              x, y = params.get("coordinate", (0, 0))
+          if action_type == "left_click" and "coordinate" in params:
+              x, y = params["coordinate"]
               if not (0 <= x < display_width and 0 <= y < display_height):
                   return False, "Coordinates out of bounds"
           return True, None
       ```
 
       ```typescript TypeScript
+      const displayWidth = 1024;
+      const displayHeight = 768;
+
       interface ActionParams {
         coordinate?: [number, number];
       }
 
       function validateAction(actionType: string, params: ActionParams): [boolean, string | null] {
-        if (actionType === "left_click") {
-          const [x, y] = params.coordinate ?? [0, 0];
+        if (actionType === "left_click" && params.coordinate) {
+          const [x, y] = params.coordinate;
           if (!(x >= 0 && x < displayWidth && y >= 0 && y < displayHeight)) {
             return [false, "Coordinates out of bounds"];
           }

       // ...
       static (bool IsValid, string? Error) ValidateAction(string actionType, IReadOnlyDictionary<string, JsonElement> parameters)
       {
-          if (actionType == "left_click")
+          if (actionType == "left_click" && parameters.TryGetValue("coordinate", out JsonElement coordinate))
           {
-              int x = parameters["coordinate"][0].GetInt32();
-              int y = parameters["coordinate"][1].GetInt32();
+              int x = coordinate[0].GetInt32();
+              int y = coordinate[1].GetInt32();
               if (x is < 0 or >= DisplayWidth || y is < 0 or >= DisplayHeight)
               {
                   return (false, "Coordinates out of bounds");

       )
 
       func validateAction(actionType string, params map[string]any) (bool, string) {
-      	if actionType == "left_click" {
-      		coord, ok := params["coordinate"].([]any)
+      	raw, hasCoordinate := params["coordinate"]
+      	if actionType == "left_click" && hasCoordinate {
+      		coord, ok := raw.([]any)
       		if !ok || len(coord) != 2 {
       			return false, "Invalid coordinate"
       		}

       record Validation(boolean valid, String error) {}
 
       Validation validateAction(String actionType, Map<String, JsonValue> params) {
-          if (actionType.equals("left_click")) {
+          if (actionType.equals("left_click") && params.containsKey("coordinate")) {
               List<JsonValue> coord = (List<JsonValue>) params.get("coordinate").asArray().get();
               long x = ((Number) coord.get(0).asNumber().get()).longValue();
               long y = ((Number) coord.get(1).asNumber().get()).longValue();

       /** @return array{bool, ?string} */
       function validateAction(string $actionType, array $params): array
       {
-          if ($actionType === 'left_click') {
-              [$x, $y] = $params['coordinate'] ?? [0, 0];
+          if ($actionType === 'left_click' && isset($params['coordinate'])) {
+              [$x, $y] = $params['coordinate'];
               if (!(0 <= $x && $x < DISPLAY_WIDTH && 0 <= $y && $y < DISPLAY_HEIGHT)) {
                   return [false, 'Coordinates out of bounds'];
               }

       DISPLAY_HEIGHT = 768
 
       def validate_action(action_type, params)
-        if action_type == "left_click"
-          x, y = params.fetch(:coordinate, [0, 0])
+        if action_type == "left_click" && params.key?(:coordinate)
+          x, y = params[:coordinate]
           unless (0...DISPLAY_WIDTH).cover?(x) && (0...DISPLAY_HEIGHT).cover?(y)
             return [false, "Coordinates out of bounds"]
           end

   <Accordion title="Log actions for debugging">
     Keep a log of all actions for troubleshooting:
 
-    <CodeGroup>
-      ```bash cURL
-      # This is application-side helper code with no API request. See the SDK tabs for
-      # the pattern.
-      ```
-
-      ```bash CLI
-      # This is application-side helper code with no API request. See the SDK tabs for
-      # the pattern.
-      ```
-
+    <CodeGroup exclude="shell">
       ```python Python
       import logging
 

 
 ***
 
-## Understand computer use limitations
-
-Computer use is in beta. Keep the following limitations in mind:
+## Migrate from `computer_20251124`
+
+Upgrading from `computer_20251124` to the toolset is optional: the models listed for `computer_20251124` under [Earlier tool versions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) keep accepting it with its beta header, so an existing integration keeps working until you change it. To upgrade, make the following changes together:
+
+1. **Remove the beta header.** Drop `anthropic-beta: computer-use-2025-11-24` from your requests. In the SDKs, remove the `betas` parameter and call the Messages API through the standard client rather than the beta namespace.
+2. **Change the `tools` entry.** Set `type` to `computer_toolset_20260801` and delete `name`, `display_width_px`, `display_height_px`, `display_number`, and `enable_zoom`. The toolset rejects each of these fields.
+3. **Choose whether to keep zoom enabled.** Zoom is enabled by default on the toolset, whereas `enable_zoom` defaults to `false`. If your environment doesn't implement zoom, add `"configs": {"zoom": {"enabled": false}}` to keep the previous behavior; otherwise implement it (see [Available actions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#available-actions)).
+4. **Handle every block in a turn.** Update your agent loop to iterate over every `tool_use` block in a response rather than reading only the first, and to dispatch on the block's `name` together with `toolset_name` instead of on `input.action`. Member inputs no longer contain an `action` field; the remaining fields are unchanged.
+5. **Run blocks in order and use the halt text.** Run the blocks sequentially, stop at the first failure, and answer the remaining blocks with `Not executed: an earlier computer action in this turn failed.` as described in [Batch actions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions). If your loop can't run batches yet, [Tool parameters](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#tool-parameters) explains how to limit Claude to one action per turn.
+6. **Echo `toolset_name` on results.** Add `"toolset_name": "computer"` to every `tool_result` that answers a member call. Results may contain only `text` and `image` content.
+7. **Support `repeat` on `key`.** The `key` member accepts an optional `repeat` count from 1 to 100. A handler that ignores unrecognized fields would press the key once, so make your `key` handler honor `repeat`.
+8. **Resize screenshots yourself.** The toolset rejects a screenshot or zoom image that exceeds the model's image limits instead of downscaling it. Resize before returning the image and keep scaling coordinates as described in [Size screenshots to fit image limits](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions).
+9. **Remove unsupported options.** Move any `defer_loading` from the entry into `configs`, with the same value on every enabled member. The other options not supported on toolset entries are listed under [Client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets).
+
+This is the `tools` entry before the change, sent with the `anthropic-beta: computer-use-2025-11-24` header:
+
+```json
+{
+  "type": "computer_20251124",
+  "name": "computer",
+  "display_width_px": 1024,
+  "display_height_px": 768,
+  "display_number": 1
+}
+```
+
+This is the `tools` entry after the change, sent with no beta header. The `configs` object keeps zoom off to match the earlier entry, which doesn't set `enable_zoom`; omit `configs` entirely to accept the default and let Claude zoom:
+
+```json
+{
+  "type": "computer_toolset_20260801",
+  "configs": {
+    "zoom": { "enabled": false }
+  }
+}
+```
+
+The following pair shows a `tool_use` block before and after the change. The action name moves from `input.action` to `name`, and the block gains `toolset_name`:
+
+```json
+{
+  "type": "tool_use",
+  "id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
+  "name": "computer",
+  "input": { "action": "left_click", "coordinate": [500, 300] }
+}
+```
+
+```json
+{
+  "type": "tool_use",
+  "id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
+  "name": "left_click",
+  "toolset_name": "computer",
+  "input": { "coordinate": [500, 300] }
+}
+```
+
+## Earlier tool versions
+
+Two earlier versions of the computer use tool remain available in beta for existing integrations, for models that don't support the toolset, and on platforms where the toolset isn't currently available. Each requires its [beta header](https://platform.claude.com/docs/en/api/beta-headers) on every request, and their parameters are documented in the [beta Messages API reference](https://platform.claude.com/docs/en/api/beta/messages/create). In the SDKs, pass the header through the `betas` parameter and use the beta namespace; only the computer use tool needs the header, not the bash or text editor tools in the same request.
+
+| Tool version        | Beta header               | Use with                                                                                                                                                                                                                                                                                                                                                                                                                                    | Parameters                                                                    |
+| ------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| `computer_20251124` | `computer-use-2025-11-24` | Claude Fable 5, Claude Mythos 5, Claude Opus 5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6, and Claude Opus 4.5                                                                                                                                                                                                                                                                                  | [API reference](https://platform.claude.com/docs/en/api/beta/messages/create) |
+| `computer_20250124` | `computer-use-2025-01-24` | Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.1 ([retired, except on Bedrock and Google Cloud](https://platform.claude.com/docs/en/about-claude/model-deprecations)), Claude Sonnet 4 ([retired, except on Bedrock and Google Cloud](https://platform.claude.com/docs/en/about-claude/model-deprecations)), and Claude Opus 4 ([retired, except on Google Cloud](https://platform.claude.com/docs/en/about-claude/model-deprecations)) | [API reference](https://platform.claude.com/docs/en/api/beta/messages/create) |
+
+***
+
+## Limitations
 
 1. **Latency:** The current computer use latency for human-AI interactions might be too slow compared to regular human-directed computer actions. Focus on use cases where speed isn't critical (for example, background information gathering, automated software testing) in trusted environments.
-
-2. **Computer vision accuracy and reliability:** Claude might make mistakes or hallucinate when outputting specific coordinates while generating actions. Extended thinking can help you understand the model's reasoning and identify potential issues.
-
+2. **Computer vision accuracy and reliability:** Claude might make mistakes or hallucinate when outputting specific coordinates while generating actions. Claude's [summarized thinking](https://platform.claude.com/docs/en/build-with-claude/thinking#summarized-thinking) output can help you understand the model's reasoning and identify potential issues; set `display: "summarized"` on the thinking configuration, because the models that support the toolset omit thinking text by default.
 3. **Tool selection accuracy and reliability:** Claude might make mistakes or hallucinate when selecting tools while generating actions or take unexpected actions to solve problems. Additionally, reliability might be lower when interacting with niche applications or multiple applications at once. Prompt the model carefully when requesting complex tasks.
-
 4. **Scrolling reliability:** The scroll action supports direction control (up, down, left, right) and a specified amount. In applications where scrolling doesn't take effect, keyboard alternatives such as Page Down can help.
-
 5. **Spreadsheet interaction:** Use the fine-grained mouse control actions (`left_mouse_down`, `left_mouse_up`) and modifier-key combinations to select individual cells. Complex spreadsheet operations might still require multiple attempts.
-
-6. **Account creation and content generation on social and communications platforms:** While Claude will visit websites, Claude's ability to create accounts or generate and share content or otherwise engage in human impersonation across social media websites and platforms is limited. This capability might be updated in the future.
-
-7. **Vulnerabilities:** Vulnerabilities such as jailbreaking or prompt injection might persist across frontier AI systems, including the beta computer use API. In some circumstances, Claude will follow commands found in content, sometimes even when they conflict with your instructions. For example, instructions on webpages or contained in images might override your instructions or cause Claude to make mistakes. Consider the following:
-
-   * Limiting computer use to trusted environments such as virtual machines or containers with minimal privileges
-   * Avoiding giving computer use access to sensitive accounts or data without strict oversight
-   * Informing end users of relevant risks and obtaining their consent before enabling or requesting permissions necessary for computer use features in your applications
-
+6. **Account creation and content generation on social and communications platforms:** Although Claude visits websites, its ability to create accounts, generate and share content, or otherwise engage in human impersonation across social media websites and platforms is limited.
+7. **Vulnerabilities:** Jailbreaks and prompt injection can affect computer use as they can any frontier AI system, including through instructions embedded in webpages or images; apply the precautions in [Security considerations](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#security-considerations).
 8. **Inappropriate or illegal actions:** Under Anthropic's Terms of Service, you must not employ computer use to violate any laws or the Acceptable Use Policy.
 
 Always carefully review and verify Claude's computer use actions and logs. Do not use Claude for tasks requiring perfect precision or sensitive user information without human oversight.

 
 Computer use follows the standard [tool use pricing](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview#pricing). When using the computer use tool:
 
-**System prompt overhead:** The computer use beta adds 466–499 tokens to the system prompt
-
-**Computer use tool token usage:**
-
-| Model             | Input tokens per tool definition |
-| ----------------- | -------------------------------- |
-| Claude 4.x models | 735 tokens                       |
+**Toolset definition overhead:** Declaring `computer_toolset_20260801` with its default members adds about 4,500 input tokens to a request (about 4,520 on Claude Fable 5, Claude Mythos 5, Claude Opus 5, and Claude Opus 4.8, and about 4,590 on Claude Sonnet 5), which covers the member tool definitions and the tool use system prompt. Disabling `zoom` with `configs` removes about 410 of those tokens. The exact count for a request is reported in the response `usage`, and you can estimate it in advance with the [token counting endpoint](https://platform.claude.com/docs/en/build-with-claude/token-counting).
+
+**Earlier tool versions:** The following figures apply to the `computer_20251124` and `computer_20250124` tool versions, not to `computer_toolset_20260801`:
+
+* System prompt overhead: 466–499 tokens added to the system prompt
+* Tool definition: about 735 input tokens per tool definition (measured with `computer_20250124`)
 
 **Additional token consumption:**
 
-* Screenshot images (see [Vision pricing](https://platform.claude.com/docs/en/build-with-claude/vision))
+* Screenshot and zoom images returned in tool results, billed as image input (see [Vision pricing](https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size))
 * Tool execution results returned to Claude
 
 <Note>

   <Card title="Best practices in detail" icon="book" href="https://claude.com/blog/best-practices-for-computer-and-browser-use-with-claude">
     Benchmarked recommendations for resolution, thinking effort, and context management
   </Card>
+
+  <Card title="Browser use tool" icon="browser" href="https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool">
+    Let Claude navigate, read, and interact with webpages in your own browser environment, for tasks that stay inside the browser.
+  </Card>
 </CardGroup>
 

 
 ## Specifying client tools
 
-Client tools (both Anthropic-schema and user-defined) are specified in the `tools` top-level parameter of the API request. Each tool definition includes:
+Client tools are specified in the `tools` top-level parameter of the API request. Anthropic-schema client tools, such as the bash and text editor tools, are declared by a date-versioned `type`; see each tool's page, linked from the [Tool reference](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference), for the fields it accepts. The computer use and browser use tools are [client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets): a single entry with no `name` that declares a fixed set of member tools. A user-defined tool definition includes:
 
 | Parameter        | Description                                                                                                                                                                                                                            |
 | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

 | `input_schema`   | A [JSON Schema](https://json-schema.org/) object defining the expected parameters for the tool.                                                                                                                                        |
 | `input_examples` | (Optional) An array of example input objects to help Claude understand how to use the tool. See [Providing tool use examples](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools#providing-tool-use-examples). |
 
-For the full set of optional properties available on any tool definition, including `cache_control`, `strict`, `defer_loading`, and `allowed_callers`, see the [Tool reference](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#tool-definition-properties).
+For the full set of optional properties available on any single tool definition, including `cache_control`, `strict`, `defer_loading`, and `allowed_callers`, see the [Tool reference](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#tool-definition-properties). A client toolset entry accepts `cache_control` and `allowed_callers` on the entry and sets `defer_loading` per member; see [Client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets).
 
 <Accordion title="Example simple tool definition">
   ```json JSON

 ### Requirements and limitations
 
 * **Schema validation** - Each example must be valid according to the tool's `input_schema`. Invalid examples return a 400 error
-* **Not supported for server-side tools** - Input examples work on user-defined and Anthropic-schema client tools, but not on server tools such as web search or code execution
+* **Not supported for server-side tools or client toolsets** - Input examples work on user-defined and Anthropic-schema client tools other than the [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) and [browser use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) toolsets, but not on server tools such as web search or code execution
 * **Token cost** - Examples add to prompt tokens: \~20–50 tokens for simple examples, \~100–200 tokens for complex nested objects
 
 ## Controlling Claude's output

 
 ### Anthropic-schema tools (client-executed)
 
-For a handful of common operations (managing scratchpad memory, running shell commands, editing files, controlling a browser), Anthropic publishes the tool schema and your application handles execution. The tools in this category are [`memory`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool), [`bash`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool), [`text_editor`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool), and [`computer`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool).
+For a handful of common operations (managing scratchpad memory, running shell commands, editing files, controlling a desktop or a browser), Anthropic publishes the tool schema and your application handles execution. The tools in this category are [`memory`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool), [`bash`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool), [`text_editor`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool), [`computer`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool), and [`browser`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool).
 
 The execution model is identical to user-defined tools: the response contains a `tool_use` block, your code runs the operation, and you send back a `tool_result`. The reason to use an Anthropic-schema tool instead of defining your own equivalent is that these schemas are trained-in. Claude has been optimized on thousands of successful trajectories that use these exact tool signatures, so it calls them more reliably and recovers from errors more gracefully than it would with a custom tool that does the same thing. The schema is the interface the model already expects.
 

 
 ## Choosing between approaches
 
-| Approach                      | When to use it                                                | What to expect                                                                        | Learn more                                                                                     |
-| ----------------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
-| User-defined client tools     | Custom business logic, internal APIs, proprietary data        | You handle execution and the agentic loop                                             | [Define tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools)     |
-| Anthropic-schema client tools | Standard dev operations (bash, file editing, browser control) | You handle execution; Claude calls the tool reliably because the schema is trained-in | [Tool reference](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference) |
-| Server-executed tools         | Web search, code sandbox, web fetch                           | Anthropic handles execution; you read the results instead of producing them           | [Server tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/server-tools)     |
+| Approach                      | When to use it                                                            | What to expect                                                                        | Learn more                                                                                     |
+| ----------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| User-defined client tools     | Custom business logic, internal APIs, proprietary data                    | You handle execution and the agentic loop                                             | [Define tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools)     |
+| Anthropic-schema client tools | Standard dev operations (bash, file editing, desktop and browser control) | You handle execution; Claude calls the tool reliably because the schema is trained-in | [Tool reference](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference) |
+| Server-executed tools         | Web search, code sandbox, web fetch                                       | Anthropic handles execution; you read the results instead of producing them           | [Server tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/server-tools)     |
 
 ## Next steps
 

   <Card title="Computer use tool" icon="computer" href="https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool">
     Take screenshots and control the mouse and keyboard in a desktop environment.
   </Card>
+
+  <Card title="Browser use tool" icon="browser" href="https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool">
+    Navigate, read, and interact with webpages in your own browser environment.
+  </Card>
 </CardGroup>
 
 ### Server tools

 Server tools run on Anthropic's infrastructure, with no handler code in your application. See [Server tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/server-tools) for the mechanics they share.
 
 <CardGroup cols={2}>
-  <Card title="Web search tool" icon="browser" href="https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool">
+  <Card title="Web search tool" icon="magnifying-glass" href="https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool">
     Search the web for information beyond the knowledge cutoff, with cited sources.
   </Card>
 

 
 This pairing is useful when the answer lives in long-form content (documentation pages, articles, specifications) that a search snippet can't fully capture. Fetch pulls the complete page so Claude can cite specific passages.
 
-## Long-running agent: memory + any toolset
+## Long-running agent: memory + any other tools
 
 Memory persists state across conversations; the other tools do the work. Add memory to any agent that needs to remember prior sessions, such as a support agent that recalls a customer's earlier issues or a project assistant that tracks decisions made last week.
 

 
 Add your other tools alongside `memory` in the same array.
 
-Memory is orthogonal to the rest of your toolset. It doesn't change how other tools behave; it gives Claude a place to write down and later retrieve facts that would otherwise be lost when the context window resets. See [Memory tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool) for the storage model.
+Memory is orthogonal to your other tools. It doesn't change how they behave; it gives Claude a place to write down and later retrieve facts that would otherwise be lost when the context window resets. See [Memory tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool) for the storage model.
 
 ## All-in-one: computer\_use
 

 
 ```json
 {
-  "tools": [
-    {
-      "type": "computer_20250124",
-      "name": "computer",
-      "display_width_px": 1280,
-      "display_height_px": 800
-    }
-  ]
+  "tools": [{ "type": "computer_toolset_20260801" }]
 }
 ```
 
-Computer use is the most general option and also the slowest, because every action requires a screenshot roundtrip. Prefer narrower tools when they cover your use case, and reach for computer use when nothing else fits. See [Computer use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) for the sandbox setup.
+The toolset entry takes no `name` or display dimensions: coordinates are expressed in the pixel space of the screenshots you return, and you can turn individual actions off through the entry's `configs` field.
+
+Computer use is the most general option and also the slowest, because Claude typically needs a fresh screenshot after each batch of actions. Prefer narrower tools when they cover your use case, and reach for computer use when nothing else fits. If the task stays inside a web browser, use the browser agent pattern in the next section. See [Computer use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) for the sandbox setup.
+
+## Browser agent: browser\_use
+
+When the whole task happens inside webpages (filling forms, reading page content, working across tabs), the browser use tool is a closer fit than computer use. Your application drives a browser it controls and returns screenshots or page state; Claude calls page-aware member tools such as `read_page`, `find`, `form_input`, and `get_page_text` alongside clicks and typing, so it can act on element references in addition to pixel coordinates.
+
+```json
+{
+  "tools": [{ "type": "browser_toolset_20260801" }]
+}
+```
+
+Like the computer use toolset, the entry takes no `name`, and you turn individual member tools off through its `configs` field. See [Browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) for the execution contract.
 
 ## Next steps
 

 ---
 title: Tool reference
 url: https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference
-description: Directory of Anthropic-provided tools and reference for optional tool definition properties.
+description: Directory of Anthropic-provided server tools, client tools, and client toolsets, plus reference for optional tool definition properties.
 ---
 
 This page is a reference for the tools Anthropic provides and the optional properties you can set on any tool definition. For a conceptual introduction to tool use, see [Tool use with Claude](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview). For guidance on implementing tool use in your application, see [Define tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools).

 
 Anthropic provides two kinds of tools: **server tools** that execute on Anthropic's infrastructure, and **client tools** where Anthropic defines the schema but your application handles execution. Both kinds appear in your request's `tools` array alongside any user-defined tools.
 
-| Tool                                                                                                     | `type`                                                                              | Execution | Status                                                    |
-| -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | --------- | --------------------------------------------------------- |
-| [Web search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool)         | `web_search_20260318` `web_search_20260209` `web_search_20250305`                   | Server    | GA                                                        |
-| [Web fetch tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool)           | `web_fetch_20260318` `web_fetch_20260309` `web_fetch_20260209` `web_fetch_20250910` | Server    | GA                                                        |
-| [Code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) | `code_execution_20260521` `code_execution_20260120` `code_execution_20250825`       | Server    | GA                                                        |
-| [Advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool)               | `advisor_20260301`                                                                  | Server    | Beta: `advisor-tool-2026-03-01`                           |
-| [Tool search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool)       | `tool_search_tool_regex_20251119` `tool_search_tool_bm25_20251119`                  | Server    | GA                                                        |
-| [MCP connector](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector)                      | `mcp_toolset`                                                                       | Server    | Beta: `mcp-client-2025-11-20`                             |
-| [Memory tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool)                 | `memory_20250818`                                                                   | Client    | GA                                                        |
-| [Bash tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool)                     | `bash_20250124`                                                                     | Client    | GA                                                        |
-| [Text editor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool)       | `text_editor_20250728` `text_editor_20250124`                                       | Client    | GA                                                        |
-| [Computer use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool)     | `computer_20251124` `computer_20250124`                                             | Client    | Beta: `computer-use-2025-11-24` `computer-use-2025-01-24` |
+| Tool                                                                                                     | `type`                                                                              | Execution | Status                                                             |
+| -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------ |
+| [Web search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool)         | `web_search_20260318` `web_search_20260209` `web_search_20250305`                   | Server    | GA                                                                 |
+| [Web fetch tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool)           | `web_fetch_20260318` `web_fetch_20260309` `web_fetch_20260209` `web_fetch_20250910` | Server    | GA                                                                 |
+| [Code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) | `code_execution_20260521` `code_execution_20260120` `code_execution_20250825`       | Server    | GA                                                                 |
+| [Advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool)               | `advisor_20260301`                                                                  | Server    | Beta: `advisor-tool-2026-03-01`                                    |
+| [Tool search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool)       | `tool_search_tool_regex_20251119` `tool_search_tool_bm25_20251119`                  | Server    | GA                                                                 |
+| [MCP connector](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector)                      | `mcp_toolset`                                                                       | Server    | Beta: `mcp-client-2025-11-20`                                      |
+| [Memory tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool)                 | `memory_20250818`                                                                   | Client    | GA                                                                 |
+| [Bash tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool)                     | `bash_20250124`                                                                     | Client    | GA                                                                 |
+| [Text editor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool)       | `text_editor_20250728` `text_editor_20250124`                                       | Client    | GA                                                                 |
+| [Computer use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool)     | `computer_toolset_20260801` `computer_20251124` `computer_20250124`                 | Client    | GA Beta: `computer-use-2025-11-24` Beta: `computer-use-2025-01-24` |
+| [Browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool)       | `browser_toolset_20260801`                                                          | Client    | GA                                                                 |
 
 For model compatibility, see each tool's page. Supported models vary by tool and by tool version.
 

 * **Model-keyed:** `text_editor_20250728` is for Claude 4 and later models and `text_editor_20250124` is for earlier models. The version you use depends on the model you target.
 * **Variant, not version:** `tool_search_tool_regex_20251119` and `tool_search_tool_bm25_20251119` are two search algorithms released together. Neither supersedes the other.
 * **Legacy:** `code_execution_20250522` supports only Python. `code_execution_20250825` adds Bash and file operations.
+* **Successor:** `computer_toolset_20260801` is the generally available successor to the beta `computer_20251124` and `computer_20250124` versions, which remain available for existing integrations and for models that don't support the toolset ([Earlier tool versions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions)). `browser_toolset_20260801` is the first version of the browser use tool. Both are [client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets).
 
 The `mcp_toolset` type is not date-versioned; versioning is carried in the `anthropic-beta` header instead.
 
+### Client toolsets
+
+The [computer use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) and [browser use tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) are Anthropic-defined client toolsets: one entry in `tools` declares a fixed set of member tools whose names, descriptions, and input schemas Anthropic defines, and your application executes every call. The entry takes no `name`, because the dated `type` fixes the member names. `configs`, `cache_control`, and `allowed_callers` (which accepts only `["direct"]`) are optional.
+
+Client toolsets are Messages API tools. They aren't currently available as agent tools in [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/tools), which provides its own built-in agent toolset, MCP toolsets, and custom tools.
+
+```json
+{
+  "type": "browser_toolset_20260801",
+  "configs": {
+    "javascript_exec": { "enabled": true }
+  },
+  "cache_control": { "type": "ephemeral" }
+}
+```
+
+`configs` adjusts individual members:
+
+* Keys are member names, and each value accepts only `enabled` and `defer_loading`.
+* A member you omit keeps its defaults. An absent value, `{}`, and a restated default are equivalent.
+* An unknown member name or any other field in a member's value is rejected, as is a `configs` that disables every member (omit the entry instead).
+* A disabled member is removed from the tools Claude sees. If Claude still names it, return an error `tool_result`.
+
+Set `defer_loading` per member, never on the entry, and give every enabled member the same value: under [tool search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool#deferred-tool-loading) the toolset loads and expands as one definition. When every enabled member defers, only a [tool search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool) that isn't itself deferred can surface the toolset, so declare one in the same request. Don't put `cache_control` on a toolset entry whose members defer; set the breakpoint on a non-deferred tool instead, because deferred definitions are not part of the cached prefix.
+
+`cache_control` goes on the entry only; for where the breakpoint lands, including markers inside a batch action, see [Tool use with prompt caching](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-use-with-prompt-caching#cache-control-on-tool-definitions).
+
+**Handle member tool calls.** Claude calls a member with a `tool_use` block whose `name` is the member name and whose `toolset_name` is `computer` or `browser`; `input` holds that member's parameters and no `action` field. Dispatch on the `toolset_name` and `name` pair, because a custom tool may share a member's name and the two toolsets share names such as `screenshot`. Only member results echo `toolset_name`. Several member calls in one turn form a batch action that you run in order ([computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions), [browser use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool#batch-actions)). New members arrive only with a new dated `type`.
+
+**Not supported on toolset entries.** The API rejects each of these with an `invalid_request_error`:
+
+* `strict: true` or `input_examples`.
+* `defer_loading` on the entry, or enabled members whose `defer_loading` values differ (set it per member in `configs`, all to the same value).
+* A code execution caller in `allowed_callers` (no [programmatic tool calling](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling)).
+* The legacy `fine-grained-tool-streaming-2025-05-14` beta header. When you stream, each member's `input` arrives as one complete `input_json_delta`.
+* A `tool_choice` of type `tool` that names the toolset or a member (use `auto`, `any`, or `none`).
+* Two entries of the same toolset, or another tool that carries that toolset's name: a tool named `computer` alongside `computer_toolset_20260801`, or a tool named `browser` alongside `browser_toolset_20260801`. The two toolsets can be declared together.
+
 ## Tool definition properties
 
 Every tool in the `tools` array, including user-defined tools, accepts optional properties that control how the tool is loaded, who can call it, and how its inputs are validated. These properties compose: you can set `defer_loading` and `cache_control` and `strict` on the same tool.
 
-| Property                | Purpose                                                                                                               | Available on                                                                                                                                          | Detailed guide                                                                                                                                 |
-| ----------------------- | --------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| `cache_control`         | Set a prompt-cache breakpoint at this tool definition                                                                 | All tools                                                                                                                                             | [Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)                                                         |
-| `strict`                | Guarantee schema validation on tool names and inputs                                                                  | All tools except `mcp_toolset`                                                                                                                        | [Strict tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/strict-tool-use)                                               |
-| `defer_loading`         | Exclude the tool from the initial system prompt; load it on demand when tool search returns a `tool_reference` for it | All tools (for `mcp_toolset`, see [tool configuration](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector#mcp-toolset-configuration)) | [Tool search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool)                                             |
-| `allowed_callers`       | Restrict which callers can call the tool                                                                              | All tools except `mcp_toolset`                                                                                                                        | [Programmatic tool calling](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling#the-allowed-callers-field) |
-| `input_examples`        | Provide example input objects to help Claude understand how to call the tool                                          | User-defined and Anthropic-schema client tools. Not available on server tools.                                                                        | [Define tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools#providing-tool-use-examples)                         |
-| `eager_input_streaming` | Enable fine-grained input streaming (`true`) or keep standard buffered streaming (`false`) for this tool              | User-defined tools only                                                                                                                               | [Fine-grained tool streaming](https://platform.claude.com/docs/en/agents-and-tools/tool-use/fine-grained-tool-streaming)                       |
+| Property                | Purpose                                                                                                               | Available on                                                                                                                                                                                                                                                                                                                                                  | Detailed guide                                                                                                                                 |
+| ----------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cache_control`         | Set a prompt-cache breakpoint at this tool definition                                                                 | All tools (on `computer_toolset_20260801` and `browser_toolset_20260801`, set it on the toolset entry itself, not inside member `configs`)                                                                                                                                                                                                                    | [Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)                                                         |
+| `strict`                | Guarantee schema validation on tool names and inputs                                                                  | All tools except `mcp_toolset`, `computer_toolset_20260801`, and `browser_toolset_20260801`                                                                                                                                                                                                                                                                   | [Strict tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/strict-tool-use)                                               |
+| `defer_loading`         | Exclude the tool from the initial system prompt; load it on demand when tool search returns a `tool_reference` for it | All tools (for `mcp_toolset`, see [tool configuration](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector#mcp-toolset-configuration)). On the computer use and browser use toolsets, set it per member inside `configs`; see [Client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets). | [Tool search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool)                                             |
+| `allowed_callers`       | Restrict which callers can call the tool                                                                              | All tools except `mcp_toolset` (on `computer_toolset_20260801` and `browser_toolset_20260801`, only `["direct"]` is accepted; see [Client toolsets](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference#client-toolsets))                                                                                                            | [Programmatic tool calling](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling#the-allowed-callers-field) |
+| `input_examples`        | Provide example input objects to help Claude understand how to call the tool                                          | User-defined and Anthropic-schema client tools, except `computer_toolset_20260801` and `browser_toolset_20260801`. Not available on server tools.                                                                                                                                                                                                             | [Define tools](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools#providing-tool-use-examples)                         |
+| `eager_input_streaming` | Enable fine-grained input streaming (`true`) or keep standard buffered streaming (`false`) for this tool              | User-defined tools only                                                                                                                                                                                                                                                                                                                                       | [Fine-grained tool streaming](https://platform.claude.com/docs/en/agents-and-tools/tool-use/fine-grained-tool-streaming)                       |
 
 ### `allowed_callers` values
 

 
 For `mcp_toolset`, the `cache_control` breakpoint lands on the last tool in the set. You don't control tool order within an MCP toolset, so place the breakpoint on the `mcp_toolset` entry itself and the API applies it to the final expanded tool.
 
+The [computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) and [browser use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool) toolset entries follow the same rule: place `cache_control` on the toolset entry itself, and the breakpoint lands after the toolset's definition. It isn't accepted inside a member's `configs` entry, because the toolset's members load as one definition. Within a [batch action](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#batch-actions), a `cache_control` marker on any of the turn's member `tool_use` or `tool_result` blocks is accepted and takes effect at the end of that batch, so several markers in one batch act as a single breakpoint. Each marker still counts toward the request's limit of [four breakpoints](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#when-to-use-multiple-breakpoints), so use one per turn.
+
 ## defer\_loading and cache preservation
 
 Deferred tools are not included in the system-prompt prefix. When the model discovers a deferred tool through [tool search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool), the definition is appended inline as a `tool_reference` block in the conversation history. The prefix is untouched, so prompt caching is preserved.

 
 ## Per-tool interaction table
 
-| Tool                                                                                                | Caching considerations                                                    |
-| --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
-| [Web search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool)         | Enabling or disabling invalidates the system and messages caches          |
-| [Web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool)           | Enabling or disabling invalidates the system and messages caches          |
-| [Code execution](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) | Container state is independent of prompt cache                            |
-| [Tool search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool)       | Discovered tools load as `tool_reference` blocks, preserving prefix cache |
-| [Computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool)     | Screenshot presence affects messages cache                                |
-| [Text editor](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool)       | Standard client tool, no special caching interaction                      |
-| [Bash](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool)                     | Standard client tool, no special caching interaction                      |
-| [Memory](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool)                 | Standard client tool, no special caching interaction                      |
+| Tool                                                                                                | Caching considerations                                                                                                                                                                                                                                         |
+| --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Web search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool)         | Enabling or disabling invalidates the system and messages caches                                                                                                                                                                                               |
+| [Web fetch](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool)           | Enabling or disabling invalidates the system and messages caches                                                                                                                                                                                               |
+| [Code execution](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) | Container state is independent of prompt cache                                                                                                                                                                                                                 |
+| [Tool search](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool)       | Discovered tools load as `tool_reference` blocks, preserving prefix cache                                                                                                                                                                                      |
+| [Computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool)     | Screenshot presence affects messages cache; `cache_control` goes on the toolset entry (see [cache\_control on tool definitions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-use-with-prompt-caching#cache-control-on-tool-definitions)) |
+| [Browser use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool)       | Screenshot presence affects messages cache; `cache_control` goes on the toolset entry (see [cache\_control on tool definitions](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-use-with-prompt-caching#cache-control-on-tool-definitions)) |
+| [Text editor](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool)       | Standard client tool, no special caching interaction                                                                                                                                                                                                           |
+| [Bash](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool)                     | Standard client tool, no special caching interaction                                                                                                                                                                                                           |
+| [Memory](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool)                 | Standard client tool, no special caching interaction                                                                                                                                                                                                           |
 
 ## Next steps
 

   </Tab>
 
   <Tab title="Files API">
-    <Note>
-      These examples reference the uploaded file as a `document` source, and no beta header is required. See [Files API](https://platform.claude.com/docs/en/build-with-claude/files) for upload details.
-    </Note>
+    These examples reference a file uploaded through the [Files API](https://platform.claude.com/docs/en/build-with-claude/files) as a `document` source.
 
     <CodeGroup>
       ```bash cURL

       ```
 
       ```php PHP
+      // The PHP SDK supports file_id document and image sources only through $client->beta->messages with the files beta.
       $citedResponse = $client->beta->messages->create(
           maxTokens: 1024,
           messages: [

   </Tab>
 
   <Tab title="Files API">
-    <Note>
-      These examples reference the uploaded file as a `document` source, and no beta header is required. See [Files API](https://platform.claude.com/docs/en/build-with-claude/files) for upload details.
-    </Note>
+    These examples reference a file uploaded through the [Files API](https://platform.claude.com/docs/en/build-with-claude/files) as a `document` source.
 
     <CodeGroup>
       ```bash cURL

       ```
 
       ```php PHP
+      // The PHP SDK supports file_id document and image sources only through $client->beta->messages with the files beta.
       $citedResponse = $client->beta->messages->create(
           maxTokens: 1024,
           messages: [

 
 ## How to use the Files API
 
-<Note>
-  Requests to the Files API endpoints (`/v1/files`) don't need a beta header. Neither do Messages or Message Batches requests that reference an uploaded file as a `document` or `image` source, or in a `container_upload` block for the code execution tool. Requests that still send the `anthropic-beta: files-api-2025-04-14` header keep working. On Files API requests, that header also selects the earlier response format: the list endpoint paginates with `before_id` and `after_id`, returns `has_more`, `first_id`, and `last_id` instead of `next_page`, and rejects the `page` and `ids[]` parameters as unknown fields. File objects returned under the header omit `expires_at` instead of returning `null` when no expiration is set. To use `page` and `ids[]` as described under [List files](https://platform.claude.com/docs/en/build-with-claude/files#list-files), send the request without the header. The PHP tabs on this page still call the SDK's `beta` namespace, which sends the header, so their list output uses the earlier format.
-</Note>
-
 ### Uploading a file
 
 Upload a file to be referenced in future API calls:

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Files API under the beta namespace; field names can differ from other SDKs.
   $file = $client->beta->files->upload(
       FileParam::fromResource(fopen('/path/to/document.pdf', 'rb'), contentType: 'application/pdf'),
   );

   ```
 
   ```php PHP
+  // The PHP SDK supports file_id document and image sources only through $client->beta->messages with the files beta.
   $response = $client->beta->messages->create(
       maxTokens: 1024,
       messages: [

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Files API under the beta namespace; field names can differ from other SDKs.
+  // list() paginates with afterID, beforeID, and limit; page and ids[] are not parameters here.
   $client = new Client();
 
   $files = $client->beta->files->list();

 
 To check a known set of files in one request instead of paging, pass up to 100 file IDs as `ids[]` query parameters. An `ids[]` request always returns a single page (`next_page` is `null`), and any ID that does not resolve to a file in your workspace is silently omitted from `data`; compare the returned IDs against the requested IDs to detect misses. `ids[]` cannot be combined with `page` or `limit`.
 
-The `page` parameter, the `next_page` cursor, and the `ids[]` filter apply to requests sent without the `anthropic-beta: files-api-2025-04-14` header. Requests that send the header receive the earlier list format described in the note under [How to use the Files API](https://platform.claude.com/docs/en/build-with-claude/files#how-to-use-the-files-api).
-
 #### Get file metadata
 
 Retrieve information about a specific file:

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Files API under the beta namespace; field names can differ from other SDKs.
   $file = $client->beta->files->retrieveMetadata($fileId);
   echo $file;
   ```

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Files API under the beta namespace; field names can differ from other SDKs.
   $client->beta->files->delete($fileId);
   ```
 

   ```
 
   ```php PHP
+  // The PHP SDK exposes the Files API under the beta namespace; field names can differ from other SDKs.
   $fileContent = $client->beta->files->download($fileId);
 
   file_put_contents("downloaded_file.txt", $fileContent);

 
 ### Client-side tools
 
-| Feature                                                                                         | Description                                                                                                                                                        | ZDR          | Availability                                                                                      |
-| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------ | ------------------------------------------------------------------------------------------------- |
-| [Bash](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool)                 | Execute bash commands and scripts to interact with the system shell and perform command-line operations.                                                           | ZDR eligible | <PlatformAvailability claudeApi claudePlatformAws bedrock vertexAi azureAi />                     |
-| [Computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) | Control computer interfaces by taking screenshots and issuing mouse and keyboard commands.                                                                         | ZDR eligible | <PlatformAvailability claudeApiBeta claudePlatformAwsBeta bedrockBeta vertexAiBeta azureAiBeta /> |
-| [Memory](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool)             | Enable Claude to store and retrieve information across conversations. Build knowledge bases over time, maintain project context, and learn from past interactions. | ZDR eligible | <PlatformAvailability claudeApi claudePlatformAws bedrock vertexAi azureAi />                     |
-| [Text editor](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool)   | Create and edit text files with a built-in text editor interface for file manipulation tasks.                                                                      | ZDR eligible | <PlatformAvailability claudeApi claudePlatformAws bedrock vertexAi azureAi />                     |
+| Feature                                                                                         | Description                                                                                                                                                        | ZDR          | Availability                                                                                  |
+| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------ | --------------------------------------------------------------------------------------------- |
+| [Bash](https://platform.claude.com/docs/en/agents-and-tools/tool-use/bash-tool)                 | Execute bash commands and scripts to interact with the system shell and perform command-line operations.                                                           | ZDR eligible | <PlatformAvailability claudeApi claudePlatformAws bedrock vertexAi azureAi />                 |
+| [Browser use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/browser-use-tool)   | Navigate, read, and interact with webpages in your own browser environment.                                                                                        | ZDR eligible | <PlatformAvailability claudeApi />                                                            |
+| [Computer use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool) | Control computer interfaces by taking screenshots and issuing mouse and keyboard commands.                                                                         | ZDR eligible | <PlatformAvailability claudeApi claudePlatformAwsBeta bedrockBeta vertexAiBeta azureAiBeta /> |
+| [Memory](https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool)             | Enable Claude to store and retrieve information across conversations. Build knowledge bases over time, maintain project context, and learn from past interactions. | ZDR eligible | <PlatformAvailability claudeApi claudePlatformAws bedrock vertexAi azureAi />                 |
+| [Text editor](https://platform.claude.com/docs/en/agents-and-tools/tool-use/text-editor-tool)   | Create and edit text files with a built-in text editor interface for file manipulation tasks.                                                                      | ZDR eligible | <PlatformAvailability claudeApi claudePlatformAws bedrock vertexAi azureAi />                 |
 
 ## Tool infrastructure