CUA: The Open-Source Computer-Use Agent Infrastructure That’s Replacing RPA Scripts — Complete Guide for Agentic AI Architects (2026)

A UiPath bot breaks because someone moved a button three pixels to the left. A Blue Prism workflow fails because the target app pushed a minor UI update over the weekend. A Power Automate desktop flow stalls on a new consent dialog that didn’t exist when the flow was recorded.

If you’ve spent any time in enterprise RPA, you’ve lived this loop: build, deploy, babysit, rebuild. The fundamental problem isn’t the tools — it’s the paradigm. Traditional RPA records fixed coordinates, fixed element selectors, and fixed sequences. The moment the UI changes, the script shatters.

Computer-use agents (CUAs) take a different approach entirely. Instead of following a recorded script, an AI agent looks at the screen, reasons about what it sees, and decides what to click, type, or scroll — the same way a human operator would. And the open-source project leading this infrastructure shift is CUA (trycua/cua): a MIT-licensed platform that gives AI agents full desktop environments across macOS, Linux, Windows, and Android, complete with sandboxing, benchmarking, and an MCP-native SDK.

With roughly 29,000 GitHub stars, backing from Y Combinator (X25 batch), and a release cadence that ships multiple updates per week, CUA has become the default substrate for teams building production computer-use agents in 2026. This guide breaks down what it is, how it works, why it matters for RPA and automation teams, and how to evaluate it against the proprietary alternatives from Anthropic, OpenAI, Google, and the traditional RPA vendors.

What Is CUA and Why Should RPA Teams Care?

CUA — short for Computer Use Agents — is open-source infrastructure that gives AI agents full, sandboxed desktop environments they can operate. It is not an agent itself. It’s the substrate: the virtual machines, the drivers, the SDKs, and the benchmarks that let you plug in any vision-capable language model (Claude, GPT-4o, Gemini, open-weight models like UI-TARS) and have it control a real operating system.

Think of it this way: if Anthropic’s Computer Use API is the engine, CUA is the chassis, wheels, and test track. You bring the engine; CUA provides everything else needed to put it on the road.

For RPA teams, this distinction matters enormously. Traditional RPA platforms bundle the runtime, the recorder, the orchestrator, and the execution environment into a single licensed product. CUA unbundles the execution environment and makes it open, composable, and model-agnostic — meaning your automation isn’t locked to one vendor’s AI capabilities or pricing structure.

The Core Problem CUA Solves

Enterprise desktops are messy. Legacy ERP systems, thick-client insurance applications, government portals built in the early 2000s, CAD tools, healthcare record systems — these applications have no APIs, no webhooks, and no integration layer. The only interface is the screen.

Traditional RPA handles this with pixel-matching, selector-based automation, and recorded click sequences. It works — until it doesn’t. According to industry analyses of RPA platform deployments, maintenance overhead from UI changes is one of the largest hidden costs of enterprise RPA programs.

Computer-use agents solve this by replacing brittle selectors with vision-based reasoning. The agent receives a screenshot, interprets the UI elements using a vision-language model, and decides on the next action. When a button moves or a dialog changes, the agent adapts — because it’s reading the screen the way a human does, not following a hardcoded path.

CUA provides the infrastructure to run these agents safely: isolated virtual machines so the agent can’t damage the host, cross-platform drivers so the same code works on macOS, Windows, and Linux, and benchmarking tools so you can measure how well your agent actually performs before deploying it to production.

CUA Architecture: The Five-Layer Stack

CUA is not a single tool — it’s a modular stack with five distinct components, each solving a different part of the computer-use problem. Understanding the architecture is critical for evaluating where CUA fits in your automation strategy.

1. Cua Sandbox — Isolated Desktop Environments

The Sandbox SDK provides a single Python API for launching ephemeral desktop environments across Linux, macOS, Windows, and Android. A typical invocation looks like this:

from cua import Sandbox, Image

