OpenGCUA: an Apache-2.0 harness lifts all 8 frontier models it tested on OSWorld-v2 (+19.6 points, −53% steps) — but real-device runs show the model gap it hides

Alibaba's Tongyi-MAI team released OpenGCUA, an Apache-2.0 stack for generalist computer-use agents. All eight frontier models it evaluated — from GPT-6 Astra to DeepSeek-V4.1-Flash — gained a mean 19.6 points of partial score on OSWorld-v2 in the same harness while taking 53% fewer steps per task. The release ships no model weights — just the harness, a cross-device SDK, and full evaluation trajectories — and its own real-device results show why the next release is a model.

What shipped

OpenGCUA ("Open Generalist CUA") is a technical report (arXiv:2610.22200, submitted 15 Oct 2026) plus a GitHub repository under Apache-2.0. The paper defines a generalist computer-use agent (GCUA) as "a system in which the model chooses how to observe, act, and organize its work across visual and programmatic interfaces" — the design pattern it says sits behind GPT-6 Astra's computer-use system, which remains closed.

The repo ships:

• Cross-Device SDK (packages/sdk): one programming interface across macOS, Android, browsers, and Linux, built on a Rust core with Python bindings; every operation is bound to an explicit device, app, window, or tab.
• macOS real-device harness (packages/harness): a terminal agent plus a native menu-bar app ("OpenGCUA for macOS", SwiftUI/AppKit, Apple Silicon, macOS 14+), currently a local development build.
• Reference agents for OSWorld (maiui_agent.py, maiui_code_agent.py) — the OSWorld example README notes it does not include a complete OSWorld evaluation runner.
• Trajectories: all eight models' runs over 108 tasks each — 3,480 attempts including retries — published with SHA256 checksums.
• Interactive lab at tongyi-mai.github.io/OpenGCUA with seven demos, including a side-by-side of four workflows filling in the same visa form.

No weights ship: "The release does not yet include a trained model." The roadmap puts "Weights released" at v0.2, trained with "no distillation from closed models" — own data, self-distillation from larger own models, and openly licensed sources.

The mechanism

Two design moves carry the result.

Code execution as a design primitive. GUI actions are written as Python and combined with accessibility-tree reads, app APIs, and shell commands in a single program with loops, branches, and checks; intermediate results drive what happens next. As the abstract puts it, code execution "lets intermediate results determine subsequent operations and enables models to apply their existing programming capabilities directly to computer interaction."

Harness-to-model decision transfer. Selected observations and task-state decisions move from fixed harness rules to the model. The harness provides the mechanism; the model decides when to use it — requesting a screenshot only when it needs one, rather than after every action.

The README frames this as three per-step decisions the model makes: what to observe (screenshot, accessibility tree, command output, API response, or any combination); how to act (one program versus one click at a time); and how to organize work (the model keeps a todo ledger and states its intent before each program).

Example from the README: on an OSWorld-v2 CRM task, GPT-6 Astra emits an intent line, then a code block that writes a Python script — it asserts the workspace hasn't changed since the original review, loops 29 PATCH calls to the CRM API, asserts each lead's status changed as intended, prints VERIFIED, and updates its todo ledger. All in one model call, where a GUI-only agent would need many steps.

Ablations support the design: writing operations as code adds 6.1 points and cuts steps by 14.8% over a GUI+CLI agent (mean of three models), and on-demand observation alone raises cache hit rates by 10.5 and 14.4 percentage points for two models without lowering task scores.

The numbers

On OpenGCUA's 82-task offline subset of the 108-task OSWorld-v2 benchmark — the long-horizon computer-use benchmark from XLANG Lab at HKU, whose tasks require an average of 318 tool calls (measured with Claude Opus 4.7 at maximum thinking) and 27.25 scoring checkpoints per task — all eight models improve under the full configuration. Mean partial score rises 45.3 → 64.9 (+19.6), steps per task fall 53.0% on average, and the gap between strongest and weakest model shrinks from 39.1 to 18.0 points (trajectories catalog, trajectories page):

Model	GCUA partial	GUI-only baseline	Gain	Steps/task
GPT-6 Astra	75.7	67.1	+8.6	33.5
Claude Opus 5	70.1	60.7	+9.4	61.4
Gemini 3.8 Flash	67.0	50.1	+16.9	101.2
GLM-5.3-Flash	64.9	29.6	+35.3	75.5
Qwen3.8-Max	64.0	46.9	+17.1	57.0
Qwen3.8-Flash	60.5	38.9	+21.6	86.2
Kimi K3	59.2	40.7	+18.5	81.9
DeepSeek-V4.1-Flash	57.7	28.0	+29.7	84.9

The weakest models gain the most: GLM-5.3-Flash goes +35.3 points and DeepSeek-V4.1-Flash +29.7, while GPT-6 Astra — already the strongest — gains only +8.6, with steps dropping from 102 to ~34 per task.

Why it matters

Two claims sit in tension.

On the benchmark, the harness is the biggest lever: the same stack lifts every model and compresses the field. If you are building computer-use agents, harness design — code execution, on-demand observation, model-owned decisions — matters more than which frontier model you pick, at least on OSWorld-v2.

But the paper's own real-device results cut the other way. On four real macOS tasks with the harness held fixed, Qwen3.8-Max used 19.4× as many reported reasoning tokens as GPT-6 Astra (and 5.7× total output tokens), completing 3 of 4 tasks to GPT-6 Astra's 4 of 4. The paper's contribution bullet is blunt: "On real devices, a large gap lies in the model." The gap the harness closes on OSWorld-v2 blows back open when the machine is shared with a user and windows run in the background — challenges the paper says are "unseen in benchmarks."

That tension is why the next release is a trained GCUA model, and why the trajectories ship with SHA256 sums: an open-then-train playbook aimed squarely at closed GPT-6 Astra-class systems.

Caveats

• All OSWorld-v2 numbers are first-party and self-reported; no independent reproduction exists yet. Treat +19.6 as the authors' claim, not an established fact.
• The baseline is the authors' own batched GUI-only reference agent, not each lab's best shipped product. As explainx.ai puts it, the gain is "against the authors' own GUI-only reference, not against each lab's best shipped agent."
• The real-device comparison is four tasks — a demonstration, not a benchmark; the paper lists a real-device benchmark as future work.
• Fewer steps ≠ fewer tokens. Qwen3.8-Flash uses ~5× GPT-6 Astra's output tokens per task while scoring ~15 points lower, and the "reported reasoning tokens" caveat matters because, per the README, GPT-family reasoning is encrypted and only API-reported.
• The harness and SDK are explicitly preliminary; the macOS app is a local development build.
• Naming: don't confuse OpenGCUA with xlang-ai's OpenCUA (NeurIPS 2025). The lab behind OpenCUA, XLANG Lab, also built the OSWorld-v2 benchmark OpenGCUA evaluates on — but the two projects are unrelated.

Sources

• arXiv:2610.22200 — OpenGCUA: Toward a Fully Open Stack for Generalist Computer Use
• arXiv HTML full text
• Hugging Face paper page (author release notes)
• GitHub: Tongyi-MAI/OpenGCUA
• README
• ROADMAP
• OSWorld example README
• Reference agent: maiui_agent.py
• Trajectories page and trajectories catalog.json
• Project page / interactive lab
• arXiv:2606.29537 — OSWorld 2.0
• AI Weekly coverage
• explainx.ai coverage