OpenGCUA: Alibaba Shows the Harness Beats the Model on Computer Use

TL;DR

On 15 October 2026, Tongyi-MAI (Alibaba) released OpenGCUA, an open harness in which the model writes GUI operations as code and decides for itself when to look at the screen. Same weights, eight frontier models, OSWorld-v2’s offline subset: the mean partial score goes from 45.3 to 64.9 (+19.6 points), steps per task drop 53.0% and output tokens fall 27.2% (Source : arXiv — OpenGCUA: Toward a Fully Open Stack for Generalist Computer Use).
The gains scale inversely with model quality: GLM-5.3-Flash +35.2, DeepSeek-V4.1-Flash +29.8, GPT-6 Astra +8.7. The spread between the best and worst model collapses from 39.1 points to 18.
The price axis is the one that matters now: Qwen3.8-Flash reaches 60.5 at ~$0.38 per task, GPT-6 Astra peaks at 75.7 for ~$15.26 — 40× the cost for 15.2 points (Source : arXiv — OpenGCUA, §3.3.6).
A companion paper, MAI-Gym, turns the same lab’s evaluation stack into an open RL gym: 10 benchmarks, 20,000 parallel environments, and a 9B model trained to 78.4% on MobileWorld / 76.2% on OSWorld-Verified — ahead of Claude Opus 4.8 (69.2%) and GPT-5.5 (62.4%) on MobileWorld (Source : arXiv — MAI-Gym).

Introduction

The vocabulary of computer use shifted in 2026 without much ceremony. A “GUI agent” clicked and typed from screenshots. What OpenAI shipped with GPT-6 Astra, and what Anthropic ships in Claude Cowork, does something broader: it picks between the screen, the shell, the accessibility tree and a service API, task by task. Tongyi-MAI formalises this as a generalist computer-use agent (GCUA) — a system whose model decides what to observe, how to act, and how to organise its work at each step.

The problem with that definition is that nobody could test it. GPT-6 Astra’s harness, prompts, trajectories and device SDK are closed, so the community could watch demos but not reproduce a single design decision. OpenGCUA’s contribution is not a model — the first release ships no trained checkpoint — but the missing instrument: an open implementation, its prompts, the evaluation trajectories of all eight frontier models, plus a preliminary real-device harness and a cross-device SDK spanning computers, browsers and phones.

Code execution is not shell access

The headline +19.6 points conflates two mechanisms that the ablations carefully separate. Code execution lets a model write a program where pyautogui.click() coexists with a shell command and Python logic, so intermediate results decide the next operation without another model call. Against plain batched GUI actions, that alone is worth +15.5 to +33.6 points and 55.3% to 63.1% fewer steps.

More interesting is the comparison against a GUI+CLI hybrid that already has the same interfaces and already runs shell scripts. There, code execution still adds +6.1 points on average and cuts steps 14.8%. Qwen3.8-Max climbs from 57.2 to 64.0 with 13.8% fewer steps; GLM-5.3-Flash from 55.8 to 64.9. Access to an interface and control over execution are two different things: a batch fixes the action sequence in advance, a program can loop, branch and retry.

The second mechanism — harness-to-model decision transfer — moves rules out of the harness and into the model. On-demand screenshots raise KV-cache hit rates from 75.6% to 86.1% (Qwen3.8-Max) and 61.9% to 76.3% (DeepSeek-V4.1-Flash) without losing score. A todo interface buys +1.6 and +1.8 points. The failure case is instructive: micro-compaction, the usual trick of replacing old tool outputs with placeholders, destroyed the prefix cache (75.6% → 68.6%). Context hygiene that looks free in tokens is expensive in cache.

The floor rises; the ranking barely moves

All eight models improved, which means the harness is infrastructure rather than a differentiator. Compressing a 39-point spread into 18 is good news for anyone running cheap models and bad news for anyone selling a benchmark lead: one third of it can be recovered by writing a different agent loop.

Real devices restore the ordering. On four macOS tasks run through the same harness, GPT-6 Astra uses 34.5 steps and 12.9K output tokens for $18.29 and 4/4 completions; Qwen3.8-Max needs 50.8 steps and 73.4K tokens for $1.49 and 3/4 — 19.4× the reasoning tokens (50.2K versus 2.6K) on the same machine. Gemini 3.8 Flash completes only 2/4 but at $0.66, and Qwen3.8-Flash does the same for $0.12.

