Anthropic shipped background computer use for Claude on September 3, 2026: Claude can now click, type, and open apps on your Mac desktop while you work on something else, inside Claude Cowork and Claude Code. It's in beta for Pro and Max plan subscribers on macOS. The framing from Anthropic's own announcement is simple — "give it something to do on your desktop and Claude clicks, types, and opens apps just like you would, while you work on something else."
TL;DR
| Question | Answer |
|---|---|
| What's new? | Claude can operate desktop apps in the background, not just in an active foreground session |
| Where? | Claude Cowork and Claude Code |
| Platform | macOS desktop app only at launch |
| Plans | Pro and Max, beta |
| How to enable | Settings → General → Computer use, in the desktop app |
| Comparable moves this week | OpenAI Codex's computer use, Cursor's cloud agents on user-managed infrastructure |
What "background" actually changes
Claude has had some form of computer-use capability — seeing a screen and controlling mouse/keyboard — for a while. The change here is specifically about attention: previously, operating a desktop through Claude generally meant the interaction lived in the foreground, visible and requiring the user to stay with the session. Background computer use decouples that — you hand Claude a desktop task (a support screenshot in the announcement example shows "Create a new file in TextEdit"), Claude requests computer-use permission if it isn't already granted, and then works the task while you switch to something unrelated.
Anthropic's own support documentation frames the setup as: turn on computer use in Settings → General → Computer use in the Mac desktop app, and it's off by default — a permission-gated capability rather than an always-on one, consistent with how Anthropic has rolled out other high-autonomy features like Claude for Work connectors.
Why this matters beyond the convenience angle
Background desktop control is one piece of a broader 2026 pattern across the major coding-agent vendors: moving agent execution off the user's immediate, synchronous attention.
| Vendor | This week's move | What it decouples |
|---|---|---|
| Anthropic | Background computer use (Cowork/Code) | Desktop task execution from foreground attention |
| Cursor | Cloud agents on user-managed infrastructure (own machines or sandbox providers like AWS Lambda, Cloudflare, E2B, Modal, Vercel) | Agent compute from the local machine entirely |
| OpenAI | Codex computer use (Windows/mobile control) | Desktop/mobile operation from Codex's own runtime |
The common thread: none of these are asking "can an agent operate a computer" anymore — that's established. They're each answering "where does that agent run, and does it need the user watching," which is a different, more operational question with real implications for how teams design agent-driven workflows, permission scoping, and audit trails.
What to actually scope before turning this on
Because background computer use grants Claude the ability to act on real apps without you watching in real time, the practical setup questions are less "does it work" and more "what should it be allowed to touch":
- Start with a narrow, low-stakes task class — file creation, form filling in a sandboxed app — before trusting it with anything touching credentials, payments, or irreversible actions.
- Treat prompt injection risk as real for any background-running agent that might browse or interact with untrusted content while you're not watching the screen — the same caution that applies to agent skills from unverified sources.
- Check what's logged. A background task you didn't watch happen still needs to be auditable after the fact if something goes wrong.
- Revoke access when the task is done, rather than leaving background computer use enabled indefinitely as a default state.
How this fits with Claude Cowork specifically
Claude Cowork is Anthropic's take on a persistent, multi-tasking Claude workspace — the framing is explicitly "give Claude something to work on, then go do something else." Background computer use is the natural extension of that idea from files and terminal commands into actual GUI applications: previously, if a Cowork task needed to interact with an app that only exposes a graphical interface — no CLI, no API, no MCP server — Claude either couldn't touch it or needed you sitting there approving each click. Background computer use closes that gap for exactly the class of tasks that were previously out of reach: legacy desktop software, internal tools with no automation surface, or any app where "just use the GUI like a person would" is genuinely the only integration path available.
This also changes how Claude Code specifically can be used for non-coding adjacent work. A Claude Code session that needs to, say, configure a setting in a native macOS app, export something from a desktop tool, or verify how a UI actually renders before writing code against it, can now hand that step to background computer use instead of stopping to ask the developer to do it manually and report back. That's a small but real reduction in the back-and-forth that otherwise interrupts an agentic coding session every time it needs something outside the terminal and file system.
Setting expectations: what background computer use is not
It's worth being precise about what shipped here, because "Claude uses your computer in the background" invites some assumptions that don't hold yet:
- It's not full autonomous operation of your machine around the clock. It executes a specific task you hand it, then stops — it isn't a standing background process watching for triggers or acting on its own initiative.
- It's not cross-platform yet. Windows and Linux users, and anyone on Enterprise or Teams plans, don't have this today regardless of how they use Claude elsewhere.
- It's not invisible. Anthropic's own UI shows a "Working on your computer" status with elapsed time and an expandable detail view — you can check in on what it's doing, which matters for trust even if you're not watching continuously.
- It's not a replacement for MCP or API integrations where those exist. If an app has a proper API or MCP server, that remains the more reliable and auditable way to automate it — computer use (background or foreground) is the fallback for the apps that don't, not a universal automation layer to reach for by default.
What to watch for as this rolls out further
Two things worth tracking as background computer use matures past this initial beta: whether Anthropic extends it to Windows/Linux and to Enterprise/Teams plans, given that a meaningful share of the automation use cases that benefit most (internal tools, legacy line-of-business software) skew toward Windows-heavy enterprise environments rather than individual Mac users; and whether Anthropic publishes more detail on the sandboxing and scoping model — specifically, whether a background task can be constrained to a specific app or window rather than granted access to the full desktop, which would meaningfully change the risk calculus for teams considering it for anything beyond low-stakes personal tasks.
Honest limitations
- Beta, macOS only, Pro/Max plans only — no Windows, Linux, Enterprise, or Teams availability announced yet.
- Anthropic's own announcement doesn't detail exact safeguards against a background task acting on the wrong window or app if the desktop state changes mid-task — worth testing conservatively before relying on it for anything consequential.
- "Full control of your screen" (per Anthropic's own support-doc wording) is a broad permission grant; teams should treat it the way they'd treat any credential with wide blast radius, not a low-risk toggle.
How this compares to what Codex and Cursor shipped this same week
Reading all three of this week's agent-execution announcements together is more informative than reading any one in isolation. OpenAI's Codex computer use targets Windows and mobile control specifically — a different platform bet than Anthropic's Mac-first rollout. Cursor's cloud agents on user-managed infrastructure solve a related but distinct problem: not "can an agent operate a GUI," but "where does an agent's compute physically run so it can reach internal services." Put side by side, none of the three vendors is competing on whether an agent can control a computer anymore — that capability exists across all of them in some form. The competition has moved to platform coverage, execution location, and how much of the workflow can happen without a human in the loop watching in real time, which is a genuinely different and more operationally interesting question than the raw capability question that dominated agent-tooling coverage a year earlier.
Closing
Background computer use turns Claude's existing screen-control capability into something you can actually delegate rather than babysit — a meaningful shift for anyone using Claude Cowork or Claude Code for real desktop workflows, not just chat. It lands the same week Cursor shipped user-managed cloud agent infrastructure, which is a useful signal: the frontier of agent tooling right now is less about raw model capability and more about where and how autonomously an agent is allowed to run. Scope it narrowly at first, and expand as you build trust in what it actually does unattended.
Related on explainx.ai
- OpenAI Codex Computer Use: Windows and Mobile Control
- Claude for Work
- What Are Agent Skills? Complete Guide
- Agent Skills Security: The Verification Threat
- Claude Code vs Cursor vs GitHub Copilot
- Claude Code Permission Modes Explained
- Claude Commerce Agents: Open-Source Blueprint
Sources
- Claude on X — background computer use announcement
- support.claude.com — Computer use setup and safety guidance
This post reflects Anthropic's official announcement as of September 3, 2026. Feature availability (platforms, plans) may expand beyond what's described here — check Anthropic's support documentation for current status.