One-sentence Summary

Researchers from UNC-Chapel Hill, Microsoft Research, Georgia Tech, and Northeastern University propose WildAWM, an open-source-model pipeline that synthesizes controllable computer-use environments spanning graphical user interfaces, model context protocol services, and command-line interfaces, with execution-based quality gates ensuring solvability, difficulty, and reliable verifiers; the resulting 341 long-horizon tasks can require over 100 agent steps and challenge frontier models such as GPT-6-Astra, which solves only 60%, and Qwen models trained exclusively in these synthetic worlds improve across eight out-of-distribution benchmarks spanning web, claw, and computer-use agents.

Key Contributions

• The paper introduces WildAWM, a scalable pipeline that synthesizes executable personal-computer environments with joint support for graphical user interfaces, model context protocol services, and command-line interfaces, enabling general computer-use agents to combine visual interaction, tool use, and code execution. The pipeline is entirely powered by open-source models and produces 341 long-horizon environment-task pairs that can require over 100 agent steps to solve.
• The paper presents execution-based quality gates for task synthesis that promote solvability, sufficient difficulty, and reliable verifiers by combining heterogeneous agent rollouts, cross-judge consistency checks, and counterfactual probes of judgment robustness. The resulting tasks remain challenging for frontier models, with GPT-6-Astra solving only 60% of them.
• The paper shows that training two Qwen models of different sizes exclusively in these synthetic worlds yields substantial gains across eight out-of-distribution benchmarks spanning web, claw, and computer-use agents, demonstrating broad generalization to unseen computer-use tasks. The code is publicly available.

Introduction

Large language model agents increasingly learn through reinforcement learning in executable environments, making scalable synthetic environments a key bottleneck for training. Computer-use agents must coordinate GUI, CLI, and MCP interactions across applications, websites, and local files, but prior synthesis pipelines often target a single interaction mode or isolated simplified applications, with CUA work frequently centered on GUI interaction. Realistic computer use also requires connected digital workspaces and tasks that are solvable, sufficiently challenging, and paired with reliable verifiers without assuming frontier model correctness. The authors propose WildAWM, a scalable, fully open-source pipeline that constructs executable personal-computer environments with websites, MCP services, and local files, then synthesizes cross-agent interface tasks grounded in those worlds. WildAWM uses execution-based multi-agent quality gates and counterfactual probes to validate task solvability, difficulty, and verifier reliability. The authors synthesize 341 environment-task pairs requiring at least three interface types, train Qwen models exclusively in these synthetic worlds, and report consistent gains across all eight out-of-distribution computer-use benchmarks.

Dataset

The authors construct a synthetic dataset of personal-computer worlds and cross-interface agent tasks grounded in those worlds.

• Sources and composition

  • The base web content comes from 15 mirror websites in WebHarbor, selected for rich visual content.
  • A world is the accumulated state of a personal computer: web applications, MCP-accessible services, and local files that record a person's activities.
  • The authors synthesize personas with occupations, named contacts, frequently used websites, and multi-day activities, then expand them into sequential day plans.
  • A coding agent materializes each day plan on top of the previous world state, creating applications, services, databases, user histories, and files.

• World construction and filtering

  • Day planning is incremental: the generator inspects the previous day's state W(c,d-1) before planning day d.
  • The generator matches activities and required services to a shared library of event skills and application implementations. It creates new skills or MCP services when needed.
  • For each day, the generator writes a deterministic, replayable program that updates databases for MCP services, websites, and local files.
  • A state is retained only when two independent replays produce the same state, services and websites stay healthy, and a separate agent verifies consistency with the day plan.
  • The world artifacts are summarized in Table 2.

• Task synthesis

  • Each XAI task starts from an initial world state W0 = W(c,d) and is grounded in that world's application data, service records, and local files.
  • Tasks must require all three interface types: GUI, MCP, and CLI.
  • The generator produces a task specification, executable verifier, rubric, hint, and ordered sub-task decomposition.
  • The verifier scores N binary checklist criteria over the initial state, final state, and final answer; task success requires all criteria to pass.

• Rollouts and quality control

  • Six rollouts per task are collected, half with hints, from 18 model-harness pairs: GLM-5.2, DeepSeek-V4-Flash, and MiniMax-M3 across OpenCode, Codex, Claude Code, Nanobot, OpenClaw, and Hermes Agent.
  • Rollout judgments use three levels: the generated verifier, an LLM judge, and an agent judge based on OpenCode.
  • Five gates filter tasks: judge consistency, initial unsatisfaction, task solvability, task difficulty, and counterfactual probing.
  • Difficulty is based on unhinted rollouts: k ≤ 1 is hard, k = 2 is medium, and k = 3 is too easy and returned for revision.

• Dataset use

  • Accepted outputs include world states, task specifications, hints, rubrics, sub-task decompositions, rollout trajectories, judgments, and executable verifiers.
  • The authors use the programmatic verifier as the reward function during RL.
  • Individual verifier criteria provide granular feedback and value estimates for long-horizon RL training.
  • Accepted tasks have a mean rollout success rate of 21.3%, an average of 4.2 sub-tasks, 3.1 interface switches, and 74.5% revisit a previously used interface.

Method

The authors leverage open-source models to synthesize executable environments and tasks for training general Computer Use Agents (CUAs). As shown in the figure below, the WildAWM pipeline consists of three main stages: World Synthesis, XAI Task Synthesis, and Online RL for CUA. Each synthesized instance contains a personal-computer environment initialized from a world state $W$W, a task $\tau$τ, and a verifier $V$V that evaluates task completion.

World Synthesis To construct diverse and realistic environments, the authors define a world as the accumulated state of a personal computer comprising web applications, MCP-accessible services, and local files. They first synthesize a persona and expand its ongoing activities into sequential day plans. A coding agent then materializes these plans day by day, extending the previous state to construct applications, services, and user histories. The cumulative state of persona $c$c after day $d$d is denoted as $W(c, d)$W(c,d), which initializes and resets the environment state. To promote diversity, the generator compares each candidate persona with accepted ones in terms of life domain and multi-day storylines. Given a day plan, the generator matches activities against a growing library of reusable event skills and application implementations, synthesizing new skills or implementing missing MCP services as needed. The state is retained only if two independent replays produce the same state and all services remain healthy.

XAI Task Synthesis Beyond environment synthesis, task generation addresses three key challenges: ensuring solvability, maintaining sufficient difficulty, and generating reliable verifiers. The authors address these with an execution-based multi-agent validation loop. Given an initial world state $W_0 = W(c, d)$W0​=W(c,d), a skill-enhanced generator proposes cross-agent interface (XAI) tasks grounded in available application data, service records, and local files. Each task requires the agent to use GUI, MCP, and CLI interfaces. For each proposal, the generator produces a task specification $\tau$τ, an executable verifier $V$V, a rubric $R$R, and a hint $h$h. The verifier evaluates a predefined checklist of $N$N binary criteria, where task success is defined as satisfying all criteria:

$$V(W_0, W, a) = \prod_{i=1}^{N} v_i(W_0, W, a)$$V(W0​,W,a)=i=1∏N​vi​(W0​,W,a)

where $v_i(W_0, W, a) \in \{0, 1\}$vi​(W0​,W,a)∈{0,1}.

To validate tasks, the authors collect six rollouts per task from 18 model-harness pairs and apply three levels of judgment: a programmatic verifier, an LLM judge, and an agent judge. These rollouts and judgments are then evaluated against five quality gates to assess task validity. Refer to the figure below for the progression of XAI task candidates through these gates.

The five quality gates are:

1. Judge Consistency: Requires agreement among the programmatic verifier, LLM judge, and agent judge for all rollouts. Disagreements trigger revisions.
2. Initial Unsatisfaction: Requires $V(W_0, W_0, \emptyset) = 0$V(W0​,W0​,∅)=0, rejecting tasks already complete in the initial state.
3. Task Solvability: Requires at least one successful rollout, with the trajectory using every declared interface.
4. Task Difficulty: Estimates empirical difficulty based on successful rollouts without hints. Tasks are labeled hard, medium, or too easy.
5. Counterfactual Probe: Tests the stability of the agent judge's feedback by presenting it with an incorrect outcome claim to ensure it is not susceptible to sycophancy.

Candidates failing any gate are returned to the generator with diagnostic evidence for revision.

General CUA Training The authors train general CUAs in the synthesized worlds using Group Relative Policy Optimization (GRPO), with the validated verifier providing dense but outcome-based rewards. For a rollout $j$j of task $\tau$τ, let $(W_j, a_j)$(Wj​,aj​) denote its final world state and answer, and let $e_j \in \{0, 1\}$ej​∈{0,1} indicate a policy format failure. The reward is assigned as $r_j = -1$rj​=−1 when $e_j = 1$ej​=1. For $e_j = 0$ej​=0, the reward combines with checklist scores $v$v:

$$r_j = \min \left\{1, V(W_0, W_j, a_j) + \frac{0.1}{N} \sum_{i=1}^{N} v_i(W_0, W_j, a_j) \right\}$$rj​=min{1,V(W0​,Wj​,aj​)+N0.1​i=1∑N​vi​(W0​,Wj​,aj​)}

where $N$N is the number of checklist criteria. Successful tasks receive unit reward, while checklist scores provide partial credit for incomplete trajectories. To address zero-variance reward groups common in small models, the authors maintain an exponential moving estimate of the required rollout multiplier. The trajectory advantage is defined as:

$$A_j = \begin{cases} (r_j - \mu_\tau) / \sigma_\tau, & \sigma_\tau > 0, \\ -K^{-1/2}, & \sigma_\tau = 0 \text{ and } e_j = 1 \forall j, \\ 0, & \text{otherwise}, \end{cases}$$Aj​=⎩⎨⎧​(rj​−μτ​)/στ​,−K−1/2,0,​στ​>0,στ​=0 and ej​=1∀j,otherwise,​

