Claude's Agent Stack Just Went GA: Computer Use, Browser Use, Skills API & Files API Explained

If you've been holding off on shipping a Claude-powered agent because the tools felt too "beta" to put in front of customers, that excuse expired this week. On August 20, 2026, Anthropic moved four foundational building blocks of the Claude Platform — computer use, the brand-new browser use tool, the Skills API, and the Files API — out of beta and into general availability. Layered on top is a quieter but arguably bigger change: a new, stateless MCP specification (dated 2026-07-28) that makes it dramatically simpler to run MCP servers at scale.

Together, these four GA tools plus the new MCP core are the clearest signal yet that Anthropic wants Claude treated as infrastructure for production agents, not a beta experiment. If you're studying for the Claude Certified Architect (CCA) exam or building anything agentic on the Claude API, this is the release to understand. Here's what actually changed, why it matters, and how to start using each piece today.

What Moved Out of Beta on August 20, 2026

Four capabilities graduated from beta status simultaneously:

Computer use — Claude can look at a screenshot of a screen and act on it: click, type, scroll, and navigate software the way a human would, including apps that have no API at all.

Browser use (new) — a purpose-built companion to computer use for web applications. Instead of only reasoning over pixel coordinates, the browser tool reads the DOM structure of a page and acts on a specific field, button, or link — which means fewer misclicks and fewer wasted round trips per task.

Skills API — lets you package instructions, scripts, and reference templates into a reusable "skill" folder that Claude loads only when a task actually needs it, instead of stuffing everything into a system prompt.

Files API — upload a file once, get back a file_id, and reuse that reference across as many requests as you need instead of re-uploading the same PDF, spreadsheet, or dataset every call.

According to Anthropic's announcement, the Skills API and Files API are also now available through Microsoft Foundry, and the updated computer use and browser use tools are coming soon to Google Cloud's Vertex AI — meaning this isn't a Claude.ai-only feature, it's a first-class part of the Claude Developer Platform across major clouds.

Why "GA" Actually Matters Here

Beta labels aren't just legal hedging — they change how teams build. Engineering leads are (rightly) cautious about wiring beta APIs into revenue-critical workflows because behavior, pricing, and availability can shift without much warning. GA status signals:

Stability commitments — breaking changes go through a deprecation process instead of landing overnight.
Production SLAs — these tools are now expected to run at the reliability bar of the rest of the Claude API.
Enterprise procurement unlocks — many enterprise buyers (and their security/compliance teams) simply won't approve beta dependencies for anything customer-facing.

If your team shelved a computer-use prototype six months ago because legal wouldn't sign off on a beta dependency, it's worth resurfacing that conversation now.

Computer Use vs. Browser Use: When to Reach for Each

A common point of confusion: computer use and browser use solve overlapping but distinct problems.

Computer Use	Browser Use
Best for	Desktop apps, legacy software, anything with no API	Modern web apps, SaaS dashboards, form-heavy workflows
How it "sees"	Screenshots only	Screenshot + page structure (DOM)
Precision	Coordinate-based clicking	Element-targeted actions (specific field/button)
Round trips per task	Higher	Lower — fewer corrective actions needed

Practical example: Say you're automating expense report submission into an internal, browser-based finance tool that has zero public API. With the browser tool, Claude can identify the "Amount" field by its actual DOM role rather than guessing pixel coordinates on a screenshot that might shift if the page reflows. That precision is exactly what makes browser use the better default for web automation, while computer use remains the right tool for native desktop apps, terminal-based workflows, or anything rendered outside a browser.

Skills API: Stop Re-Explaining Yourself in Every Prompt

If you've ever built a system prompt that tries to teach Claude your company's entire style guide, API conventions, and edge-case handling in one giant block of text, the Skills API is the fix. A skill is a folder — instructions, scripts, templates — that Claude loads conditionally, only when the current task calls for it.

This has two direct benefits for anyone building production agents:

Lower token overhead. You're not paying to re-send a 4,000-word playbook on every single call when only 200 words of it are relevant to the task at hand.
Composability. Skills are versioned and reusable, which means you can build a library of skills (PDF generation, code review checklists, internal API conventions) and mix them into different agents without duplicating logic.

This pairs directly with Claude Managed Agents, which Anthropic explicitly ties to "versioned skills and reusable files" in this same announcement — the Skills API and Files API are the building blocks managed agents are meant to run on.

Files API: The End of Redundant Uploads

The Files API sounds mundane until you've built an agent that processes the same reference document across dozens of conversation turns. Before, that often meant re-uploading (and re-paying for) the same file repeatedly. Now:

Upload a file once via the Files API.

Get back a persistent file_id.

Reference that file_id in any future request — no re-upload, no redundant processing.

For teams building document-heavy agents (contract review, research assistants, customer support bots referencing a knowledge base), this is a direct cost and latency win, and it's the kind of detail that shows up on the CCA exam's agent-architecture questions.

The Quiet Big Deal: MCP's New Stateless Core (Spec 2026-07-28)

Running alongside the GA announcement, Anthropic also began rolling out support for the MCP 2026-07-28 specification, and it's a meaningful architectural shift for anyone running MCP servers. The old MCP handshake required a session ID that pinned a client to a specific server instance — fine for a single long-running process, painful for anything you wanted to deploy on serverless or edge infrastructure.

The new spec removes that session-pinning requirement. A stateless core means any request can land on any server instance, which unlocks:

Serverless MCP servers — deploy on Lambda, Cloudflare Workers, or similar without maintaining sticky sessions.
Simpler horizontal scaling — no more routing logic to keep a client glued to "its" instance.
Lower operational complexity for teams maintaining internal MCP servers at scale.

With Claude's connector directory now listing over 950 MCP servers in active use, this stateless core is Anthropic clearing the path for that number to keep growing without turning MCP server operations into its own infrastructure headache.

How to Get Started Building With This Stack

If you want hands-on practice before these concepts show up on a certification exam or a client project, here's a sensible build order:

Start with the Files API. It's the lowest-friction entry point — upload a reference doc, get a file_id, and use it across a small test agent.

Package a Skill. Take one recurring task (say, "format this into our internal report template") and turn it into a Skills API skill instead of a system-prompt block.

Prototype browser use on a real internal tool. Pick a web app your team actually uses that lacks a public API, and have Claude complete one multi-step task end to end.

Only reach for computer use when the target application genuinely has no browser-based or API-based path — it's the right tool for legacy desktop software, not the default for everything.

Key Takeaways

Computer use, browser use, the Skills API, and the Files API are all GA as of August 20, 2026 — no longer beta, now backed by production stability expectations.
Browser use is the better default for modern web apps because it acts on page structure, not just screenshot coordinates.
The Skills API cuts token overhead and makes agent capabilities reusable and versioned; it's the foundation Claude Managed Agents build on.
The Files API eliminates redundant re-uploads via persistent file_id references.
MCP's new stateless spec (2026-07-28) removes session pinning, making serverless and edge-deployed MCP servers practical for the first time.

Next Steps

Agent architecture — including when to use computer use vs. browser use, and how the Skills and Files APIs fit into managed agent design — is exactly the kind of applied knowledge tested on the Claude Certified Architect (CCA) exam. If you're prepping for certification or just want structured practice with Claude's agent stack, check out AI for Anything's CCA practice test bank to test what you actually know before you sit the real exam.

Sources: