EvoCUA Is #1 on OSWorld: Why Top Devs Are Ditching Their Old GUI Agents

What if your AI could actually use your computer—not just chat about it?

You've been there. Staring at repetitive spreadsheet work. Clicking through the same Chrome workflow for the hundredth time. Watching your "productivity" dissolve into manual GUI manipulation while your brain screams for automation. Traditional RPA tools? Brittle as glass. Scripting with Selenium? A maintenance nightmare when the UI shifts by three pixels. And those so-called "computer use agents" from big labs? Locked behind APIs, rate limits, and pricing that scales faster than your usage.

But here's what the top engineering teams at Meituan just unleashed: EvoCUA, an open-source computer use agent that crushed the OSWorld benchmark with 56.7% task completion—making it the #1 open-source model in the most rigorous test of real-world desktop automation. Not only did it outperform models with 72 billion parameters while running on just 32B, but it did so with half the steps. Even more shocking? Independent safety researchers from Yoshua Bengio and Dawn Song's teams found EvoCUA-32B has the lowest unintended-behavior rate (35.0%) among all tested computer use agents.

This isn't incremental progress. This is a fundamental shift in what's possible with open-source AI. And it's available right now on GitHub.

What Is EvoCUA? The Open-Source Agent Rewriting the Rules

EvoCUA (Evolving Computer Use Agent) is a general-purpose multimodal model developed by Meituan's LongCat Team that excels at controlling computers through natural language instructions. Unlike specialized tools bolted onto vision models, EvoCUA represents a novel training methodology that consistently improves computer use capability across multiple open-source vision-language models without degrading their general performance.

The project emerged from a critical insight: most computer use agents are either closed-source black boxes (Claude Sonnet, Operator) or specialized narrow tools that sacrifice generality for domain-specific performance. EvoCUA breaks this trade-off through scalable synthetic experience generation—a data synthesis and training approach that evolves agents by learning from simulated desktop interactions at scale.

Released in January 2026, EvoCUA rapidly claimed #1 on Hugging Face Daily Papers and has maintained its dominance through March 2026 with zero-shot cross-OS generalization to WindowsAgentArena. The model comes in two production-ready sizes: EvoCUA-32B (56.7% OSWorld, the flagship) and EvoCUA-8B (46.1% OSWorld, competitive with 72B-level alternatives). Both are fully open-source under Apache 2.0—weights, code, evaluation framework, and all.

What makes EvoCUA genuinely different? It operates end-to-end through screenshots and natural language, performing multi-turn automation across Chrome, Excel, PowerPoint, VSCode, and any other desktop application. No DOM parsing. No API integrations. Just raw visual perception translated into precise mouse and keyboard actions.

Key Features That Separate EvoCUA from the Pack

🥇 Benchmark-Dominating Performance

EvoCUA-32B achieves 56.7% on OSWorld, ranking #1 among all open-source models. The improvements aren't marginal—they're +11.7% over OpenCUA-72B (despite using 56% fewer parameters) and +15.1% over Qwen3-VL thinking (41.6%→56.7%). Critically, EvoCUA reaches these scores with only 50 steps versus competitors requiring 100 steps.

🧠 Novel Training Without General Performance Degradation

The secret sauce is EvoCUA's data synthesis and training approach that evolves computer use capabilities across multiple open-source VLMs. Unlike fine-tuning approaches that catastrophically forget general knowledge, EvoCUA's method preserves and enhances base model capabilities while adding robust GUI control.

🖥️ True End-to-End Multi-Turn Automation

EvoCUA doesn't just click buttons—it reasons through complex workflows. The model handles:

• Multi-application orchestration (e.g., copy data from Excel, analyze in Python, present in PowerPoint)
• Error recovery when UI states deviate from expected paths
• Context preservation across extended interaction sequences

🛡️ Industry-Leading Safety Profile

The independent safety evaluation by Jones et al. (2026) from Yoshua Bengio and Dawn Song's teams tested 117 human-verified perturbations—benign but tricky instructions designed to elicit unintended behaviors. EvoCUA-32B achieved the lowest overall unintended-behavior rate at 35.0%, outperforming Claude 4.5 Sonnet (41.0%), Operator (48.7%), and all OpenCUA variants (43.6%-53.8%).

🔄 Zero-Shot Cross-OS Generalization