where $\mu_\tau$μτ​ and $\sigma_\tau$στ​ denote the mean and population standard deviation of rewards in a completed rollout pool of size $K$K. The second case provides a format-related learning signal even when all rollouts receive the same format error reward.

Experiment

The experiments train Qwen3.6-35B-A3B and Qwen3.5-4B on 341 WildAWM-synthesized XAI tasks and evaluate generalization on eight unseen web, claw, and computer-use benchmarks. Training improves both model scales across all benchmarks, with larger models gaining more and substantially narrowing the gap to frontier systems. Analysis shows the synthesized tasks are diverse, solvable, challenging, and reliably verified, while all synthesis quality gates contribute, and RL works best after warm-start initialization by adding long-horizon problem solving to cross-interface behaviors learned from teacher trajectories.

The comparison spans single-app, multi-app, and personal-computer scopes, along with modality, interface, synthesis source, synthesis model, and target agent choices. Most related methods specialize in one interface such as GUI, MCP, or CLI and rely on proprietary models for synthesis. WildAWM differs by unifying GUI, MCP, and CLI access in a personal-computer world and by using open-source models for synthesis and verification. Related methods tend to target a single application or a subset of interfaces: GUI-based web and desktop agents, an MCP-only tool-use agent, or CLI-only agents, whereas WildAWM provides joint GUI, MCP, and CLI access. The compared related methods use proprietary synthesis models, while WildAWM is noted for open-source task synthesis and verification, combining WebHarbor’s visual web substrate with synthesized services, files, and application data.

World synthesis produces dozens of personas and hundreds of cumulative world states across a set of websites and MCP services, with many states per persona. The pipeline reuses a large library of skills and records daily activity through database records, local files, and touched services or databases. Final-day activity touches more sites and services than the daily average, and accumulated world states reach tens of MiB. The synthetic environment spans dozens of personas and hundreds of cumulative world states. A large shared library of reusable skills supports multi-day and multi-persona generation. Final-day touched sites and MCP services exceed the daily mean. Generated worlds accumulate large numbers of database records and local files, with final state sizes reaching tens of MiB.

This case study shows an XAI task whose interface flow passes through MCP, CLI, and the web, then returns to CLI and MCP. The solution requires reading a client thread, running a CLI script to merge inventory, BOM, and spec-sheet data, ordering via the web, and writing a restock note and direct message. Because the flow revisits CLI and MCP after the web step, the task cannot be completed in a single interface, and world-changing sub-tasks are checked by deterministic verifier scripts. The task spans multiple sub-tasks across MCP, CLI, and web/GUI, with a flow that revisits CLI and MCP rather than staying within one interface. The CLI sub-task joins three heterogeneous local sources, ranks surge candidates by specs such as outlets, joules, cord length, and trip-indicator presence, and writes a ranked shortlist. World-state-changing sub-tasks are checked by deterministic verifier scripts, and task success requires all verifier scripts to pass.

The synthesized XAI task corpus is dominated by hard tasks, with a much smaller share of medium tasks and relatively low task density per persona and world. Tasks require cross-interface behavior, averaging about three interface switches per task, and synthesis success is measured across a diverse pool of agent configurations. Feedback-driven revisions at multiple quality gates are used to improve task reliability. Hard tasks greatly outnumber medium tasks in the synthesized corpus. Generated tasks require cross-interface interaction, averaging around three interface switches per task. Synthesis rollouts are drawn from a pool of 18 model and harness configurations, with revisions tracked per task at each gate.

WildAWM training improves both evaluated model scales on every out-of-distribution benchmark, spanning web, claw, and computer-use agent tasks. The larger model gains more overall and narrows the gap toward frontier agents, though frontier models still retain the highest average scores. Both the 35B-A3B and 4B models improve across all eight benchmarks, with the larger model gaining about 10.6 points on average versus about 8.2 for the smaller model. The largest gains concentrate across web, claw, and computer-use tasks such as CLE, OSV, WebArena, and CUG, and the 35B-A3B average rises from roughly 43 to 53, closer to but still below frontier performance.

The experiments compare WildAWM with related methods across single-app, multi-app, and personal-computer scopes, and they evaluate world synthesis scale, cross-interface task complexity, corpus composition, and training benefits. WildAWM differs from prior approaches by unifying GUI, MCP, and CLI access in a personal-computer environment and by using open-source models for task synthesis and verification. The generated worlds contain many personas and accumulated states, while the XAI task corpus is dominated by hard tasks requiring multiple interface switches and deterministic verifier checks. Training on WildAWM improves both evaluated model scales across all out-of-distribution web, claw, and computer-use benchmarks, with the larger model narrowing the gap toward frontier agents.