MobileWeave: Program-First Synthesis of Dependency-Linked Tasks for Training Mobile GUI Agents

Ziyi He, Xian Wu, Qiyuan Chen, Haitao Li, Cehao Yang, Yinghao Zhu, Xichen Zhang, Xiao Chen, Yushi Feng, Lequan YuarXiv 2026 · arXiv

TL;DR

MobileWeave introduces a "program-first" approach to training mobile GUI agents by synthesizing tasks as executable programs rather than just free-form text. By explicitly modeling dependencies between subgoals (e.g., using a value from one app to perform an action in another), it teaches agents the crucial skill of multi-step composition, leading to massive performance gains across major mobile benchmarks.

What Problem Does This Paper Address?

Building a reliable mobile GUI agent—an AI that can navigate apps to fulfill user requests—requires a staggering amount of training data. While we can use Large Language Models (LLMs) to synthesize tasks, most current pipelines are "text-first." They prompt an LLM to write a task description (e.g., "Find a meeting time and set an alarm"), but the underlying logic and dependencies between subgoals remain implicit.

This leads to a composition gap: an agent might know how to find a meeting and how to set an alarm individually, but it fails to "weave" them together because it doesn't understand that the alarm time depends on the meeting time found in the previous step. Furthermore, text-first synthesis often produces tasks that are impossible to complete or lack clear success criteria.

Methods

The authors propose MobileWeave, which flips the script by using a "program-first" synthesis pipeline.

  1. Typed Capability Graph: Instead of looking at screenshots, MobileWeave abstracts an app's code into a graph. Nodes represent data types (like "Timestamp" or "Note"), and edges represent "operators" (functions the app can perform).
  2. Program Synthesis: Tasks are constructed as small programs over this graph. "Atomic" programs handle single goals, while "Composite" programs link them using value edges (passing data) and object edges (acting on a created item).
  3. Native Verification: Because these tasks are programs, they can be executed natively in a simulator (MobileGym) to ensure they are actually feasible before a single training trajectory is ever collected.
  4. Loop-Targeted Recovery: To prevent agents from getting stuck in "action loops" (repeatedly clicking the same button), the authors introduce a recovery training stage. When an agent stalls, a teacher model intervenes with a single corrective action to show it how to break the loop.
Figure 1. Text-first vs. program-first task synthesis. Top: exist- ing pipelines prompt an LLM with screens or trajectories to write each task directly as text, leaving the dependencies between its subgoals implicit. Bottom: MobileWeave composes each task as a program over a typed capability graph of app functions, verifies it by native execution, and only then turns it into an instruction with each dependency fixed by the program and enforced by its completion check. Right: success rates (%) of Qwen3-VL-8B and MobileWeave-8B.

Datasets

  • Training: Data was synthesized exclusively within the MobileGym simulator environment, resulting in 822 atomic and 1,376 composite tasks.
  • Evaluation: The models were tested on four benchmarks:
  • MobileGym: To test generalization to new tasks within the same environment (Task OOD).
  • AndroidWorld, AndroidLab, and MobileWorld: To test generalization to entirely different apps and OS environments (Environment OOD).

Key Insights and Ideas

  • Composition is a Learnable Skill: The researchers found that agents often fail not because they can't perform an action, but because they lose the "thread" of the dependency. Explicitly training on tasks with linked subgoals teaches the agent to carry information across steps.
  • Structure Over Quantity: MobileWeave outperformed "direct generation" (text-first) baselines even when the baseline had access to more training trajectories. The diversity and structural correctness provided by the capability graph are more valuable than raw data volume.
  • The "Aha" Moment on Dependencies: By training on "independent" versions of composite tasks (where subgoals are unrelated), performance dropped significantly compared to "dependency-linked" tasks. This proves that the relationship between subtasks is a vital training signal.
Figure 2. Overview of MobileWeave. Left: a typed capability graph of entities, semantic types, and operators is extracted from app code and state and grounded in native functions. Middle: atomic programs are woven into composite programs through value and object edges; each program that passes execution and review yields an instruction and a completion check. Right: successful teacher rollouts form the SFT trajectories, and one-step teacher interventions in the policy’s action loops yield the recovery SFT data.

Key Results

MobileWeave-8B (built on Qwen3-VL) achieved state-of-the-art results among open-data models:

  • MobileGym: Improved the base model by 26.7 points, reaching a 43.2% success rate.
  • Cross-Environment Generalization: Despite only being trained on MobileGym, it saw gains of 8.6 to 21.3 points on AndroidWorld, AndroidLab, and MobileWorld.
  • Efficiency: The 4B version of MobileWeave actually outperformed the original 8B base model across every benchmark, showing that better data can compensate for smaller model size.
Table 1. Comparison on task out-of-distribution (Task OOD) and environment out-of-distribution (Env OOD) mobile benchmarks. On MobileGym, SR and PR denote success rate and progress rate, respectively. MobileWorld uses the GUI-only setting. Blue shading highlights base models and MobileWeave models. Within Open-Data Models, bold and underlined scores indicate the best and second-best results in each column, respectively. For the Qwen3-VL base models and MobileWeave, ± denotes the standard deviation over eight runs on MobileGym and three runs on the other benchmarks.

Limitations and Future Work

While highly effective, MobileWeave currently relies on a controllable simulator (MobileGym) to extract app capabilities and verify programs. Scaling this to "wild" Android apps where source code isn't available remains a challenge.

The authors suggest that future work could involve extending this program-first construction to more diverse platforms and using the executable completion checks as rewards for Reinforcement Learning (RL), potentially allowing agents to continue improving through self-play.

Summary updated

Abstract

Native mobile GUI agents require large-scale training trajectories covering both individual app functions and multi-goal workflows within and across apps, which makes automatic task synthesis a promising way to scale training data. Existing synthesis pipelines, however, produce each task as free-form text, leaving implicit how its subgoals depend on one another. This matters because composition is a skill in its own right: a policy may complete each subtask of a workflow on its own, yet fail to chain these subtasks into the complete workflow. We present MobileWeave, which instead synthesizes every task as an executable program derived from the app implementations of a controllable simulator. MobileWeave abstracts each app into a typed capability graph with semantic types shared across apps, composes atomic programs into single- and cross-app composite programs through explicit value and object dependencies, and verifies each program by native execution, deriving both its instruction and its completion check from the same program. Trained on teacher trajectories collected for these tasks and on recovery supervision at the policy's own stalls, MobileWeave-8B improves its base model by 26.7 points on MobileGym and by 8.6, 21.3, and 17.6 points on AndroidWorld, AndroidLab, and MobileWorld, with comparable gains at 4B. Beyond these gains, we find that composition is learnable from task structure: explicit dependencies between subgoals act as a training signal that teaches a policy to compose skills it already masters. We release data, model, and code at https://maxxnotmarx.github.io/MobileWeave/ .
BibTeX
@misc{he2026mobileweave,
  author = {Ziyi He and Xian Wu and Qiyuan Chen and Haitao Li and Cehao Yang and Yinghao Zhu and Xichen Zhang and Xiao Chen and Yushi Feng and Lequan Yu},
  title = {{MobileWeave: Program-First Synthesis of Dependency-Linked Tasks for Training Mobile GUI Agents}},
  year = {2026},
  eprint = {2611.23860},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.23860},
}
Figure