Computer Use, Browser Use, Skills and Files Go GA: How Claude Now Drives Apps That Have No API
Anthropic’s 19 August release takes four agent building blocks out of beta on the Claude Platform. Here is how each one actually works, why it means fewer round trips per task, and how they fit together in a Managed Agent.
On 19 August 2026 Anthropic quietly moved four pieces of agent infrastructure to general availability on the Claude API: the computer use tool, now shipped as the computer_toolset_20260801 toolset; a brand-new browser use tool, browser_toolset_20260801; the Files API; and Agent Skills together with the Skills API. The one-line pitch from @ClaudeDevs was “automate work in applications that have no API with fewer round trips per task, and build Claude Managed Agents on versioned skills and reusable files.” That sentence is doing a lot of work, so this post unpacks it: what each piece is, how the loop runs, and what changes in your code.
The one idea underneath all four: the loop runs on your side
Neither toolset runs a browser or a desktop on Anthropic’s servers. They are client toolsets: you add {"type": "browser_toolset_20260801"} or {"type": "computer_toolset_20260801"} to tools, Claude answers with tool_use blocks naming member tools such as navigate, left_click or type — each tagged with a toolset_name — and your application executes them in an environment you host, then sends back one tool_result per tool_use. Claude looks at what came back and decides the next turn. The loop ends when it replies with text instead of tool calls.
- Claude
- Sees the task plus the toolset definition and emits tool_use blocks. It never touches the environment directly — it only proposes actions and reads results.
- Your app (the executor)
- Receives the tool_use blocks, runs them against your browser or desktop in order, and returns one tool_result per block. Stops at the first failure and marks the rest as not executed.
- Browser or desktop
- hosted by youA sandboxed browser for browser_toolset_20260801, or a VM/container with a display for computer_toolset_20260801. Anthropic processes screenshots and actions but never hosts the environment.
- tool_use batch
- several per turnSince the GA toolsets, one assistant turn can carry several member calls — click, type, Enter — instead of one action per round trip.
- Observation
- A screenshot (computer use), or an accessibility tree / page text / browser_state block (browser use). You can bundle an observation onto the last result of a batch to save a turn.
- tool_result batch
- One tool_result per tool_use, in a single user message. For a failed action: is_error: true, and later actions get the exact halt text “Not executed: an earlier action in this turn failed.”
That division of labour is the same one computer use has had since 2024. What is new is the shape of each turn. Under the old computer_20251124 tool Claude issued one action, waited for your result, issued the next. The GA toolsets let a single assistant turn carry several member calls, and the browser toolset adds a way to name page elements that does not depend on pixel coordinates at all. Those two things are where the “fewer round trips” comes from.
Computer use: from one click per turn to a batch per turn
computer_toolset_20260801 exposes 17 member tools: screenshot and zoom for looking; left_click, right_click, middle_click, double_click, triple_click, left_click_drag, mouse_move, left_mouse_down, left_mouse_up, cursor_position and scroll for the mouse; type, key and hold_key for the keyboard; and wait. zoom — a full-resolution crop of a region — is on by default now, and each member can be switched off or tuned through a configs map on the toolset. You declare the toolset once; there is no input_schema to write.
The behavioural change is batching. Claude can return, say, a left_click, a type and a screenshot in one response. The contract on your side is strict: run the blocks in order, never in parallel, and stop at the first failure. The failed action gets is_error: true with a description, and every later action in the same turn must come back with the exact text “Not executed: an earlier computer action in this turn failed.” so Claude knows where the chain broke.
// one assistant turn, three actions
{ "role": "assistant", "content": [
{ "type": "tool_use", "id": "toolu_01", "name": "left_click", "toolset_name": "computer",
"input": { "coordinate": [640, 60] } },
{ "type": "tool_use", "id": "toolu_02", "name": "type", "toolset_name": "computer",
"input": { "text": "pictures of cats" } },
{ "type": "tool_use", "id": "toolu_03", "name": "screenshot", "toolset_name": "computer",
"input": {} }
]}
// your reply: one tool_result per block, in order, in ONE user message
{ "role": "user", "content": [
{ "type": "tool_result", "tool_use_id": "toolu_01", "toolset_name": "computer",
"content": [{ "type": "text", "text": "OK" }] },
{ "type": "tool_result", "tool_use_id": "toolu_02", "toolset_name": "computer",
"content": [{ "type": "text", "text": "OK" }] },
{ "type": "tool_result", "tool_use_id": "toolu_03", "toolset_name": "computer",
"content": [{ "type": "image", "source": { "type": "base64", "media_type": "image/png", "data": "iVBORw0KG…" } }] }
]}Show the 3 numbers behind this chart
| Category | Model round trips |
|---|---|
| One action per turn (computer_20 | 10 |
| Batched (computer_toolset_202608 | 4 |
| Refs + form_input (browser_tools | 3 |
Two practical notes. The earlier beta versions keep working — computer_20251124 with its beta header is still what you use on Claude Opus 4.7, Sonnet 4.6 and Opus 4.6, and still the only option on Claude Platform on AWS, Bedrock, Vertex AI and Foundry. And upgrading is not a rename: the request shape and the tool-result handling both change, so read the migration section of the computer use docs before swapping the type string.
Browser use: Claude reads the page, not just the pixels
browser_toolset_20260801 is the more interesting launch. It is built for the case where the “application with no API” is a website, and it gives Claude something computer use never had: the page’s own structure. Alongside screenshot, zoom and the familiar pointer and keyboard members, there are three reading tools — read_page returns the accessibility tree as tagged text, find answers a natural-language query with up to 20 matching elements, and get_page_text returns the readable article text — plus form_input to set a field, checkbox or select directly, four tab tools (new_tab, list_tabs, switch_tab, close_tab), and navigate for URLs and history. Four optional members, javascript_exec, file_upload, read_console and read_network, are off unless you enable them in configs.
The key mechanism is the element reference. When your executor answers read_page it labels each interactive node — link "Pricing" [ref_2], textbox "Search" [ref_4] — and keeps its own map from ref_2 to the underlying DOM node or accessibility id. Claude then targets actions by reference instead of by coordinate: {"target": {"type": "ref", "ref": "ref_2"}}. References are tab-scoped and die on navigation, at which point you return an error telling Claude to re-read the page. Coordinates are still allowed, and still needed for canvases, video and cross-origin frames, but they are no longer the default way to touch a page.
// read_page (filter: "interactive") comes back as tagged text
link "Documentation" [ref_1]
link "Pricing" [ref_2]
textbox "Search docs" [ref_3]
button "Search" [ref_4]
// and Claude acts on the reference, not on a pixel
{ "type": "tool_use", "name": "left_click", "toolset_name": "browser",
"input": { "target": { "type": "ref", "ref": "ref_2" } } }
// navigation and tab tools also return a browser_state block your executor fills in
{ "type": "browser_state",
"tabs": [{ "tab_id": "tab-1", "title": "Pricing", "url": "https://example.com/pricing", "active": true }],
"state_changes": [{ "type": "download_started", "download_id": "dl-1", "url": "https://example.com/invoice.pdf" }] }Step through a complete two-round-trip task below. Left is the Messages API transcript, right is what the browser your app hosts is doing at that moment.
Where the round trips go: batching, as with computer use; references that survive layout shifts, so a click rarely needs a confirming screenshot; form_input, which sets a value in one call rather than focus-type-blur; and observation bundling — your executor may attach a screenshot or a fresh tree read as an extra content block on the last result of a batch, and a browser_state footer rides along with every navigation so Claude always knows which tabs exist without asking.
Skills: versioned expertise you attach instead of prompting
Agent Skills are directories with a SKILL.md at the root — YAML frontmatter carrying a name (lowercase, hyphens, at most 64 characters) and a description (at most 1,024) — plus whatever scripts and reference files the task needs, up to 30 MB uncompressed. Claude sees the name and description up front and only reads the rest when a task matches, which is what keeps a library of skills cheap on context. Anthropic ships four (pptx, xlsx, docx, pdf); you upload your own to the workspace with POST /v1/skills.
The part that matters for production is versioning. Every upload to POST /v1/skills/{skill_id}/versions is a complete snapshot with its own skver_ id; files you leave out are not carried forward. You reference a skill as {"type": "custom", "skill_id": "skill_01…", "version": "latest"} to ride the newest version, or pin an exact version id to freeze behaviour. On the Messages API skills ride in the container parameter next to the code execution tool, up to 20 per request, and any documents they produce come back as file_id values you download through the Files API. As of 19 August the skills-2025-10-02 header is gone; requests that still send it behave exactly as before.
# upload a skill directory once
skill = client.skills.create(files=files_from_dir("financial_skill"))
# skill.id -> "skill_01AbCdEfGhIjKlMnOpQrStUv", skill.latest_version_id -> "skver_01…"
# use it on the Messages API (needs the code execution tool; no beta header any more)
response = client.messages.create(
model="claude-opus-5",
max_tokens=4096,
container={"skills": [
{"type": "anthropic", "skill_id": "xlsx", "version": "latest"},
{"type": "custom", "skill_id": skill.id, "version": skill.latest_version_id},
]},
tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
messages=[{"role": "user", "content": "Build the Q3 variance workbook from the attached ledger."}],
)In Claude Managed Agents the same skills attach to the agent definition through a skills array, with version pinned or left at latest, up to 500 deduplicated skills per session — and since 7 August a session that mounts a GitHub repository also discovers any skills in that repo’s root .claude/skills directory at start-up, no upload needed. That is convenient and worth a warning: a mounted repo is now part of your agent’s trust boundary, because anyone who can merge a SKILL.md into it is writing instructions your agent will follow.
Files: upload once, reference everywhere
The Files API is the plumbing under both of the above. POST /v1/files takes a PDF, text file or image (up to 500 MB each, 1 TB per organisation) and returns a file_id you reference in a message as a document, image or container_upload block instead of re-sending bytes on every turn. The GA response format adds two things that were missing: an optional expires_in_seconds on upload (one hour to 90 days), reported back as expires_at, and proper page / next_page pagination plus an ids[] filter on list. Files that skills or code execution create are the only ones you can download; your own uploads are write-only.
# upload once — no files-api-2025-04-14 header needed now
uploaded = client.files.upload(
file=("ledger.pdf", open("ledger.pdf", "rb"), "application/pdf"),
)
# reference by id, as many times as you like
response = client.messages.create(
model="claude-opus-5",
max_tokens=1024,
messages=[{"role": "user", "content": [
{"type": "text", "text": "Summarise the open items."},
{"type": "document", "source": {"type": "file", "file_id": uploaded.id}},
]}],
)
# generated outputs (from skills / code execution) are downloadable
client.files.download(generated_file_id).write_to_file("variance.xlsx")For Managed Agents the file_id becomes a session resource: {"type": "file", "file_id": …, "mount_path": "/data.csv"} puts a read-only copy at /mnt/session/uploads/data.csv inside the sandbox, up to 500 files per session, and you can add or remove resources on a running session. Anything the agent writes can be listed by scope_id and pulled back out through the same download endpoint. One caveat that applies to both files and skills: they are scoped to the workspace, not to an end user. Any key in the workspace can read any file, so never accept a file_id from a user, and give multi-tenant apps a workspace per tenant.
How the four fit together in a Managed Agent
- Skills API
- GA, no beta headerUpload a SKILL.md directory once. Each upload is a snapshot with its own skver_ id; reference it as latest or pin an exact version.
- Files API
- GA, no beta headerUpload once, get a file_id, reference it in Messages requests or mount it into a Managed Agents session. 500 MB per file, 1 TB per organisation, optional expiry.
- Agent
- create once, reference by idModel, system prompt, tools and the skills array live on the agent, never on the session. Update it and sessions pin to the version they started with.
- Session + sandbox
- Each session gets its own container. Mounted files land read-only under /mnt/session/uploads; skills load when a task matches; generated files get a downloadable file_id.
- Your app
- Streams session events, answers custom tool calls, lists session files by scope_id and downloads the outputs.
- sessions.create
- The only call in the request path. The agent id plus resources — files and optionally a GitHub repo whose .claude/skills directory is scanned at start.
The pattern Anthropic is nudging you towards is clear from the announcement wording: the agent is a stored, versioned recipe (model, system prompt, tools, skills), sessions are cheap and disposable, and everything the agent needs to know or read arrives as a pinned skill version or a mounted file rather than as a giant prompt. One honest caveat: the browser and computer toolsets are documented for the Messages API today, while a Managed Agents session’s built-in toolset is the sandbox set — bash, read, write, edit, glob, grep, web_fetch and web_search. Putting a live browser inside a Managed Agents session is still a custom-tool or partner-hosted affair (Browserbase already documents a CDP integration) rather than a one-line config.
Safety: the part the announcement does not shout about
Driving a real browser or desktop means every page, screenshot, tab title and download name is untrusted input that can try to steer the model. The docs are explicit about what they expect you to do, and none of it is optional in practice:
- Run the browser or desktop in a dedicated container or VM with minimal privileges, no personal credentials and no sensitive filesystems mounted.
- Restrict network access to an allowlist of domains, and re-check the URL in your navigate handler after redirects — only http and https should ever be allowed.
- Leave javascript_exec, file_upload, read_console and read_network off unless a specific workflow needs them, and if you enable file_upload, validate paths against a dedicated directory.
- Require a human confirmation step for consequential actions — purchases, account changes, accepting terms. Anthropic’s own classifiers flag likely prompt injections in screenshots and make Claude ask for confirmation before continuing; you can opt out for unattended automation, but that is a decision, not a default.
What to do this week
- Delete the files-api-2025-04-14 and skills-2025-10-02 beta headers from your code. Requests without them get the GA response formats — pagination and expires_at on files — so check any code that parses list responses.
- If you run computer use on a GA-supported model, plan the move to computer_toolset_20260801: it changes the request shape and your result handling, and you gain batching and per-member configs.
- If your computer-use task was really a web task, prototype it on browser_toolset_20260801 — the reference-based loop is both cheaper in round trips and less brittle than coordinate clicking.
- Pin skill versions in anything customer-facing, set expires_in_seconds on transient uploads, and give each tenant its own workspace — files and skills are workspace-scoped.
Full details are in the Claude Platform release notes for 19 August, and the four reference pages: computer use tool, browser use tool, using Agent Skills with the API and the Files API. For the Managed Agents side, see Skills and Adding files.