The case studies explain the residue. On a 125-question workbook, GPT-6 Astra wrote a reusable solver, validated it against seven supplied examples and confirmed it covered every question; Qwen3.8-Max wrote functions and loops too, but processed fixed row ranges covering 85 questions and left 40 cells empty — its own program printed the count and it never checked. Code execution does not manufacture completeness discipline. It only gives a capable model a better instrument.

MAI-Gym: the infrastructure is the release

The companion paper attacks the other half of the problem: benchmarks ship hundreds of hand-written tasks, while online RL with verifiable rewards consumes thousands. MAI-Gym serves ten benchmarks through a single environment manager that has run 20,000 instances in parallel, with 1,000 fresh instances initialised in 328.4 seconds on mobile and 88.9 seconds on computer. Evaluation and training share one rollout path, which removes a subtle bug class: measure with a different harness than you train with and you are grading a different agent.

The recipe produces MAI-Gym-9B: 78.4% MobileWorld, 76.2% OSWorld-Verified, ahead of UI-Venus-2-9B (75.2/70.8) and of the much larger GUI-Owl-1.5-32B (43.9/56.5). Training used 512 GPUs for roughly 96 hours with a peak of 20,000 concurrent environments. Joint training on mobile and computer beat merging two domain experts (78.4/76.2 versus best merges of 76.4 and 74.8), and scaling synthesised tasks from 500 to 5,000 added 9.2 and 6.5 points on benchmarks whose tasks never appear in training.

The transfer result deserves the caveats it comes with. RL in a clone of a ticketing app lifted clone success from 36.5% to 73.1% and real-app success on a physical phone from 28.8% to 48.1% — a real +19.2 points, but the clone-to-real gap widened from 7.7 to 25.0 points. Simulated environments teach transferable skills, not the environment.

What operators should take from this

Three practical consequences. First, stop comparing benchmark numbers across vendors unless the harness is named: the same weights move by up to 35 points on harness design alone, so a “state of the art” claim is a claim about an agent loop. Second, the economics of escalation have changed — below one dollar per task a 9B-class policy now holds the workflow, and frontier models should be reserved for the tasks where their completeness discipline actually pays. Third, report steps, tokens, latency and dollars separately. OpenGCUA is explicit that fewer steps do not imply fewer tokens: GPT-6 Astra cuts steps 67.2% while spending the same output budget.

The gap the papers leave open is the one that matters for deployment: none of this measures a machine shared with its user for six hours, with notifications, background windows and a half-written document.

FAQ

What exactly is a GCUA, and how is it different from a GUI agent? A generalist computer-use agent is defined by three per-step decisions the model makes: what to observe, how to act (screenshot, accessibility tree, shell, API) and how to organise the work. A GUI-only agent fixes the first two by construction. A GUI+CLI hybrid fixes the coordination order in advance. The GCUA framing makes those choices measurable.

Do I need a new model to use OpenGCUA? No. The harness works with existing models through their APIs — that is the point of the eight-model evaluation. The first release ships no trained checkpoint, only the implementation, prompts, trajectories, a preliminary real-device harness and a cross-device SDK.

Is MAI-Gym-9B a drop-in GUI agent today? The checkpoint, framework, 49 mocked apps and 2,000 verified tasks are released. Read the numbers carefully: MobileWorld and OSWorld-Verified environments appear in training, though their benchmark tasks do not. The scores measure generalisation to new tasks inside familiar environments, not free transfer to your desktop.

Why do steps fall 53% while tokens only fall 27%? Because the two measure different things. Fewer round trips cuts orchestration overhead and latency; output volume is dominated by reasoning. GPT-6 Astra reduces steps by 67.2% with roughly unchanged tokens, while Claude Opus 5 drops from 378.3K to 89.3K output tokens per task. End-to-end latency has to be measured separately.

What is the single most useful number in the two papers? The cost frontier: 60.5 points at $0.38 per task versus 75.7 at $15.26. It reframes computer use as a routing problem — cheap policy by default, frontier model on escalation — rather than a model-shopping problem.