async with Sandbox.ephemeral(Image.linux()) as box:
    await box.shell.run("apt-get install -y firefox")
    screenshot = await box.screenshot()
    await box.mouse.click(x=500, y=300)
    await box.keyboard.type("search query")

Key architectural decisions in the Sandbox layer:

• Ephemeral by default: Every run starts from a clean image, ensuring reproducibility. This is critical for benchmarking and for production deployments where you need deterministic starting states.
• BYOI (Bring Your Own Image): You can supply custom .qcow2 or .iso images — essential for enterprise teams that need to test against their actual desktop environment, not a generic Linux install.
• Cross-OS from one API: The same mouse.click, keyboard.type, and screenshot methods work whether the sandbox is running Ubuntu, macOS Sequoia, or Windows 11.
• Near-native performance: On Apple Silicon, macOS VMs run via Apple’s Virtualization.Framework at up to 97% native CPU speed according to the project’s benchmarks. Linux and Windows run via QEMU on any host.

The sandbox daemon (cua-spacesd) runs inside each virtual environment on port 3211, exposing process management, filesystem access, desktop control, and screen streaming over gRPC. This is the communication bridge between your agent code and the virtual desktop.

2. Cua Driver — Background Desktop Automation

While the Sandbox runs agents in isolated VMs, the Driver takes a fundamentally different approach: it runs agents on the user’s actual machine, in the background, without taking over the mouse cursor or window focus.

This is CUA’s most distinctive capability. Traditional RPA tools like UiPath’s attended robots seize control of the desktop — you can’t use your computer while the bot runs. CUA Driver operates in the background by reading accessibility trees, intercepting screen buffers, and injecting input events at the system level without moving the visible pointer.

The Driver ships as:

• A CLI for scripting and automation pipelines
• An MCP server for integration with Claude Code, Cursor, Codex, and other MCP-compatible tools (a direct connection to the Model Context Protocol ecosystem)
• Typed SDKs in Python, TypeScript, Swift, and Kotlin

The Driver also records sessions as replayable trajectories — structured logs of every screenshot, action, and outcome — which feed directly into Cua Bench for evaluation and into training pipelines for fine-tuning custom models.

3. Lume — Lightweight VM Management

Lume is the virtual machine layer underneath the Sandbox. Originally the founding project of the company (before the broader CUA vision took shape), Lume is a CLI that creates and manages macOS and Linux VMs on Apple Silicon using Apple’s Virtualization.Framework.

For RPA architects evaluating CUA, Lume matters because it determines deployment topology. You can run Lume locally (a developer testing agents on their laptop), on dedicated Mac hardware in a data center (an RPA Center of Excellence running agent fleets), or through CUA’s cloud offering on AWS, Google Cloud, or Modal (teams that want managed infrastructure).

4. CuaBot — Multi-Player Computer Use

Launched at ClawCon San Francisco in February 2026 (which drew 700+ in-person attendees and 20,000 livestream viewers), CuaBot introduced what the team calls “multi-player computer use.” It runs coding agents — Claude Code, OpenClaw, and others — inside sandboxed desktops, with the desktop stream visible to the human operator via H.265 video, shared clipboard, and audio.

The multi-player aspect means both the human and the agent have cursors on the same desktop simultaneously. The human can watch, intervene, take over, and hand back control. This maps directly to the “human-in-the-loop” pattern that enterprise automation teams require for compliance-sensitive workflows — a pattern that Forrester’s Q3 2026 Adaptive Process Orchestration Wave identified as a key differentiator for mature automation platforms.

5. Cua Bench — Evaluation and Training Infrastructure

You can’t improve what you can’t measure. Cua Bench provides a standardized harness for evaluating computer-use agents across established benchmarks:

• OSWorld: The de facto benchmark for desktop agent tasks, where state-of-the-art models currently achieve 30–50% accuracy (compared to a human baseline of approximately 72%)
• ScreenSpot: Visual grounding accuracy — can the model correctly identify which UI element to interact with?
• Windows Arena: Multi-step Windows desktop tasks
• Custom task definitions: Define your own evaluation scenarios for domain-specific testing

