CUA Review 2026: Open-Source Computer-Use Agent Infrastructure

Verdict

CUA is open-source infrastructure for building computer-use agents, not a finished product. The repository at github.com/trycua/cua shows 22,650 stars and describes sandboxes, SDKs and benchmarks for desktop-controlling AI. The docs describe a framework you assemble, not an agent you switch on. I would rate it 7.5 out of 10 for teams building automation pipelines who want to own the stack. I would skip it if you need a turnkey agent with guaranteed reliability on business-critical actions, because the reliability layer is yours to build.

What is CUA?

CUA is an open-source project from the trycua team. The repository describes it as infrastructure for computer-use agents: sandboxes, SDKs and benchmarks for desktop-controlling AI. That framing matters because the name gets confused with OpenAI's computer-using agent, which is a different thing entirely. OpenAI ships a model and API for GUI automation. CUA ships the scaffolding around that class of model — the sandbox where the agent runs, the SDK you call it from, and the benchmarks you measure it against.

The distinction is practical. If you want a hosted agent that clicks buttons for you, CUA is not that. If you want to run a computer-use model against a controlled desktop environment, capture screenshots, dispatch click and type actions, and score the results, CUA is aimed at exactly that job. The website at cua.ai and the repository both point at the same idea: give developers a repeatable harness for desktop-controlling AI rather than a black box.

The tool block lists pricing starting at $0/mo, which fits an open-source project with no seat fee. There is no subscription tier to compare against a SaaS competitor. You pay for whatever model you route through it, and you pay for the compute that hosts the sandbox. The project itself is free to use under its open-source license.

What the docs describe

The documentation positions CUA around three pieces. First, sandboxes: isolated desktop environments where an agent can move a mouse, type on a keyboard and read the screen without touching your real machine. Second, SDKs: programmatic interfaces for driving those sandboxes and feeding screenshots to a model. Third, benchmarks: a way to score how well a given model performs on computer-use tasks.

That third piece is the one I find most useful as an analyst. Computer-use agents are hard to evaluate because the environment changes under them. A benchmark harness that standardizes the task, the environment and the scoring removes a lot of the noise. The repository shows the project treats benchmarking as a first-class concern rather than an afterthought, which is unusual for this category.

The sandbox piece addresses a real problem. Running a GUI agent on your own desktop is risky. It can delete files, submit forms, or click through a purchase confirmation. A sandbox contains that blast radius. The docs describe the sandbox as the place where the agent operates, which means the safety boundary is architectural rather than prompt-based. That is a stronger design than telling a model in plain language not to do something dangerous.

How computer-use agents work

Any computer-use agent, CUA included, follows the same loop. The agent takes a screenshot of the current screen. A vision-capable model looks at that screenshot and decides on an action. The action is something like click at coordinates, type a string, scroll, or press a key. The environment executes the action. The agent takes a new screenshot and repeats.

This loop has consequences. Every step costs a screenshot, and screenshots are expensive in tokens. A vision model has to encode a full-resolution image to reason about it, and that encoding is billed. A task that takes twenty steps costs twenty screenshots plus the reasoning tokens for each decision. Long tasks get expensive fast, and the cost scales with the number of steps rather than the complexity of the goal.

The loop is also slow. Each step waits for a model response before the next action. A human clicking through a form does it in seconds. An agent doing the same thing pays a round-trip to the model for every click. On a five-step task that is tolerable. On a fifty-step task it is painful, and the probability of a wrong turn compounds with each step.

CUA's contribution is not the loop itself. It is the infrastructure that makes the loop testable and contained. The sandbox gives you a safe place to run it. The SDK gives you a programmatic handle. The benchmarks give you a score. That is the layer most teams underestimate when they start building computer-use agents.

API and integration

The repository and docs describe SDKs for driving the sandbox and dispatching actions. The pattern is consistent with the category: you provide a screenshot or let the SDK capture one, the model returns an action, the SDK executes it in the sandbox. Human-in-the-loop confirmation is a documented pattern, which means you can gate risky actions behind an approval step rather than letting the agent run unattended.

That confirmation pattern is the single most important integration decision for production use. An agent that can submit a form without approval is an agent that can submit the wrong form. An agent that pauses before the submit and asks a human is slower but survivable. The docs describe the confirmation hook as something you wire in, not something that is on by default, so the responsibility sits with the integrator.

Token cost scales with screenshot frequency, as it does for any screenshot-driven agent. If your task requires a screenshot every step, you pay for a screenshot every step. If you can batch actions or reduce the resolution, you pay less. The docs do not promise a magic reduction here, and I would be suspicious of any computer-use framework that did. The cost is structural to the approach.

Integration with existing pipelines is where CUA's open-source nature helps. You can run the sandbox wherever you run your other containers. You can route to whichever vision model you prefer, including the ones in the pricing snapshot below. You are not locked to a single vendor's agent runtime, which matters if you expect to swap models as they improve.

Pricing in 2026

The tool block lists CUA pricing starting at $0/mo. That reflects the open-source model: the project itself carries no license fee and no seat cost. What you actually pay for is the model you route through it and the compute that hosts the sandbox.

