A computer-use agent is the thing people actually meant when they said “AI agent” two years ago and got a chatbot instead. Not a model that answers questions, not a coding assistant that lives in your editor — software that takes a screenshot, decides where to click, moves your mouse, types into the field, and keeps going until the task is done or it gets stuck.
May 2026 was a big month for this category. ServiceNow and NVIDIA put a governed autonomous desktop agent on stage at Knowledge 2026. Claude Cowork went GA back in April. OpenAI shipped background computer use inside Codex. Gemini’s browser agent kept maturing. So the question people are searching — “best computer-use agent 2026” — has the wrong shape. There isn’t one. The honest answer is that the winner flips depending on where your work actually happens.
What counts as a computer-use agent (and what doesn’t)
This trips people up, so let’s draw the line clearly.
A chatbot answers. A coding agent like Devin or Codex writes and runs code in a repo or sandbox — I covered that race in the async cloud coding agents roundup. A no-code RPA bot follows a brittle pre-recorded script that breaks the moment a button moves.
A computer-use agent is different from all three. It perceives a screen (or a DOM) and acts on it the way a person would, with no API and no pre-built workflow. There are really two flavors under the hood, and the difference matters more than the marketing suggests:
- Screenshot + mouse/keyboard control. The agent sees pixels, reasons about them, and emits coordinates and keystrokes. OS-agnostic. Works on anything you can render to a screen — legacy desktop apps, weird internal tools, a remote VM. Also slower and more prone to misclicks on dynamic UIs.
- DOM-native web actions. The agent reads the page’s actual structure and clicks elements by their identity, not their pixel position. Way more reliable for the web, useless outside a browser.
Almost every “my agent failed” story comes from using a pixel-based agent for something a DOM-based one would’ve nailed, or vice versa. Keep that split in mind — it’s the whole ballgame.
The contenders, by what they’re actually good at
OpenAI Operator — the browser errand-runner
Operator is the one most people have touched, because it ships with ChatGPT. Tell it to book a restaurant, fill out a multi-page form, pull data off a few sites, and it’ll grind through it in a hosted browser. In April 2026 OpenAI folded computer use into Codex with background sessions, so it can now run desktop tasks in parallel and it leans macOS-first for that.
It’s the lowest-friction way to try the whole category. The flip side: it’s happiest inside a browser, and when it wanders into something visually fussy it stalls or asks you to take over. Fine for errands, shaky for anything you’d bet a deadline on.
Gemini Computer Use — the web specialist
Gemini’s agent grew out of Project Mariner, and it shows. It’s DOM-aware, so on browser workflows — clicking through a SaaS dashboard, scraping structured data, navigating a checkout — it tends to be the steadiest of the bunch. When the work genuinely lives in Chrome, this is usually the one I reach for.
That strength is also the ceiling. Hand it a local file or a native desktop app and the web-native advantage evaporates. It’s a browser agent that’s excellent at being a browser agent, full stop.
Claude Computer Use & Cowork — the desktop generalist
Anthropic took the portable route. Claude Computer Use exposes a screenshot-plus-mouse-and-keyboard tool with no OS baked in, so it runs across VMs, containers, and remote desktops. Cowork is the consumer-facing wrapper — it went from research preview in January to GA on April 9, 2026, and it now lives in the Claude Desktop app on macOS and Windows, working on your local files and apps in the background and handing back a finished deliverable.
In practice this is the one I trust most for messy local work: renaming and reorganizing files, driving an old Windows desktop tool that has no API, cobbling together a report from three apps that don’t talk to each other. It’s not the fastest on pure web tasks — a DOM-native agent will out-click it there — but for “operate my computer” in the literal sense, it’s the most broadly capable.
ServiceNow Project Arc — the governed enterprise play
This is the May 2026 news. At Knowledge 2026, Jensen Huang and Bill McDermott introduced Project Arc, a long-running, self-evolving autonomous desktop agent that lives on an employee’s machine, thinks, writes and runs code, and adapts when things go sideways — no pre-built workflows. It’s in early preview.
What makes Arc interesting isn’t the agent, it’s the cage around it. Every action runs inside NVIDIA OpenShell, an open-source sandboxed runtime where the enterprise defines what the agent can see, which tools it can touch, and how each action is contained. ServiceNow AI Control Tower sits on top, setting policy, monitoring behavior, and logging every file read, command executed, and API called. That’s the actual product: an autonomous desktop agent a security team can audit and sign off on. For a regulated shop, the governance is the feature and the autonomy is the commodity.
Manus — the autonomy maximalist
Manus is the one that’ll keep going for 30 to 60 minutes, pivot around obstacles, and hand back a finished artifact while you do something else. Its Wide Research mode fans out 100-plus parallel agents for big data-gathering jobs, which genuinely has no clean equivalent elsewhere.
The catch is cost and predictability. A single wide-research run can burn 4,000 to 10,000 credits, and the Extended plan runs $200/month for 40,000 credits. It’s a power-user and small-team tool — thrilling when it lands the artifact, expensive when it spins. (Pricing and credit math shift often, so check the current plan before you budget around it.)
The one axis that actually decides it: where does your work live?
Forget the leaderboard. Ask where the task happens.
In a browser, every time. Filling forms, navigating dashboards, structured scraping, repetitive web errands. Gemini Computer Use for the reliable stuff; Operator if you just want it bundled with ChatGPT and don’t want to wire anything up. I lean Gemini when reliability matters and Operator when convenience does.
On the desktop — local files, native apps, legacy tools. This is Claude’s lane. The OS-agnostic screenshot approach is the whole point: it doesn’t care whether the app has an API or shipped in 2009. Cowork for the no-code version, the Computer Use API if you’re building.
Long, autonomous, fan-out research jobs for an individual or small team. Manus, with your eyes open about credits.
A governed enterprise rollout across many employee desktops. Project Arc. Not because the agent is necessarily smarter, but because OpenShell sandboxing and AI Control Tower audit trails are what let security actually approve the thing. A raw Computer Use API gives you the capability; it doesn’t give you the control plane your CISO will demand.
If you only remember one sentence: browser → Gemini, desktop → Claude, governed enterprise → Arc, max autonomy → Manus, lowest friction → Operator.
The reliability conversation nobody wants to have
Here’s the part the demo videos skip. Computer-use agents are still meaningfully unreliable on real work.
The shared yardstick is OSWorld-Verified, and it’s worth knowing what it does and doesn’t tell you. Headline scores compress enormous task-category variance into one number. An agent that’s great at file operations might be mediocre at form-filling; another flips it. So the benchmark ranking rarely matches your ranking, because your workload isn’t the benchmark’s average.
Screen-scraping agents — the pixel-based ones — still break on dynamic UIs. A modal pops up, a layout reflows, an element loads half a second late, and the agent clicks empty space. DOM-native agents dodge a lot of that on the web but can’t help you off it. None of them recover from failure the way a person does; they tend to either retry the same wrong action or quietly drift off task. Plan for it. The right unit of trust in 2026 is “agent does the first 80%, human checks before anything ships,” not “agent does the job.”
So before you commit, run a pilot on your ten most common real tasks and measure the success rate yourself. The vendor’s number is about their tasks. You care about yours.
Governance and the runaway-action problem
An agent that can click anything can also click the wrong thing — delete the file, send the email, submit the order. The cost of a mistake is no longer a bad sentence; it’s a real action against a real system.
The pattern the serious players have converged on is two-tier tool classification: low-risk actions run automatically, high-risk actions halt and wait for a human to approve or reject. Claude and OpenAI both expose this natively in their tool-use APIs, and you should use it — don’t let an agent submit payments or delete records without a gate.
For consumer use on your own machine, that human-in-the-loop gate plus a bit of common sense is usually enough. For enterprise, it isn’t, and that’s exactly the gap Project Arc is selling into: VM-level sandboxing so the agent can’t touch what it shouldn’t, plus an audit log of every action for after-the-fact review. If you’re rolling agents out to hundreds of desktops, the governance layer isn’t a nice-to-have, it’s the entire reason the project gets approved. The capability has been available for a while; the control plane is the new product.
Cost and lock-in, briefly
The pricing models don’t line up, which makes apples-to-apples hard:
- Operator comes inside ChatGPT tiers — cheapest to start, least granular control.
- Claude bills via the API for builders, or per-seat for Cowork — pay for what you build or per user.
- Gemini runs through Google’s API and ecosystem pricing.
- Manus is credit-metered, and heavy runs add up fast.
- Project Arc is enterprise platform licensing through ServiceNow — you’re buying the governed platform, not a per-call agent.
Lock-in tracks scope. A browser agent is relatively swappable. A governed enterprise desktop platform with policies and audit pipelines built around it is not — switching later means rebuilding the control plane, so choose that one for the long haul.
What I’d actually do
If you’re just curious, open Operator inside ChatGPT and give it a web errand — lowest effort, decent first impression. If your real pain is browser drudgery, pilot Gemini Computer Use and measure the success rate on your own tasks. If it’s local files and crusty desktop apps, Claude Cowork is the one I’d hand the messy stuff to first. And if you’re scoping a rollout where security has a veto, the question isn’t which agent is smartest — it’s whether you can audit every action it takes, which is the bet Project Arc is making.
Pick one workflow you do too often, run an agent at it for a week, and count how many times you had to step in. That number tells you more than any benchmark — and it’s the number that decides whether this category is ready for your work yet.
Sources: NVIDIA Blog — ServiceNow autonomous agents, ServiceNow Newsroom — Project Arc, The New Stack — NVIDIA OpenShell runtime, Anthropic — Claude Cowork, digitalapplied — Computer Use Agents 2026, Manus — Introducing Wide Research.