Cua Bench supports parallel execution (--max-parallel 4) for running evaluations at scale, and exports trajectories in a structured format suitable for fine-tuning or reinforcement learning. This is the bridge between “we built an agent” and “we know how well our agent actually works” — a gap that most enterprise RPA deployments never close.

CUA vs. the Competitive Landscape: Where Does It Fit?

The computer-use agent space has exploded in 2026, with offerings from frontier labs, startups, and traditional RPA vendors all converging on the same problem. Here’s how CUA stacks up.

CUA vs. Anthropic Computer Use API

Anthropic’s Claude Computer Use API provides a model capability: Claude sees a screenshot, returns the next mouse/keyboard action, and your code executes it. It is the engine without a car.

CUA provides the car. In practice, most teams building with Anthropic’s Computer Use API end up needing exactly what CUA offers: sandboxed environments, cross-platform drivers, trajectory recording, and evaluation tooling. The two are complementary, not competitive. You run Claude’s Computer Use inside a CUA Sandbox, with Cua Bench measuring accuracy, and the Cua Driver handling background execution on production machines.

CUA vs. OpenAI ChatGPT Agent (Operator)

OpenAI folded its Operator product into the broader ChatGPT Agent offering — a hosted cloud VM with browser, terminal, and file access. It’s powerful for consumer and knowledge-worker tasks, but it runs entirely in OpenAI’s cloud. You can’t deploy it on-premises, can’t connect it to internal applications behind a firewall, and can’t customize the execution environment.

For enterprise RPA teams, this is a dealbreaker. The applications you need to automate — SAP, Epic, Oracle E-Business Suite, in-house legacy systems — aren’t accessible from a datacenter VM with a public IP. CUA runs locally or in your own cloud account, with full network access to your internal environment. OpenAI’s approach works well for personal productivity tasks (as explored in the OpenAI DevDay 2026 coverage); CUA works for enterprise process automation.

CUA vs. Google Mariner / Gemini Computer Use

Google’s Mariner and the broader Gemini enterprise agent platform remain primarily browser-scoped. For organizations whose automation targets are web applications, Mariner is compelling. For desktop automation — which represents the bulk of legacy enterprise RPA workloads — it’s out of scope. CUA covers both web (via browser instances inside sandboxes) and native desktop applications.

CUA vs. Traditional RPA (UiPath, Automation Anywhere, Blue Prism)

This is the comparison that matters most for this site’s audience. Here’s the honest assessment:

Dimension	Traditional RPA	CUA + Vision Model
Resilience to UI changes	Breaks on selector/coordinate changes; requires manual maintenance	Adapts via vision reasoning; self-heals for minor UI drift
Development speed	Point-and-click recorders; fast for simple flows	Requires prompt engineering and model selection; steeper initial curve
Cost per execution	Low marginal cost once built (license fees aside)	Higher: each step sends a screenshot through an LLM (token-heavy)
Determinism	High — same inputs produce same outputs every time	Lower — LLM reasoning introduces variability; requires guardrails
Audit trail	Mature; meets SOX/HIPAA requirements out of the box	Trajectory recording provides raw data; compliance tooling is emerging
Maintenance overhead	High — UI changes require workflow updates	Low — agent adapts; retraining needed only for major redesigns
Vendor lock-in	High — proprietary runtimes, licensing, orchestrators	Low — MIT license, model-agnostic, self-hostable
Legacy app coverage	Excellent for apps with stable UIs	Excellent for apps with dynamic UIs; may struggle with pixel-perfect precision tasks

The honest verdict: CUA + a vision model is not a wholesale replacement for traditional RPA today. It’s a complement that excels where RPA struggles — dynamic UIs, cross-application workflows that span unintegrated systems, and scenarios where maintenance costs exceed development costs. The smart architecture is a hybrid: deterministic RPA for stable, high-volume, precision-critical processes; computer-use agents for everything that traditional bots keep breaking on.

CUA vs. Other Open-Source CUA Infrastructure