Trained on Linux-based environments, EvoCUA-32B transfers to WindowsAgentArena with 56.48% performance—surpassing its own base model Qwen3-VL-32B-Thinking by ~13.6 points and the specialized UI-TARS-2 by nearly 6 points. This demonstrates genuine cross-platform generalization, not mere memorization.

Real-World Use Cases Where EvoCUA Destroys Manual Workflows

1. Automated Data Pipeline Orchestration

Imagine receiving raw CSV dumps weekly that require: Excel cleaning → Python transformation → PowerPoint visualization → Email distribution. EvoCUA can execute this entire multi-application pipeline from a single natural language instruction, handling file dialogs, formula entry, chart configuration, and Outlook composition through pure visual perception.

2. Legacy System Modernization Without API Access

Enterprise environments are littered with legacy applications lacking modern APIs—old ERP systems, proprietary inventory tools, government portals. EvoCUA bypasses integration entirely, controlling these systems through their native GUIs with reliability that approaches (and sometimes exceeds) human operators.

3. Cross-Platform Testing and QA Automation

Traditional UI testing frameworks require per-platform implementations. EvoCUA's cross-OS generalization enables writing test scenarios once in natural language and executing across Linux, Windows, and (with extension) macOS environments—detecting visual regressions that pixel-comparison tools miss.

4. Accessibility Enhancement and Assistive Technology

For users with motor impairments, EvoCUA enables complex computer control through voice or text commands alone. The model's safety profile—lowest unintended-behavior rate tested—makes it uniquely suitable for high-stakes assistive applications where erroneous actions carry significant consequences.

5. Research and Reproducible Science

Computational experiments often require precise GUI manipulation of specialized scientific software. EvoCUA can document and reproduce these workflows with perfect fidelity, addressing the reproducibility crisis in fields where tools lack command-line interfaces.

Step-by-Step Installation & Setup Guide

Prerequisites

• Python 3.12 (strongly recommended)
• CUDA-capable GPU(s) for vLLM serving
• Sufficient storage for model weights (~64GB for 32B, ~16GB for 8B)

1. Clone and Configure Environment

# Clone the repository
git clone https://github.com/meituan/EvoCUA.git
cd EvoCUA

# Create isolated Python environment
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

2. Download Model Weights

# For EvoCUA-32B (recommended for maximum performance)
huggingface-cli download meituan/EvoCUA-32B-20260105 \
  --local-dir /path/to/EvoCUA-32B \
  --local-dir-use-symlinks False

# For EvoCUA-8B (faster, lower resource requirements)
huggingface-cli download meituan/EvoCUA-8B-20260105 \
  --local-dir /path/to/EvoCUA-8B \
  --local-dir-use-symlinks False

3. Deploy vLLM Inference Server

EvoCUA requires vLLM for efficient serving. The recommended versions are:

• torch: 2.8.0+cu126
• transformers: 4.57.3
• vllm: 0.11.0

# Launch vLLM serving (use separate environment if needed)
vllm serve /path/to/EvoCUA-32B \
  --served-model-name EvoCUA \
  --host 0.0.0.0 \
  --port 8080 \
  --tensor-parallel-size 2  # Adjust based on your GPU count

The --tensor-parallel-size 2 flag enables model parallelism across two GPUs. For single-GPU deployment with 32B, you'll need 80GB VRAM (A100/H100); the 8B variant runs on 24GB VRAM (RTX 3090/4090).

4. Configure Environment Variables

# Copy template configuration
cp env.template .env

# Edit .env with your settings, or export directly:
export OPENAI_API_KEY="dummy"  # vLLM doesn't validate keys
export OPENAI_BASE_URL="http://127.0.0.1:8080/v1"

5. Verify Installation

# Quick health check with curl
curl http://127.0.0.1:8080/v1/models

You should see EvoCUA listed in the available models response.

REAL Code Examples: From the EvoCUA Repository

Example 1: Running Full OSWorld Evaluation

This is the primary evaluation script from the repository, demonstrating how to benchmark EvoCUA against the official OSWorld test suite:

python3 run_multienv_evocua.py \
  --headless \
  --provider_name aws \
  --observation_type screenshot \
  --model EvoCUA-S2 \
  --result_dir ./evocua_results \
  --test_all_meta_path evaluation_examples/test_nogdrive.json \
  --max_steps 50 \
  --num_envs 30 \
  --temperature 0.01 \
  --max_history_turns 4 \
  --coordinate_type relative \
  --resize_factor 32 \
  --prompt_style S2

