Cua - Open-Source Docker Container for Computer-Use Agents

TL;DR

TL;DR: Cua is an MIT-licensed open-source project from YC W25 that packages the sandbox environment, SDK, and evaluation benchmarks you need to build AI agents capable of controlling full desktop operating systems.

Source and Accuracy Notes

• Project page: cua.ai
• Source repository: github.com/trycua/cua
• License: MIT (verified via GitHub API license.spdx_id)
• HN launch thread: news.ycombinator.com/item?id=43773563
• Source last checked: 2026-07-08 (commit main, pushed 2026-07-07)

What Is Cua?

Cua (pronounced “see-you-ei”) is an open-source infrastructure project for building computer-use agents — AI systems that can autonomously control a full desktop operating system (macOS, Linux, or Windows) using keyboard and mouse inputs, just like a human would.

Backed by Y Combinator (W25 batch), Cua provides four core components:

• Cua — Agent-ready sandboxes for any OS. Pre-configured container environments where agents can safely interact with a desktop without affecting your real system.
• Cua Drivers — Run desktop automation in the background on macOS and Windows (Linux in pre-release). Drives native desktop apps without needing a full VM.
• Cua-Bench — Evaluation benchmarks and reinforcement learning environments for measuring how well your agent performs on real desktop tasks.
• Lume — macOS virtualization layer, purpose-built for running macOS VMs in CI and development workflows.

Setup Workflow

Prerequisites

• Docker installed on your machine
• Git
• Python 3.10+ or Node.js (depending on which SDK you use)
• For Cua Drivers on macOS: macOS 13+ with accessibility permissions granted

Step 1: Install Cua

The quickest way to get started is via the official install script. Open a terminal and run:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/trycua/cua/main/libs/cua-driver/scripts/install.sh)"

This installs the Cua Driver, which handles background computer-use on macOS and Windows.

Step 2: Set Up a Sandbox Environment

Cua sandboxes give your agent a clean, isolated desktop to work in. Clone the repo and use the SDK:

git clone https://github.com/trycua/cua.git
cd cua

Consult the official documentation for your specific OS and use case — the setup flow differs between Cua (container sandboxes), Cua Drivers (native background automation), and Lume (macOS virtualization).

Step 3: Connect to an Agent Framework

Cua can be wired into existing agent frameworks as an MCP (Model Context Protocol) server. For example, to connect Cua Drivers to Claude Code:

# Wire Cua Driver as an MCP server for Claude Code
# See: https://cua.ai/docs for the full configuration steps

Once configured, your agent can control the desktop in the background — opening apps, filling forms, navigating files, and performing any task a human could do with a keyboard and mouse.

Deeper Analysis

Why Cua Exists

The core challenge with computer-use agents is safety and isolation. Letting an AI agent freely control your operating system is powerful but risky — a misbehaving agent could delete files, send emails, or make unauthorized purchases. Cua’s sandbox approach solves this by running the agent in a contained environment that mimics a real desktop without access to your actual data or applications.

The project fills a gap in the current ecosystem: most computer-use frameworks (Anthropic’s Computer Use, OpenAI’s Operator, etc.) are either closed-source, tied to specific cloud platforms, or lack proper benchmarking tools to measure agent performance rigorously.

Architecture Overview

Cua’s architecture has three layers:

1. Execution Layer — Cua Drivers or Lume provides the actual desktop control capability. Cua Drivers work natively on macOS/Windows, using OS-level APIs to simulate input. Lume handles macOS VM provisioning.
2. Sandbox Layer — Cua containers isolate agent execution from the host system. This is where the agent actually runs its tasks.
3. Benchmark Layer — Cua-Bench provides standardized tasks and scoring to evaluate how well an agent completes real desktop workflows.

Performance Considerations

Running a full desktop environment in a container has overhead. Cua’s design trades some latency for safety and reproducibility — each sandbox is a clean snapshot you can reset between tasks. For latency-sensitive workflows, Cua Drivers (which drive the real OS in the background) will outperform full containerized sandboxes.

Practical Evaluation Checklist

• [ ] Install script runs without errors on target OS
• [ ] Sandbox environment boots and is accessible to the agent
• [ ] Agent can open apps and interact with UI elements in the sandbox
• [ ] Agent actions are contained within the sandbox and do not affect host system
• [ ] Cua-Bench tasks run and produce meaningful evaluation metrics
• [ ] MCP server connection to preferred agent framework succeeds

Security Notes

• Cua sandboxes are designed to isolate agent actions from the host system — always verify your sandbox configuration before running untrusted agent code
• Cua Drivers require accessibility permissions on macOS — this grants the agent significant system access within the driver context; follow the principle of least privilege
• For production deployments, run agents in fully virtualized environments (Cua containers + Lume for macOS) rather than relying on Driver-level access

FAQ

Q: How does Cua differ from Browser Use or Notte? A: Browser Use and Notte are specialized for web browser automation. Cua is operating-system-level — it can interact with any application on the desktop, not just browsers. Cua can also drive native macOS and Windows apps directly via Cua Drivers.

Q: Does Cua require a specific LLM backend? A: No. Cua provides the sandbox infrastructure and SDKs. You connect your own agent logic and LLM provider. The MCP server interface makes it framework-agnostic.

Q: Is Cua production-ready? A: Cua is actively maintained (19K+ GitHub stars, active development as of July 2026) but computer-use agent infrastructure is still maturing. Evaluate it for your specific use case — it may be production-ready for narrow, well-defined tasks but should be carefully sandboxed for open-ended workflows.

Q: What is Lume? A: Lume is Cua’s macOS virtualization component. It provisions macOS VMs (using Apple’s Virtualization Framework) for CI/testing scenarios where you need clean macOS environments without dedicated hardware.

Conclusion

Cua is the most comprehensive open-source project for OS-level computer-use agents currently available. Its combination of sandboxed execution, native desktop drivers, benchmarking tools, and macOS virtualization makes it a strong foundation for anyone building desktop automation agents. MIT licensed and framework-agnostic, it integrates into existing workflows via MCP.

If you are evaluating computer-use infrastructure for agentic automation products, Cua deserves a close look. Start with the install script and explore the docs at cua.ai/docs.