Claude Platform Makes Four Agent APIs Generally Available

You can build agents that read documents, apply versioned procedures, and operate browser or desktop software with Claude’s production agent stack. Anthropic moved Computer Use, Browser Use, the Skills API, and the Files API to General Availability on August 20, 2026, as described in the platform announcement. This tutorial shows how to structure the workflow, choose between browser and desktop automation, manage files and skills, and account for the main limits.

Map the agent workflow before writing code

The four capabilities divide an agent into clear responsibilities:

Workflow stage	Claude capability	Purpose
Input	Files API	Store documents and reference them by file_id
Procedure	Skills API	Attach reusable, versioned instructions and scripts
Execution	Browser Use or Computer Use	Operate web applications or desktop interfaces
Deliverable	Files API and code execution	Produce, store, and retrieve reports or modified files

This separation is useful for production systems because documents, procedures, and actions have different lifecycles. A policy document may expire after a short period, a skill may need version control, and an automation tool may require tighter permissions than the model’s text-generation step.

The design also fits the broader practice of building reliable agents. Treat every stage as an observable boundary. Record the input file IDs, selected skill version, tool calls, returned artifacts, and final validation result for each run.

Installation and setup

The APIs are available on the Claude Platform. Skills are also available natively on AWS and Microsoft Foundry. Start with the Claude tool reference for the current request structure, then configure the four capabilities in the order your workflow uses them.

A practical setup sequence is:

1. Create the organization workspaces required for tenant isolation.
2. Upload source documents through /v1/files and retain each returned file_id.
3. Package domain instructions as a SKILL.md directory containing structured instructions, executable scripts, and workflow templates.
4. Upload and version the skill through /v1/skills.
5. Declare either browser_toolset_20260801, computer_toolset_20260801, or both in the agent request.
6. Attach the relevant file references and skill to the Messages API call.
7. Persist output file IDs, expiration metadata, and the agent’s completion log.

Skills execute Python and Bash scripts inside Anthropic’s hosted code execution sandbox. The Skills API supports up to 100 workspaces per organization by default, which gives you a boundary for separating customer, department, or environment-specific procedures.

Keep skill packages focused. A skill should define the procedure, validation criteria, and supporting scripts for one domain task. Splitting unrelated operations into separate skills makes version changes easier to audit and lets the agent attach only the instructions required for a request. The agent skills guide covers the packaging model in more detail.

Manage documents with the Files API

The Files API lets you upload a document once and reference it across Messages API calls or code execution environments. This is the right place to keep PDFs, spreadsheets, and intake forms used repeatedly during a workflow.

Files API feature	How to use it in an agent
file_id references	Pass the stored identifier instead of repeatedly embedding the document
expires_in_seconds	Set the desired file lifetime when temporary storage is appropriate
expires_at	Track the resulting automatic expiration time
ids[] filtering	Retrieve or filter specific stored files
page and next_page	Paginate through file listings
Organization storage	Plan for up to 1 TB of storage

The API also provides 5x higher rate limits than its previous availability level. That capacity helps when multiple agent runs share a document corpus, although storage and request limits still need to be part of your workload design.

Use expiration deliberately. Short-lived uploads suit one-time intake processing, while reusable reference material can remain available for longer-running workflows. Store the expiration timestamp with your job metadata so a retry can detect an unavailable input and request a fresh upload rather than failing inside the execution loop.

Files can contain sensitive business material, so keep file references scoped to the workspace and workflow that needs them. Do not treat a file_id as a substitute for authorization in your application. Your orchestration layer should decide which files an agent may attach before the model receives the request.

Attach a versioned procedure with the Skills API

The Skills API standardizes reusable agent behavior around the open SKILL.md package format. A package can include:

• Structured operating instructions
• Executable Python or Bash scripts
• Workflow templates
• Validation criteria

The key architectural choice is to keep procedural knowledge in a managed package rather than copying a long operating manual into every prompt. Upload, version, attach, and manage the skill programmatically. The agent request then combines a specific document set with a known procedure version.

For example, an invoice-processing workflow might use one skill to define field validation, exception handling, and output formatting. The Files API supplies the invoices, while Browser Use enters approved values into the finance application. A later skill version can change validation rules without changing the document-ingestion layer or browser orchestration.

Test skill changes against representative files before promoting them to a production workspace. Include explicit completion checks in the package, such as required fields, acceptable formats, and conditions that require human review. Keep those checks separate from the agent’s natural-language goal so the workflow has a deterministic validation boundary.

Choose Browser Use or Computer Use

Use Browser Use when the target application is accessible through a client-hosted browser viewport and its DOM or accessibility tree exposes the controls the agent needs. Use Computer Use when the workflow depends on a desktop interface, visual state, or software that cannot be operated through browser element references.

Browser Use

The browser_toolset_20260801 toolset includes 27 member tools by default, including navigate, read_page, find, get_page_text, form_input, new_tab, and switch_tab. Four additional tools are opt-in: javascript_exec, file_upload, read_console, and read_network.

read_page inspects the DOM and accessibility tree and returns persistent element references such as [ref_2]. Those references are more stable for structured web workflows than relying exclusively on pixel coordinates. The tradeoff is context cost: declaring the browser toolset adds approximately 6,600 input tokens before prompt execution. For short tasks, that overhead can materially affect efficiency, so enable the browser toolset only for requests that need it.

Opt-in tools should be enabled according to the workflow’s actual requirements. A form-filling agent may need file_upload, while a debugging workflow may need read_console or read_network. Avoid exposing capabilities that the skill never uses.

Computer Use

The computer_toolset_20260801 toolset is a single client toolset definition with 17 member tools, including screenshot, left_click, type, and zoom. It supports multiple member actions in one model turn and executes them sequentially. Anthropic reports that batching reduces task-completion steps and latency by 20% to 40%.

Zoom is enabled by default through configs.zoom.enabled. Computer Use also supports fine-grained per-member toggling, which lets you expose only the actions required by a workflow. Configure a narrow tool surface for tasks that only need screenshots, clicks, and typing.

Computer Use is supported on Claude Fable 5, Claude Mythos 5, Claude Opus 5, Claude Sonnet 5, and Claude Opus 4.8. The tool is appropriate for visual interfaces, but coordinate-based interaction remains sensitive to layout changes. Add screenshots and state checks around important transitions, and require confirmation before irreversible actions such as submitting, deleting, or sending data.

Design retries and validation around tool calls

A production loop should treat every tool result as a new state observation. After a browser action, read the page again when the next decision depends on updated content. After a computer action, capture a screenshot when visual confirmation matters. Store failed tool calls with the associated file IDs and skill version so you can reproduce the exact execution context.

Keep the agent’s final response separate from the deliverable. Reports and modified documents should be generated in the execution environment, uploaded or referenced through the Files API, and returned with their file_id. Your application can then expose a download link, pass the artifact to another workflow, or retain it according to its lifecycle policy.

For high-impact workflows, add a human approval state between validation and the final external action. This is especially important when the agent can submit transactions, modify records, or publish information through a browser or desktop application. Agent observability practices can help you monitor latency, tool failures, token overhead, and artifact production across runs.

Start with a bounded end-to-end workflow

Choose one workflow with a fixed document type, one versioned skill, and a small set of browser or desktop actions. Set file expiration, enable only the required tool members, and make the skill’s validation criteria explicit. Once that path produces auditable artifacts consistently, expand the workspace and add additional skills or application surfaces.