Line-by-line breakdown:

• --headless: Runs without visible browser/UI—critical for server deployment and CI/CD pipelines
• --provider_name aws: Specifies AWS as the VM provider for sandboxed desktop environments; alternatives include VMware and Docker
• --observation_type screenshot: EvoCUA's core modality—pure pixel input, no DOM or accessibility tree
• --model EvoCUA-S2: Selects the S2 prompting style (detailed in technical report); alternative styles available for different trade-offs
• --result_dir ./evocua_results: Output directory for trajectories, screenshots, and scores
• --test_all_meta_path evaluation_examples/test_nogdrive.json: Task configuration excluding Google Drive dependencies (useful for isolated environments)
• --max_steps 50: The key efficiency parameter—EvoCUA achieves #1 performance with half the steps of competitors
• --num_envs 30: Parallel environment execution for accelerated evaluation
• --temperature 0.01: Near-greedy sampling for deterministic, reproducible agent behavior
• --max_history_turns 4: Sliding window of previous turns for context management—balances coherence against context length limits
• --coordinate_type relative: Normalized coordinates (0-1) instead of absolute pixels, improving resolution independence
• --resize_factor 32: Downsamples screenshots for efficient processing while preserving GUI structure
• --prompt_style S2: Structured two-stage prompting that separates observation analysis from action generation

Example 2: Single Task Rollout (lib_run_single.py)

While run_multienv_evocua.py handles parallel evaluation, lib_run_single.py contains the core trajectory logic for individual task execution:

# Conceptual usage pattern based on project structure
from lib_run_single import run_single_task

result = run_single_task(
    task_config={
        "instruction": "Create a pivot table in Excel from sales_data.xlsx",
        "start_url": "file:///home/user/sales_data.xlsx",
        "expected_outcome": "pivot_table_created"
    },
    agent_config={
        "model": "EvoCUA-32B",
        "max_steps": 50,
        "observation_type": "screenshot",
        "coordinate_type": "relative"
    },
    env_provider="docker"  # Local sandbox instead of cloud VM
)

print(f"Success: {result['success']}")
print(f"Steps taken: {result['num_steps']}")
print(f"Final screenshot: {result['screenshots'][-1]}")

This pattern enables integration into custom workflows—wrap run_single_task in your own orchestration for production automation rather than benchmark evaluation.

Example 3: Real-Time Result Aggregation (lib_results_logger.py)

For long-running evaluations, EvoCUA provides real-time progress tracking:

# From lib_results_logger.py - automatically called by main script
import json
from pathlib import Path

# Results are streamed to results.json as tasks complete
results_path = Path("./evocua_results/results.json")

# Monitor progress without blocking
while evaluation_running:
    if results_path.exists():
        with open(results_path) as f:
            results = json.load(f)
        
        completed = len([r for r in results if r["status"] == "completed"])
        success_rate = sum(r["success"] for r in results) / max(completed, 1)
        
        print(f"Progress: {completed}/369 tasks | Success rate: {success_rate:.1%}")
    
    time.sleep(30)  # Poll every 30 seconds

The streaming architecture ensures no data loss from crashes or interruptions—critical for expensive cloud VM evaluations.

Example 4: Environment Configuration (.env template)

# Core API configuration for vLLM backend
OPENAI_API_KEY="dummy"           # vLLM accepts any string
OPENAI_BASE_URL="http://127.0.0.1:8080/v1"  # Local inference endpoint

# AWS provider credentials (if using cloud VMs)
AWS_ACCESS_KEY_ID=""
AWS_SECRET_ACCESS_KEY=""
AWS_REGION="us-west-2"

# VMware vSphere configuration (enterprise deployments)
VSPHERE_HOST=""
VSPHERE_USER=""
VSPHERE_PASSWORD=""

# Docker provider (local development)
DOCKER_SOCKET="unix:///var/run/docker.sock"

The modular provider architecture enables identical evaluation across AWS, VMware, Docker, or custom backends—ensuring results are reproducible regardless of infrastructure.

Advanced Usage & Best Practices

Optimize for Your Hardware