CUA isn’t the only open-source player. Here’s how it compares to the closest alternatives:

• Browser-Use (~14K+ stars): MIT-licensed, built on Playwright, excellent for web-only automation. If your targets are all web applications, Browser-Use is lighter and simpler. CUA wins when you need desktop scope — and most enterprise RPA workloads involve at least some thick-client applications.
• E2B Desktop / Daytona: Cloud sandbox competitors. CUA has broader OS coverage (especially macOS, which matters for design, creative, and Mac-first enterprise environments) and the Bench/Driver components that E2B lacks.
• OpenCUA (xlang-ai): A research-focused project with the AgentNet dataset and fine-tuned 7B/32B/72B models that achieve state-of-the-art OSWorld results. OpenCUA is for training and research; CUA is for production infrastructure. They complement each other — you could train a model with OpenCUA’s data and deploy it on CUA’s infrastructure.
• Simular (Agent S/S2): A proprietary startup (ex-DeepMind team) offering a commercial computer-use agent priced at $500/month per seat for enterprise. Closest competitor in terms of ambition, but closed-source and vendor-locked.

How CUA Works: A Practitioner’s Walkthrough

Understanding CUA’s architecture conceptually is one thing. Seeing the actual workflow — from installation to a running agent — reveals where the developer experience stands today.

Installation

CUA provides platform-specific installers:

# macOS / Linux
curl -fsSL https://cua.ai/install.sh | sh

# Windows (PowerShell)
# Separate installer script available from cua.ai

# Python SDK only
pip install cua

# Cua Driver (for background automation on native desktop)
# Separate install script from cua.ai

The full Cua Spaces application (the desktop GUI for managing sandboxes) requires macOS 26 or later. The Python SDK and CLI work on macOS, Linux, and Windows. Lume (VM management) requires Apple Silicon for macOS VMs; Linux VMs run on any host via QEMU.

The Agent Loop: Vision → Reason → Act

At its core, a computer-use agent built on CUA follows a simple loop:

1. Screenshot: Capture the current state of the desktop
2. Send to VLM: Pass the screenshot to a vision-language model with a task description
3. Parse action: The model returns a structured action (click at coordinates, type text, scroll, or “done”)
4. Execute: CUA’s Sandbox or Driver executes the action on the virtual or real desktop
5. Repeat: Take a new screenshot and continue until the task is complete or a step limit is reached

CUA provides a reference cua-agent package that implements a ReAct-style loop as a baseline. Production teams typically customize this with domain-specific guardrails: maximum step counts, action validation (preventing the agent from clicking “Delete” on certain screens), checkpoint-and-rollback logic, and human-in-the-loop escalation triggers.

MCP Integration: The Connector to the Agentic Ecosystem

CUA Driver ships as an MCP server, which means it plugs directly into the Model Context Protocol ecosystem. Practically, this means:

• Claude Code users can add CUA Driver as an MCP tool and have Claude operate their desktop applications from within the coding assistant
• Cursor and Codex users get the same integration via their MCP configurations
• Custom agentic workflows built on MCP-compatible frameworks can incorporate desktop automation as a first-class capability

This MCP-native approach is strategically significant. As the agentic AI ecosystem consolidates around MCP as the standard protocol for tool integration, CUA’s position as an MCP server means desktop automation becomes a composable capability that any MCP-compatible agent can invoke — not a siloed tool requiring its own orchestrator.

The Team and Backing Behind CUA

CUA was founded in March 2025 by Francesco Bonacci (product, previously at Microsoft) and Dillon DuPont (research, also ex-Microsoft, where the two co-authored the Windows Agent Arena benchmark). The company is headquartered in San Francisco with a distributed team spanning Vancouver, Toronto, New York, and New Jersey.

The project was accepted into Y Combinator’s X25 batch and received $500K in seed funding from 468 Capital, Orange Collective, and Script Capital. The original project — Lume, the lightweight VM manager — launched on Hacker News in March 2025 and grew into the broader CUA platform.

