# CUA-Lite: A Unified Open Platform for Computer-Use Agents That Eliminates Infrastructure Fragmentation
## A New Approach to Building and Benchmarking Computer-Use Agents
A group of researchers based at UC Berkeley has introduced CUA-Lite, an open-source platform designed to streamline how computer-use agents (CUAs) are built, trained, evaluated, and deployed. Rather than focusing on building a larger or more capable model, the team took a step back and asked a foundational question: what if the real bottleneck in CUA development isn’t the model itself, but the scattered infrastructure surrounding it?
Their answer is a platform that consolidates four historically disjointed components — agents, environments, task traces, and training/evaluation frameworks — behind a single action space, a unified data schema, and one command-line interface. The result is a system that spans desktop, browser, and mobile environments, and installs cleanly on any standard Docker host.
## The Infrastructure Problem CUA-Lite Was Built to Solve
In the current landscape, anyone trying to train or benchmark a computer-use agent faces a patchwork of incompatible tools. The agents live in one repository, the environments in another, the task traces in a third, and the evaluation scripts in yet another. Each piece uses its own data format, interface conventions, and setup requirements. This fragmentation makes it difficult to reproduce results, compare agents fairly, or move a model from training to deployment without significant engineering overhead.
CUA-Lite addresses this by creating a common foundation. Every agent, environment, and dataset connects through the same underlying plumbing, meaning a researcher can swap out a model or an environment without rewriting their pipeline.
## Lite.OSWorld: Running Faithful Desktop Tasks Without Virtual Machines
One of the most tangible innovations in the CUA-Lite ecosystem is **Lite.OSWorld**, a sandbox that reproduces the OSWorld task suite inside a plain Docker container rather than inside a full QEMU/KVM virtual machine. The original OSWorld benchmark provides a faithful Ubuntu desktop environment, but it requires nested virtualization — specifically access to `/dev/kvm` — which many cloud providers, CI systems, and container orchestration platforms do not expose.
By moving to a GNOME desktop inside a standard Docker container, Lite.OSWorld removes that requirement entirely. The trade-off was clear: would a container be faithful enough to produce the same scores as the original VM? The team tested this across 13 different models and found that Lite.OSWorld scores match the VM-based OSWorld scores, meaning that training signals and evaluation results transfer directly between the two environments.
### Performance Comparison at a Glance
| Metric | Traditional VM Setup | Lite.OSWorld (Docker) |
|—|—|—|
| Per-task memory footprint | 4.1 GB | 0.9 GB |
| Cold start time | 29.9 seconds | 23.8 seconds |
| Host requirements | Nested virtualization (`/dev/kvm`) | Any Docker host |
| Parallel instance capacity | Baseline | ~4.6× more instances |
| Task suite fidelity | Full OSWorld | Identical task suite |
The memory savings alone are dramatic. At 0.9 GB per desktop compared to 4.1 GB, a single host machine can run many more simultaneous tasks, dramatically improving throughput for large-scale evaluation and training runs.
The broader sandbox family now includes **Lite.ScaleCUA**, **Lite.CUAGym**, and **Lite.CUAWorld**, the last of which extends coverage to roughly 40 applications including Blender, QGIS, and VS Code. Across the entire platform, there are more than 30,000 verifiable tasks available for benchmarking and training.
## LiteSample: One Data Schema for Everything
The second major architectural piece is **LiteSample**, a single supervised-learning data schema that works across every environment, agent type, and task category in the platform. Each sample is stored as a standard parquet file alongside associated images, making it straightforward to load, filter, and process with existing data tools.
The team has already preprocessed ten or more existing CUA datasets into this format and published them freely on Hugging Face, including names like Aguvis, OpenCUA, ScaleCUA, GUI-360, GUIOdyssey, and Multimodal-Mind2Web. Beyond these public corpora, LiteSample also supports freshly generated rollout datasets, where a frontier teacher model is run through the sandboxes to produce traces that can then be used for knowledge distillation into smaller, more efficient student models.
Because different model families require different training scaffolding, CUA-Lite ships a dedicated adapter for each supported model. These adapters take the unified LiteSample format and pack it into whatever structure the target model expects — including collapsing multi-step histories so that several steps can share a single forward pass, reducing compute costs during training.
## One Command for Evaluation, Fine-Tuning, and Reinforcement Learning
At the heart of the platform sits **lite.gym**, a unified interface that takes screenshots as input and returns actions as output. It provides one action space per platform, so a developer working on desktop tasks writes the same kind of action logic whether the underlying environment is Ubuntu, Windows, or a web browser.
More than ten pre-built agents are available out of the box, spanning models from OpenAI, Anthropic, Google, and open-source families including Qwen3-VL, UI-TARS, Fara-7B, and MAI-UI. The platform integrates with 15 or more benchmarks covering four categories:
– **Grounding**: ScreenSpot-Pro, OSWorld-G
– **Desktop**: OSWorld, OSWorld-2, WindowsAgentArena, CUABench
– **Browser**: WebArena, VisualWebArena, MiniWoB, WebVoyager, Online-Mind2Web, WebGym
– **Mobile**: AndroidWorld, AndroidLab, MobileWorld, MobileGym
Switching between models and environments is as simple as changing a couple of flags in a rollout script, keeping the barrier to entry low.
### Training Results
On the supervised fine-tuning side, the repository documents a configuration where Qwen3-VL-2B-Instruct is fine-tuned on desktop trajectories from Lite.ScaleCUA. In the reported setup, mean episode return on the 332-task Lite.OSWorld evaluation split improved from 0.138 at baseline to 0.237 after fine-tuning. This was run on two GPUs using a single documented configuration.
For reinforcement learning, the platform uses GRPO (Group Relative Policy Optimization) on top of the Slime trainer, with rollouts scored directly in the environment providing the reward signal. A worked example covers 416 mobile tasks across 28 applications on MobileGym, demonstrating that the same unified loop serves both evaluation and training.
## Deployment and Accessibility
CUA-Lite installs via `uv sync –all-extras` on Python 3.12. Its lightweight sandboxes run on any Docker host without requiring specialized hardware virtualization support, which means they work on cloud instances, CI runners, and even nested containers. This accessibility is a deliberate design choice — the team wants the platform to be usable by researchers and practitioners regardless of their infrastructure budget.
The project currently ships without an explicit open-source license in the repository, so anyone considering commercial use should verify the terms directly with the maintainers.
—
## Frequently Asked Questions (FAQ)
**What exactly is CUA-Lite?**
CUA-Lite is an open-source platform that unifies the four core pieces of computer-use agent development — agents, environments, task traces, and training/evaluation frameworks — behind a single action space, data schema, and command-line interface.
**Who built it?**
The platform was developed by a research team based at UC Berkeley.
**Why is Lite.OSWorld significant?**
Lite.OSWorld reproduces the OSWorld benchmark task suite inside a Docker container instead of requiring a full virtual machine with nested virtualization. This makes it accessible on virtually any cloud or CI infrastructure while producing scores that match the original VM-based benchmark.
**How much memory does Lite.OSWorld save?**
Each desktop instance uses approximately 0.9 GB of memory in Lite.OSWorld, compared to 4.1 GB for a full QEMU/KVM VM — roughly a 78% reduction.
**Can I use CUA-Lite for commercial purposes?**
The repository does not yet include an explicit license. You should verify the terms with the project maintainers before using it in a commercial product.
**What models are supported?**
The platform includes built-in support for models from GPT, Claude, Gemini, Qwen3-VL, UI-TARS, Fara-7B, MAI-UI, and others. The adapter architecture means additional models can be integrated by implementing a per-model adapter that converts LiteSample data into the target model’s expected format.
**What datasets are available?**
Ten or more datasets have been preprocessed into the LiteSample format and published on Hugging Face, including Aguvis, OpenCUA, ScaleCUA, GUI-360, GUIOdyssey, and Multimodal-Mind2Web. Additional rollout datasets are generated by running teacher models through the sandboxes.
**Does the platform support mobile environments?**
Yes. CUA-Lite includes benchmarks and sandboxes for Android and mobile tasks through AndroidWorld, AndroidLab, MobileWorld, and MobileGym.
**What hardware is needed to run the sandboxes?**
Any machine that can run Docker is sufficient. No GPU passthrough or nested virtualization is required for the container-based sandboxes.
**How do I install it?**
The platform installs with `uv sync –all-extras` on Python 3.12.
—
## Conclusion
CUA-Lite represents a significant shift in how the computer-use agent community thinks about infrastructure. By consolidating fragmented tools into a single, well-documented platform, it lowers the barrier to entry for both research and practical deployment. The Lite.OSWorld sandbox alone removes a major pain point — the need for nested virtualization — while maintaining benchmark fidelity. Combined with the LiteSample data schema, a unified gym interface, and out-of-the-box support for evaluation, fine-tuning, and reinforcement learning, the platform offers an unusually complete toolchain for anyone working on agents that can interact with desktop, browser, or mobile interfaces.
As the project continues to grow its task coverage, agent library, and dataset collection, it has the potential to become a central hub for the broader CUA community. The fact that it is open and accessible on any Docker host means that adoption barriers are minimal.
Thank you for reading