Model pricing is where the real cost lives. From the live pricing snapshot, the high end is openai/o1-pro at $150 per million input tokens and $600 per million output tokens, with a batch tier at $75 and $300. Below that sit openai/gpt-5.5-pro at $30 in and $180 out, anthropic/claude-opus-4.7-fast at $30 in and $150 out, and openai/gpt-5.4-pro at $30 in and $180 out. Mid-range options include openai/gpt-5.2-pro at $21 in and $168 out, openai/o3-pro at $20 in and $80 out, and openai/gpt-5-pro at $15 in and $120 out. The cheaper end of the snapshot includes anthropic/claude-opus-4.1 and anthropic/claude-opus-4, both at $15 in and $75 out, and openai/o1 at $15 in and $60 out.

For a screenshot-heavy workload, input tokens dominate because every screenshot is input. A model at $30 per million input tokens is meaningfully cheaper than one at $150 for the same task, and the quality difference may not justify the gap on simple flows. The batch tiers, where available, roughly halve the input cost, which matters if your tasks are not latency-sensitive. openai/gpt-5.5-pro:batch lists $15 in and $90 out, and openai/o1-pro:batch lists $75 in and $300 out.

Sandbox compute is the other line item. The docs describe running agents in isolated environments, which means you are paying for whatever hosts those environments. That cost is not in the tool block and I would not guess at it. It depends entirely on where you deploy and how long the sandbox stays alive.

Pros and cons

Pros

• Open source with a public repository at github.com/trycua/cua, 22,650 stars, and no license fee.
• Sandbox-first design contains the blast radius of a misbehaving agent, which is a stronger safety story than prompt-level guardrails.
• Benchmarks are treated as a first-class part of the project, which helps you compare models on the same tasks rather than guessing.
• SDK-driven integration fits existing pipelines and lets you swap vision models as pricing and quality shift.
• Documented human-in-the-loop confirmation pattern gives you a place to gate risky actions.

Cons

• It is infrastructure, not a finished agent. You build the reliability layer yourself.
• Token cost scales with screenshot frequency, and screenshot-heavy tasks are expensive on any vision model.
• Long unconstrained flows remain fragile across the category, and CUA does not claim to solve that.
• Safety stops and confirmation gates can interrupt real work flows if wired too aggressively.

Alternatives

The comparison that matters most is against browser-use, which targets the same category from a different angle. Browser-use focuses on browser automation specifically, while CUA's sandbox and benchmark framing covers desktop apps as well. If your tasks are all web-based, browser-use is the more direct fit. If you need to drive native desktop software, CUA's sandbox model is closer to the problem. Our browser-use Web UI review covers that side in more detail.

OpenAI's own computer-using agent is the other obvious reference point. It is a hosted model and API rather than a framework, so the trade-off is control versus convenience. You get less to build and less to own. Our OpenAI Codex review covers the coding-agent side of that ecosystem, which overlaps with computer-use work more than it first appears.

Anthropic's computer use offering sits in the same space, and the pricing snapshot shows anthropic/claude-opus-4.7-fast at $30 in and $150 out, which is competitive with the OpenAI mid-range for screenshot-heavy work. If you are already standardized on Claude models, routing CUA's sandbox through them is a reasonable path.

For teams comparing the whole landscape of agentic tooling, our roundup of best agentic AI coding tools puts CUA in context against adjacent categories. Beetlix is our own product, and where it overlaps with CUA it does so at the orchestration layer rather than the sandbox layer, so the two are more complementary than competing.

Who should use CUA

CUA fits teams that want to own their computer-use stack. If you have engineers who can run a sandbox, wire an SDK, and route to a vision model of your choosing, the project gives you a head start on the parts that are tedious to build from scratch. The benchmark harness alone saves time if you plan to evaluate multiple models against the same tasks.

It does not fit teams that want a finished agent. If you need something that logs into a portal and files a report today, with no engineering time, CUA is the wrong layer. You would be better served by a hosted agent product, accepting the loss of control in exchange for not building the reliability layer yourself.

It also does not fit teams with a hard reliability requirement on business-critical actions. The category as a whole is not there yet. An agent that succeeds on a demo task most of the time is not the same as an agent you can trust with a payment or a legal filing. CUA's sandbox and confirmation hooks reduce the risk, but they do not eliminate the need for a human in the loop on anything that cannot be undone.

How this review was researched

This review is based on the vendor documentation at cua.ai, the project repository at github.com/trycua/cua, and the live model pricing data included above. No hands-on testing was performed. Claims about what the project does come from the documentation and repository description. Claims about cost come from the pricing snapshot. Where the documentation does not specify a number, this review describes the tier by name rather than inventing a figure.

FAQ

Is CUA the same as OpenAI's computer-using agent?

No. CUA is open-source infrastructure from the trycua team, described in its repository as sandboxes, SDKs and benchmarks for desktop-controlling AI. OpenAI's computer-using agent is a separate hosted model and API. They operate in the same category but are different products from different organizations.

Does CUA cost anything to use?

The tool block lists pricing starting at $0/mo, reflecting its open-source license. Your real cost is the vision model you route through it and the compute that hosts the sandbox. Model pricing from the live snapshot ranges from $15 per million input tokens at the low end to $150 at the high end, with batch tiers available on some models.

How does CUA compare to browser-use?

Browser-use targets browser automation specifically. CUA's sandbox and benchmark framing covers desktop applications as well as browsers. If your tasks are entirely web-based, browser-use is the more direct fit. If you need to drive native desktop software, CUA's sandbox model is closer to the problem.