Key milestones that demonstrate community traction:

• July 2025: Presented Windows Agent Arena at ICML with Ollama
• September 2025: Sponsored the first Computer-Use Agents track at Hack the North (1,778 participants)
• November 2025: Windows GA, macOS preview, CLI, VLM Router, and Playground shipped in one week; presented at NeurIPS with Ollama
• December 2025: Launched Cua-Bench; hosted hackathon with CodeRabbit and Factory
• February 2026: ClawCon San Francisco (700+ attendees, 20K livestream viewers) — launched CuaBot multi-player computer use
• September 2026: Latest releases include cua-driver-rs v0.28.x with modern MCP support, sandbox v0.7.0 with shared Driver MCP client, and Cua Fleet for managing agent clusters

The release cadence is aggressive — multiple updates per week, with nightly builds available for early adopters. This velocity signals active development but also means production teams should pin versions carefully, as breaking changes are possible between minor releases.

CUA-S1: The Specialized Models

In addition to the infrastructure layer, CUA has begun releasing CUA-S1 — a family of small, specialized models trained for fast, bounded computer-use decisions. The first research profile focuses on form-filling tasks, with weights hosted on Hugging Face.

This is significant for RPA teams evaluating cost. Running GPT-4o or Claude on every screenshot in a long automation workflow gets expensive fast — each step sends a full image through the model. CUA-S1 models are designed for the simple, repetitive decisions (clicking a “Next” button, filling a text field, selecting a dropdown value) where a small specialized model is both faster and cheaper than a frontier model, reserving the expensive model calls for complex reasoning steps.

This tiered-model approach mirrors what mature RPA orchestration looks like: simple rules for simple tasks, complex logic for complex decisions. CUA-S1 brings this pattern to computer-use agents.

Enterprise Considerations: What RPA Teams Need to Evaluate

Before adding CUA to your automation stack, these are the practical questions every RPA architect should work through.

Licensing and Compliance

CUA uses a layered licensing model:

• MIT License: The SDK, CLI, Cua Driver, and Lume — the core components you’d deploy in production
• FSL-1.1-MIT: Cua Spaces (the desktop app) and Cua Driver Bench — source-available, becomes MIT two years after each release ships
• AGPL-3.0: The optional cua-som perception extension and cua-perception — important to evaluate if your legal team has AGPL restrictions

For most enterprise deployments, the MIT-licensed core is what matters. The SDK and Driver can be deployed, modified, and embedded in proprietary systems without copyleft concerns.

Deployment Topology

CUA supports three deployment models:

1. Local development: Developers run Lume and the Sandbox on their laptops (requires Apple Silicon for macOS VMs). Low cost, good for prototyping and testing.
2. Self-hosted infrastructure: Run CUA on dedicated hardware in your data center or private cloud. Cua Fleet manages clusters of agent-running sandboxes. This is the model for enterprise teams with on-premises requirements.
3. CUA Cloud: Managed infrastructure through cua.ai, with deployment to AWS, Google Cloud, or Modal. Usage-based pricing. Fastest path to production for teams without infrastructure expertise.

Security and Isolation

Sandboxing is CUA’s primary security model. Each agent runs in an ephemeral VM that is destroyed after the task completes. The host machine is never exposed to the agent’s actions. For the Driver (which runs on the actual machine), the risk profile is different — the agent can see and interact with real applications, which requires careful access scoping and human oversight.

Teams deploying the Driver in production should implement:

• Application allow-lists (restrict which apps the agent can interact with)
• Action validation layers (prevent destructive actions like “Delete All”)
• Session recording with audit trails (CUA’s trajectory export provides the raw data; you build the compliance wrapper)
• Human-in-the-loop escalation for high-risk actions

Current Limitations

Transparency about limitations is essential for realistic planning:

• macOS VM sandboxes require Apple Silicon. If your enterprise is Windows-only, you’re limited to Linux and Windows sandboxes via QEMU (which works fine, but lacks the Virtualization.Framework performance optimization).
• OSWorld accuracy is still 30–50% for the best models. Human accuracy on the same benchmark is approximately 72%. Computer-use agents are not yet reliable enough for fully unattended, mission-critical processes without guardrails.
• Cost per task is higher than traditional RPA. Each step involves an LLM inference call with an image — expect $0.01–0.10 per step depending on the model. For high-volume processes (thousands of transactions per day), this may not compete with a well-maintained RPA bot.
• The ecosystem is fast-moving. APIs change between releases. Pin your CUA dependency versions and test before upgrading.
• Linux Driver is newer and less mature than macOS. Production deployments on Linux should expect some rough edges.

Where CUA Fits in the 2026 Automation Stack

The most productive way to think about CUA is not as an RPA replacement but as a new layer in the automation stack — one that handles the workflows traditional RPA can’t reach or can’t maintain cost-effectively.

A mature 2026 automation architecture might look like this:

• API integrations for systems with modern APIs (Salesforce, ServiceNow, Workday REST APIs) — cheapest, fastest, most reliable
• Traditional RPA for high-volume, stable-UI processes where determinism matters (invoice processing against a stable SAP GUI, for example)
• Computer-use agents on CUA for dynamic-UI processes, cross-application workflows spanning unintegrated systems, and long-tail automations where the maintenance cost of a traditional RPA bot exceeds the value delivered
• Agentic orchestration tying all three layers together — platforms like Pydantic AI for composable agent architecture, or enterprise orchestrators from UiPath Maestro and Automation Anywhere

CUA’s position as open-source infrastructure — not a competing product — means it integrates into existing stacks rather than replacing them. A UiPath shop can run CUA alongside its existing bots, using CUA for the automations that keep breaking and UiPath for the ones that run reliably. This is pragmatic, not ideological.

Getting Started: A Decision Framework

If you’re evaluating CUA for your organization, here’s a practical decision tree:

1. Start with Cua Bench. Before building anything, benchmark your target model (Claude Computer Use, GPT-4o, UI-TARS-2, or your fine-tuned model) on OSWorld and ScreenSpot. If accuracy on your target task type is below 40%, you need a better model before you need better infrastructure.
2. Prototype with the Sandbox SDK. Build a proof-of-concept for one specific workflow — ideally a process that’s causing the most RPA maintenance pain. Use ephemeral Linux sandboxes (no Apple Silicon required).
3. Evaluate the Driver for attended scenarios. If your use case involves human-in-the-loop workflows (compliance review, exception handling), test the Driver on macOS to see if background operation meets your requirements.
4. Run a cost model. Calculate the per-task cost of the CUA approach (model inference + infrastructure) versus the total cost of ownership of your current RPA solution (licenses + development + maintenance). CUA wins on maintenance-heavy, low-volume processes. Traditional RPA wins on stable, high-volume processes.
5. Evaluate the MCP integration path. If your organization is building an MCP-based agentic infrastructure, CUA Driver as an MCP server fits naturally. If you’re committed to a specific RPA vendor’s orchestration layer, evaluate whether CUA can be invoked from that orchestrator.

What’s Coming Next

Based on the project’s trajectory and public roadmap signals:

• CUA-S1 model expansion: More specialized models for specific task types beyond form-filling — navigation, data extraction, and multi-step reasoning
• Fleet management maturity: Cua Fleet is in early releases (v0.1.x). Expect orchestration features for managing dozens or hundreds of concurrent agent sandboxes
• Enterprise compliance tooling: Trajectory recording provides raw data, but SOC 2 and HIPAA-ready compliance features (immutable audit logs, role-based access, data residency controls) are likely on the roadmap given the project’s enterprise ambitions
• Deeper Windows support: Windows went GA in November 2025, but macOS has received more recent development attention. Expect Windows parity as the enterprise market demands it

FAQs

Is CUA a replacement for UiPath, Automation Anywhere, or Blue Prism?

