A paper posted to arXiv on 14 July reports that EvoCUA-1.5, a computer-use agent trained with online reinforcement learning, achieves 63.2% success on the OSWorld-Verified benchmark [S1]. That number matters because it comes from a model in the 32B/35B parameter class outperforming comparable open-weight baselines and approaching models far larger than itself [S1]. The gap between those two facts — modest size, strong results — is where the real story hides.

From watching to doing

Computer-use agents are AI models that operate a graphical desktop the way a human does: reading the screen, moving the cursor, clicking buttons, typing text. The original EvoCUA, published in January 2026 by researchers at Meituan, learned these skills the way most agents do — from static, pre-generated examples [P3][P4]. The agent watched demonstrations and imitated them. Its GitHub repository, now at 332 stars under the meituan/EvoCUA namespace, shipped under an Apache 2.0 licence [P2].

The problem with learning from examples is that it plateaus. The original paper's own abstract acknowledged this: the field is held back by the difficulty of scaling static training data, and existing approaches depend on agents merely copying human demonstrations rather than learning through their own attempts [P4]. You can only feed an agent so many recordings of humans clicking through spreadsheets before the returns flatten. The agent never discovers what works through its own trial and error.

EvoCUA-1.5 changes the training method. Instead of learning offline from canned examples, the agent interacts with executable sandbox environments — real, runnable computer desktops where it attempts tasks and receives verifiable feedback on whether it succeeded [S1]. Think of it as the difference between reading a cookbook and actually cooking the meal. You burn the eggs once. You adjust the heat. You try again.

The three pieces that make it work

The paper introduces several technical components designed to make online RL stable enough to actually improve the agent rather than degrading it.

The first is Step-Level Policy Optimization, or STEPO. Reinforcement learning traditionally scores an entire sequence of actions — a full trajectory — as one unit. STEPO breaks that trajectory into individual steps while preserving the balance of advantages across the whole sequence [S1]. In plain terms: the agent learns which specific clicks and keystrokes helped, not just whether the overall attempt worked.

The second is a task-generation and filtering system. The agent trains on synthesised tasks that have verifiable outcomes — you can check whether the file was created, whether the email was sent. Policy-aware filtering and pass-rate calibration weed out tasks that are too easy, too hard, or poorly defined [S1].

The third is the Dynamic Tri-Adaptive Curriculum, or DTAC. This controls which tasks the agent sees during training by mixing three categories: tasks the agent can actually learn from, difficult tasks it previously succeeded at (replayed to reinforce them), and a controlled dose of tasks that are currently infeasible — too hard to solve, but useful for exposing the agent to harder territory without overwhelming it [S1]. It is a curriculum that shifts as the agent improves.

Underneath all of this sits a fully asynchronous RL infrastructure with staleness control and mini-group batching [S1]. Training an agent that interacts with live computer environments is slow and messy — each task takes real time to execute. The asynchronous design lets the system keep training without waiting for every sandbox interaction to finish.

The authors report that experiments confirm these components improve both training stability and downstream task performance [S1].

What it means

The core shift here is from imitation to experience. Most computer-use agents today are trained on recordings of human activity — click logs, screen captures, step-by-step tutorials. That approach produces agents that can handle familiar patterns but break when something unexpected happens, because they have never had to recover from their own mistakes.

Online reinforcement learning changes the feedback loop. The agent attempts a task in a sandbox, fails, gets a signal that it failed, and adjusts. Over thousands of iterations, it builds something closer to genuine skill than pattern-matching. The 63.2% score on OSWorld-Verified — a curated subset of the OSWorld benchmark, which tests agents on real desktop tasks like editing documents, managing files, and navigating applications — suggests the approach works [S1].

The parameter-count comparison is the other half of why this matters. The authors claim EvoCUA-1.5 outperforms comparable 32B/35B-scale open-weight baselines and approaches models with significantly larger parameter counts [S1]. If a 32B-class agent trained through online RL can get close to what much bigger models achieve, that changes the economics of building computer-use agents. Smaller models are cheaper to run — inference costs scale with parameter count — and cheaper to host.

The field is moving from controlled lab tests toward messier, real-world execution. Online RL is the training method that matches that ambition.

What it means for business

A two-person automation firm that builds workflows for clients — say, scraping insurance portals or filling out compliance forms — feels this first. Today, if an agent fails mid-task, the workflow breaks and a human intervenes. An agent trained through online RL has practised recovering from failure thousands of times in a sandbox. That does not make it perfect, but it changes the failure rate in a way that matters for production use.

The cost picture matters too. If a 32B-class model can approach the performance of something much larger, the inference bill drops. For a suburban agency running agents on cloud infrastructure, that is the difference between a workflow that costs cents per run and one that costs dollars.

There is a catch, though, and it is an honest one. The paper does not disclose training compute, data sources, or whether model weights or code for version 1.5 will be released [S1]. The original EvoCUA repository is public under Apache 2.0 [P2], but whether 1.5 follows the same path is unknown. A business cannot plan around a model it cannot run.

What we don't know yet

Several things remain unverified. The 63.2% figure applies to OSWorld-Verified specifically, not the full OSWorld benchmark — conflating the two would overstate results [S1]. The baseline comparisons cite unnamed "comparable" models and "significantly larger" parameter counts without specifying which models or how large [S1]. The paper is a single-source preprint; all performance and technical claims are author-reported and have not been independently reproduced.

The model's own parameter count is not stated in the evidence we have. We know it outperforms 32B/35B-scale baselines, but we do not know whether EvoCUA-1.5 itself is a 32B model or something else entirely [S1].

What would answer these questions: independent reproduction of the 63.2% result on OSWorld-Verified by a third party, public release of the trained weights, and named baseline comparisons with exact model identifiers. The Meituan EvoCUA GitHub repository [P2] is the natural place to watch for code or weight releases. The arXiv paper page [S1] is where any revised versions with additional detail would appear.

If you want to follow where computer-use agents are heading, this is the thread to watch. Subscribe to keep reading the research that actually moves the needle.

Sources

More from Not A Tech Guy

Generated from an audited evidence pack with primary-source research. Social-media items are discussion signals, not verified facts. Nothing here is financial, legal or medical advice.