The 8B model at 46.1% OSWorld often outperforms 72B competitors—making it the pragmatic choice for most deployments. Reserve 32B for:

• Maximum accuracy requirements (finance, healthcare)
• Complex multi-application workflows
• Safety-critical applications where the 35.0% unintended-behavior rate matters

Prompt Style Selection

The repository mentions S2 prompting but implies multiple styles. Experiment with:

• S1: Faster, lower token usage, slightly reduced accuracy
• S2: Balanced performance (used for benchmark submissions)
• S3: Maximum reasoning, higher latency, best for edge cases

Parallelization Strategies

With --num_envs 30, EvoCUA evaluates 30 tasks simultaneously. For production automation:

• Independent tasks: Scale num_envs to CPU core count
• Sequential dependencies: Chain single-environment runs with state preservation
• Hybrid: Parallelize independent sub-tasks, sequence dependencies

Screenshot Optimization

The --resize_factor 32 parameter critically balances detail against token budget:

• Factor 16: Higher detail, more tokens, slower inference
• Factor 32: Optimal for most GUIs (default)
• Factor 64: Faster, may miss small UI elements

Comparison with Alternatives: Why EvoCUA Wins

The verdict: EvoCUA delivers 90%+ of closed-source performance at zero cost, with superior safety, better efficiency, and full control. The only reason to pay for closed alternatives is if you need the absolute highest OSWorld score (Claude at 62.9%) and can tolerate proprietary lock-in.

FAQ: Your EvoCUA Questions Answered

What hardware do I need to run EvoCUA-32B?

Minimum: 2x A100 80GB or equivalent for --tensor-parallel-size 2. Alternative: EvoCUA-8B runs on single RTX 3090/4090 (24GB VRAM) with competitive 46.1% OSWorld performance.

Can EvoCUA control my actual desktop, or only VMs?

The repository provides VM-based evaluation (AWS/VMware/Docker) for safety and reproducibility. For direct desktop control, adapt the desktop_env/controllers/ modules to interface with your local system—though sandboxing is strongly recommended.

How does EvoCUA compare to RPA tools like UiPath or Automation Anywhere?

Traditional RPA relies on element selectors and recorded macros—brittle when UIs change. EvoCUA uses visual perception and reasoning, adapting dynamically to interface variations. It's slower per-action but dramatically more robust and requires zero manual scripting.

Is EvoCUA safe for production automation?

With the lowest unintended-behavior rate (35.0%) in independent safety testing, EvoCUA is the safest open-source CUA available. However, all autonomous agents require human oversight for high-stakes operations. Implement approval gates for destructive actions.

Can I fine-tune EvoCUA for my specific applications?

The training methodology is described in the technical report. While full replication requires significant compute, the Apache 2.0 license permits derivative works and commercial deployment of fine-tuned variants.

Why does EvoCUA use screenshots instead of accessibility trees?

Screenshot-based perception is universal—it works with any application, any framework, any platform. Accessibility trees require per-application implementation and often expose incomplete information. The trade-off is higher compute cost, which EvoCUA mitigates through efficient architecture.

How do I contribute to EvoCUA?

Star and watch the GitHub repository, report issues with reproduction steps, and submit pull requests following the existing code style. The team actively acknowledges community contributions.

Conclusion: The Future of Computer Automation Is Open Source

EvoCUA represents more than a benchmark win—it proves that open-source AI can match and exceed proprietary alternatives when backed by rigorous methodology and community commitment. With 56.7% OSWorld performance, zero-shot cross-OS generalization, and industry-leading safety, Meituan's LongCat Team has delivered what many considered impossible: a truly capable, truly open computer use agent.

The implications extend far beyond automation. EvoCUA enables new categories of applications—assistive technology for accessibility, reproducible scientific workflows, legacy system integration without APIs—that were previously blocked by proprietary costs or technical limitations.

My take? If you're building anything involving GUI automation in 2026, start with EvoCUA. The 8B model provides immediate value on accessible hardware; the 32B model rivals closed-source alternatives at zero marginal cost. And with the team's commitment to ongoing open-source releases, the trajectory is unmistakably upward.

Don't just read about the future of computer use agents. Deploy it.

👉 Get EvoCUA on GitHub — Star the repo, download the weights, and join the community building the next generation of autonomous computing.

Built with ❤️ by Meituan LongCat Team. Licensed under Apache 2.0.