No — CUA is infrastructure for computer-use agents, not a full RPA platform. It lacks the orchestrator, recorder, credential vault, queue management, and enterprise administration features that RPA platforms provide. It complements RPA by handling workflows that traditional bots can’t maintain cost-effectively, particularly those involving dynamic UIs or cross-application processes without API integrations.

What models work best with CUA?

CUA is model-agnostic. In practice, the best-performing models for computer use tasks in 2026 are Anthropic’s Claude (with Computer Use API) and ByteDance’s UI-TARS-2 (open-weight, approximately 53% on OSWorld-Verified). GPT-4o and Gemini also work. CUA’s own CUA-S1 models are designed for fast, cheap decisions on simple tasks, with frontier models reserved for complex reasoning.

How much does it cost to run CUA in production?

CUA itself is free (MIT license). Costs come from three sources: infrastructure (VMs to run sandboxes — varies by cloud provider), model inference (each screenshot-to-action step costs $0.01–0.10 depending on the model and provider), and development time. For a typical 20-step workflow running 100 times per day with Claude, expect roughly $20–200/day in model inference costs. Compare this to your current RPA license and maintenance costs for the same process.

Can CUA handle multi-application workflows that span SAP, Excel, and a custom web portal?

Yes — this is one of its primary advantages. A CUA sandbox runs a full desktop environment, so the agent can open SAP GUI, switch to Excel, and navigate a browser-based portal within a single session. Traditional RPA does this too, but CUA’s vision-based approach handles the transitions between applications more gracefully when UI layouts change.

Is CUA production-ready for mission-critical processes?

With guardrails, yes — for the right processes. CUA is actively used in production by teams building computer-use agent products. However, the 30–50% accuracy ceiling on general benchmarks means fully unattended, zero-tolerance-for-error processes are not yet viable without human oversight. Use it for attended automation, supervised batch processing, and processes where occasional errors are recoverable.

Key Takeaways

• CUA is infrastructure, not an agent. It provides the sandboxes, drivers, SDKs, and benchmarks that let you build computer-use agents with any vision-capable model. Think of it as “the Kubernetes of desktop automation.”
• ~29K GitHub stars, Y Combinator-backed, MIT-licensed. One of the fastest-growing open-source projects in the agentic AI infrastructure space in 2026, with aggressive release cadence and a growing community.
• Five-layer stack: Sandbox (isolated VMs), Driver (background desktop automation), Lume (VM management), CuaBot (multi-player computer use), and Cua Bench (evaluation and training).
• MCP-native integration connects CUA to the broader agentic AI ecosystem — Claude Code, Cursor, and any MCP-compatible tool can invoke desktop automation through CUA Driver.
• Complements, doesn’t replace, traditional RPA. Best suited for dynamic-UI processes, cross-application workflows, and high-maintenance automations where traditional bots keep breaking. Use alongside UiPath/AA/Blue Prism, not instead of them.
• Current limitations are real: 30–50% OSWorld accuracy, higher cost per task than scripted RPA, Apple Silicon required for macOS sandboxes, and a fast-moving codebase that requires version pinning.
• The hybrid stack is the pragmatic architecture: APIs for integrated systems, traditional RPA for stable high-volume processes, CUA for everything else, tied together by an agentic orchestrator.

References

1. CUA GitHub Repository — github.com/trycua/cua
2. CUA Official Website — cua.ai/about
3. Flowtivity, “Cua: The Open-Source Framework Giving AI Agents Full Computer Access” (June 2026) — flowtivity.ai
4. Simular AI, “The Best Computer Use Agents in 2026” — simular.ai
5. Chakra Labs, “CUA Market Map” — chakra.dev
6. Y Combinator, CUA Company Profile — ycombinator.com
7. CUA GitHub Releases — github.com/trycua/cua/releases
8. Clauday, “trycua/cua — The Computer-Use Stack Goes Open Source” — clauday.com
9. andrew.ooo, “trycua/cua Review: Open-Source Computer-Use Agents” — andrew.ooo
10. Coddykit, “GitHub Trending October 2026” — coddykit.com