OpenGCUA: Alibaba opens the computer-use stack, but the model is not in the box

Facts checked October 17, 2026

On October 15 the MAI-UI team at Alibaba Token Hub posted OpenGCUA, a first release of what they call a fully open stack for generalist computer-use agents. Shipped: harness, preliminary cross-device SDK, prompts, and evaluation trajectories for eight frontier models. Not shipped: a trained model. On their own offline OSWorld-v2 runs, the full configuration raises mean partial score by 19.6 points and cuts steps per task by 53.0%. I read the report, the repository and the LICENSE file. arXiv report

What actually shipped

OpenGCUA is a report plus a repository. The release delivers most of the parts around the model: an evaluation harness, a preliminary real-device harness for a user's own Mac, a preliminary cross-device SDK that binds every operation to an explicit device, application, window or tab, the prompts used in the runs, and the evaluation trajectories of eight frontier models. What it does not deliver yet is a trained model. The report says so itself and puts the model first on the release roadmap.

The definition underneath is the part I would keep. A generalist computer-use agent, in their framing, is not a GUI agent plus shell access. It is a system where the model decides at every step what to observe (screenshot, accessibility tree, command output, API response, or nothing new), how to act (a click, an element operation, a shell command, an API call, or a program combining them), and how to organize its work (the plan, the progress record, which observations stay in context). GUI-only agents, CLI agents and GUI+CLI hybrids like the team's own Qwen-UI-Agent are special cases that fix some of those decisions in advance.

The benchmark numbers, read calmly

The headline result: on the offline set of OSWorld-v2, the full GCUA configuration improved all eight tested models, including GPT-6 Astra and Claude Opus 5, raising mean partial score by 19.6 points and cutting reported steps per task by 53.0% against batched GUI-only execution. The score gap between the strongest and weakest models narrowed by more than half.

Calm caveats. These are the authors' runs, on the authors' harness, on an offline benchmark set, with no independent replication as of today. The offline set is not the online leaderboard. And a harness that lifts every model is a harness result, not evidence about which model is best.

Two design ideas worth stealing

Code execution as the action space. With GUI and shell access held constant, letting the model write GUI operations as code and mix them with programmatic operations added 6.1 points to mean partial score and cut steps per task by 14.8% against the GUI+CLI baseline. The mechanism is not magic: intermediate results steer the next operation without another model call, and models already know how to program. The report's case study identifies five recurring code-execution patterns.

Harness-to-model decision transfer. Most harnesses hard-code rules like taking a screenshot after every step. OpenGCUA hands those decisions to the model: it requests a screenshot only when it needs one, tracks its own task state, and states each program's purpose before running it. On-demand observation alone raised prompt-cache hit rates by 10.5 and 14.4 percentage points for two of the tested models, without lowering task scores. Fewer screenshots is cheaper tokens.

The real-device gap is the honest part

The preliminary real-device harness runs on a user's actual machine, where the agent shares the computer with its owner and acts on background windows, challenges benchmarks do not capture. Holding the harness fixed across four real macOS tasks, selected Qwen3.8-Max runs used 19.4 times as many reported reasoning tokens as GPT-6 Astra and 5.7 times as many output tokens, while completing fewer tasks. The report traces the gap to model behavior: expensive reasoning for simple operations, trouble adapting to real-device conditions, weaker code execution.

Four tasks is a tiny sample, and the word selected is doing work in that sentence. Treat the ratio as a warning light, not a measurement.

License and repository state

The code is Apache-2.0, read from the LICENSE file in the repository, and the README documents a macOS quick start for the source harness plus a local demo studio. The repository is days old: 24 stars and no forks when I checked on October 17. A contributing guide exists. Both the real-device harness and the cross-device SDK are described as preliminary. Repository

Analysis: my read

The durable part of this release is not the score table. It is the two transferable lessons: let the model write programs instead of click batches, and stop forcing observations it did not ask for. Any harness can adopt both this week, and the cache-hit numbers suggest the second pays for itself. The fully-open-stack framing currently describes a stack without its centerpiece, so the honest label is open harness and tooling, model forthcoming. If the trained model lands under the same license, this becomes the reference point for open computer-use research. If it does not, the design lessons still stand.

What I could not confirm

I did not run the harness or the SDK, and I did not audit the released trajectories. The OSWorld-v2 numbers are the offline set on the team's own harness. The real-device token ratios come from four tasks with selected runs. No trained model exists publicly, so every claim about OpenGCUA-the-model is a roadmap claim. The project roadmap and release milestones are intentions, not shipments.

A check you can run

The two headline numbers, 53% fewer steps and higher cache hits, are arithmetic you can apply to your own workload before believing them. The sketch below takes your agent's average steps per task and your provider's cached and uncached input prices, and shows what the paper's claims would mean for cost per task. Replace the numbers with yours.

Illustrative arithmetic, not the team's code

# Illustrative arithmetic from the OpenGCUA report's own claims. Not the team's code.
# Claims (offline OSWorld-v2, 8 models): 53.0% fewer steps per task,
# and on-demand observation raising prompt-cache hits by 10.5-14.4 points for two models.
steps_before = 42          # your agent's average steps per task today - edit
input_tokens_per_step = 6000
cache_read_price = 0.10    # $ per 1M cached input tokens - edit
fresh_input_price = 1.00   # $ per 1M uncached input tokens - edit

steps_after = steps_before * (1 - 0.530)
def cost_per_task(steps, hit_rate):
    per_step = input_tokens_per_step * ((1 - hit_rate) * fresh_input_price + hit_rate * cache_read_price) / 1_000_000
    return steps * per_step
print(f"steps per task: {steps_before:.0f} -> {steps_after:.0f}")
for h in (0.50, 0.50 + 0.144):
    print(f"cache hit {h:.1%}: ${cost_per_task(steps_before, h):.3f} -> ${cost_per_task(steps_after, h):.3f} per task")

Sources and freshness

• arXiv report, October 15
• GitHub repository, Apache-2.0
• Project site