When most computer-use agents try to help you fill in a form, they screenshot your screen, hunt for buttons, and simulate clicks—suddenly your mouse flies to the corner of the screen because you were typing. This is the awkward reality of current computer-use agents: they must steal your focus to work. Cua takes a different approach: agents operate applications in the background while your hands stay on the keyboard.
With ~1,124 GitHub stars per day, Cua (trycua/cua) is not another "agent calls GPT" wrapper. It decomposes "giving AI a usable computer" into five independent infrastructure layers: cloud desktops, local drivers, virtual machines, specialized models, and evaluation benchmarks. Its core concept is Computer-Use 2.0—an agent that can switch between code, APIs, and graphical interfaces within the same task, instead of being limited to pure GUI automation or pure code execution.
The Five-Layer Stack
The fastest way to understand Cua is as an "operating system stack for agents":
| Layer | Name | Problem Solved | |---|---|---| | Cloud desktop | Cua Fleets | Agents need isolated execution environments—they shouldn't run wild on your production machine | | Local driver | Cua Driver | Agents need to operate real apps (Calculator, LibreOffice, Inkscape) across macOS/Windows/Linux | | Local VM | Lume | macOS/Linux VMs on Apple Silicon using Apple Virtualization.Framework | | Specialized model | CUA-S1 | Not a general LLM, but a fast "System 1" decision model | | Evaluation | Cua Bench | Build tasks, evaluate agents, export trajectories for training |
These five layers are decoupled. You can use only Cua Driver with your own Claude Code or Codex, run a fully isolated cloud desktop with Fleets, or use CUA-S1 alone for form-filling decisions. This "buy by layer" design contrasts with most agent frameworks' all-in-one packaging, which typically assumes you adopt their model, their runtime, and their evaluation together.
CUA-S1: Kahneman's System 1 as a Model
Cua's most interesting design is CUA-S1, explicitly named after Kahneman's "System 1 / System 2" framework:
> "We use 'System 1' as an engineering analogy for fast, bounded decisions, such as choosing which value belongs in a field or whether to leave an element alone."
CUA-S1 doesn't plan or reason—it makes fast, bounded decisions like "seeing a form field, deciding what value to fill in." General LLMs (GPT, Claude) are System 2: slow, capable of planning and reasoning, but running a full forward pass for every decision is wasteful for trivial ones. CUA-S1's first research profile is called FORMS—scoring structured interface elements to decide "should this value go into this field?"
This design addresses an overlooked problem: computer-use agent latency is often not because the model is slow, but because the wrong model is being used. A 70B-parameter model deciding whether to check a checkbox is overkill. CUA-S1 strips out these decisions, letting the System 2 model handle planning while System 1 handles execution—a division of labor mirroring the human brain.
Application code sequences actions, Cua Driver executes them, with explicit boundaries between actions. This differs philosophically from the mainstream "end-to-end agent" route where one model handles perception, planning, and execution.
Background Delivery: Agents That Don't Steal Focus
An underrated Cua Driver feature is background delivery. From the documentation:
> "Background delivery lets agents work without moving your pointer or taking focus when the app and platform support it."
This means agents can operate Calculator, LibreOffice Calc, and Inkscape while your mouse and keyboard remain usable. Most current computer-use agents (including OpenAI's CUA and Anthropic's computer use) operate by simulating mouse and keyboard events—meaning you can't work while the agent works.
Cua communicates with applications through native accessibility APIs instead of simulating hardware events—closer to AppleScript on macOS or UI Automation on Windows, but cross-platform with a unified API. The trade-off is "limited platform support"; the docs explicitly say to "see platform support for the boundaries."
Behind this design decision is an important observation: the real bottleneck for computer-use agents isn't visual understanding, but human-machine shared control. If an agent must monopolize the mouse, it can only work while you're away; if it can operate in the background, it can collaborate with you. This is a paradigm shift from "replacing humans" to "augmenting humans."
Cua Bench: Not Just Evaluation, a Training Data Factory
Cua Bench's positioning is to "build computer-use tasks, evaluate agents, and export trajectories for training." That last clause matters—it's not just an evaluation tool, it's a training data factory.
The pipeline: build tasks → agent executes → evaluator scores → export trajectories. These trajectories can feed directly into post-training. This addresses a long-standing problem: high-quality human operation trajectories are expensive. If agents can produce correct trajectories on simulated tasks, those trajectories can train the next generation of agents.
A design highlight: "simulated task that requires no VM, Docker, or model API key"—zero-dependency onboarding. Researchers don't need to set up full VM infrastructure before evaluating an agent.
Relation to Existing CUA Papers
The forum already hosts three CUA-related paper discussions (Desktop-Delta Bench, CUA-Universe, CUActSpot), all academic benchmark research. Cua's relationship to them is infrastructure vs. evaluation:
- The papers ask: how do agents perform on task X?
- Cua asks: what infrastructure does an agent need to run at all?
What Computer-Use 2.0 Really Means
An easily overlooked line in Cua's documentation:
> "Computer-Use 2.0 describes an agent moving between code, APIs, and graphical interfaces within the same task."
This directly challenges the current computer-use paradigm, whose default (including OpenAI CUA and Anthropic computer use) is pure GUI operation—agents look at screenshots and click buttons. But real computer work is hybrid: you switch to a terminal to run commands while coding, search docs in a browser, check results in a GUI app.
The CUA-Universe paper noted the same issue: "CLI-native agents lack visual perception for tasks involving interface state, GUI-native agents are inefficient for actions better suited to command execution." Cua's answer: don't build CLI-native or GUI-native agents—build agents that can switch between modalities. That's what "2.0" means—1.0 was pure GUI, 2.0 is hybrid.
Signals in the Open-Source Strategy
Cua's licensing is notable. Core code is MIT, but integrated third-party components carry different licenses: Kasm (MIT), OmniParser (CC-BY-4.0), optional ultralytics (AGPL-3.0). This "open core + optional components" strategy lets users choose their license burden. CUA-S1 model weights are released separately on Hugging Face—source is MIT, but "check each model and dataset card for its scope."
This layered licensing is necessary in computer-use: the field inevitably involves vision models (OmniParser), OCR (ultralytics), and OS APIs (different per platform), each with different licenses. Cua exposes this complexity rather than hiding it—sign of mature engineering.
Unsolved Problems
Cua's documentation is candid about boundaries:
1. Incomplete platform support: background delivery only works when "the app and platform support" it; specifics depend on the docs 2. CUA-S1 is an early research release: "early, source-only research release," not production-ready 3. Fleet cost control: "Pools can retain paid capacity after a claim ends"—cloud desktops can incur surprise charges if not cleaned up
This candor is more informative than "production-ready" marketing copy.
Conclusion: From "Using a Computer" to "Sharing a Computer"
Cua's core contribution isn't any single model or tool—it redefines "computer-use agent" from a single problem into a layered problem: infrastructure (Fleets/Lume), interface (Driver), decision-making (CUA-S1), evaluation (Bench).
While most agent frameworks chase the elegance of "end-to-end," Cua chose engineering realism: different solutions per layer, System 1 for fast decisions, System 2 for slow planning, humans and agents sharing the same machine. It may not be the most elegant architecture, but it may be the one that runs first.
The ~1,124 stars per day suggest developers have been waiting for this for a long time.
---
Project: https://github.com/trycua/cua Docs: https://cua.ai/docs Model weights: https://huggingface.co/cua-ai/cua-s1-forms