UI-OCEANUS: Scaling GUI Agents with Synthetic Environmental Dynamics

1. Introduction

Generalist GUI agents [1,2,3,4,5] traditionally rely on Behavioral Cloning (BC) [6,7,8,9,10] to map visual observations to actions. However, acquiring trajectory-level data is prohibitively expensive. Unlike static image-text pairs, valid execution traces require long-horizon sequences where a single error can invalidate the entire trajectory. This sensitivity makes synthesizing reliable data difficult and necessitates labor-intensive human annotation [7,9,11,12], creating a major bottleneck for data scalability.

To bypass this bottleneck, recent approaches [3,13] have adopted distillation-based Continual Pre-training (CPT), distilling knowledge from foundation models via static objectives like UI captioning [14] or grounding [15]. Critically, these methods suffer from a “distillation ceiling” [16]: they enhance the agent’s static semantic understanding but fail to capture the temporal dynamics of the environment. For instance, an agent might correctly identify a “submit” button (semantics) but stubbornly assume that clicking it leads to submission, failing to anticipate that an incomplete form will actually trigger a validation error (dynamics). Lacking such grounded interaction physics, these agents remain bound by static semantic priors, unable to adapt when dynamic environmental states contradict their shallow heuristics. Therefore, there is a pressing need for a scalable CPT objective that derives supervision directly from autonomous environmental feedback.

To address these limitations, we propose UI-Oceanus, a self-supervised training framework designed to equip agents with a robust GUI world model (Figure 1). The core insight in UI-Oceanus is that the underlying set of atomic transitions (i.e., single-step observation-action-outcome tuples) in the GUI environment is both relatively finite and inherently self-supervised, providing a natural task-agnostic scaling dimension for CPT. The finite nature ensures that the environmental dynamics can be efficiently explored without an expert policy model or explicit task goal to reach high coverage. The self-supervised nature enables the environment to act as a rigorous verifier where the observed transition following the action serves as a ground-truth label of consequence. Both features enable agents to utilize task-agnostic exploration heuristics [17,18,19,20,21] to efficiently harvest vast quantities of these atomic transitions. Crucially, these atomic transitions ground the learning process in mastering the fundamental mechanics of the interface first. This effectively separates the acquisition of interaction physics from the execution of user intent: the agent learns “what is possible” (dynamics) from massive synthetic data before learning “what is desirable” (intent) from scarce expert demonstrations.

To realize this framework, we develop a scalable data engine capable of converting low-cost autonomous exploration into high-density supervision. We systematically investigate the spectrum of environmental dynamics and uncover a critical insight: forward dynamics, defined as the generative prediction of future interface states, serves as the key objective enabling performance scaling with data volume, significantly outperforming inverse dynamics and backward dynamics. Consequently, UI-Oceanus prioritizes forward dynamics prediction as the generative objective [22,23]. Technically, we capture raw interaction traces, isolate unique and meaningful atomic transitions via strict hashing filtering and semantic filtering, and employ a Visual-Language Model (VLM) to synthesize precise descriptions of environmental changes. Finally, we implement a two-stage training strategy: the model is first continually pre-trained on a mixture of GUI dynamics, grounding, and general data to establish a robust world model, and subsequently specialized via agentic post-training to align this physical intuition with complex instruction following.

We conduct extensive empirical evaluations within the WeChat mini-program ecosystem [24], one of the world’s largest and most diverse digital platforms. Hosting millions of distinct mini-programs for over a billion monthly active users (MAU), this ecosystem presents a virtually infinite space of interaction logic and visual layouts, demanding that agents master universal interaction dynamics rather than memorizing specific app interfaces. Notably, UI-Oceanus demonstrates robust scalability on the WeChat mini-program offline benchmark, achieving an average improvement of +7% across seven different VLM backbones compared to strong baselines with identical Supervised Fine-Tuning. Crucially, these benefits are amplified in online navigation: UI-Oceanus boosts the real-world success rate by 21.9% during the cold-start phase and maintains an average 15% lead even after both step-level and multi-step GRPO [24] alignment. Furthermore, our experiments yield three critical insights: (1) Data scaling: Performance scales log-linearly with synthetic data volume, showing no saturation up to 32B parameters and 3.2B tokens, confirming the scalability of atomic dynamics supervision. (2) Mechanism: Forward dynamics proves superior to inverse dynamics, as its higher predictive difficulty compels the model to learn more robust, semantic visual representations. (3) Generalization: The learned world model captures universal GUI physics effectively, enabling robust generalization to unseen mini-programs and Android environments, as well as compositional reasoning on complex multi-step tasks never seen during training.

We highlight main contributions as below:

• We pioneer a shift in GUI agent learning by separating the acquisition of atomic interaction physics from high-level instruction following. To the best of our knowledge, this is the first work to systematically scale environment dynamics as a self-supervised CPT objective for GUI agents, fundamentally bypassing the data scalability limitations of trajectory-based behavioral cloning.
• We propose UI-Oceanus, a scalable framework designed to mine training supervision directly from intrinsic environmental signals.
• We conduct extensive evaluations validating the performance scaling of UI-Oceanus. Our results demonstrate robust generalization across both domains and horizons, while ablation studies identify forward dynamics as the optimal objective for GUI world models.

2. Background and Related Work

Generalist GUI agents autonomously execute user instructions by interacting with Graphical User Interfaces (GUIs), thereby significantly boosting user productivity in daily tasks [25]. Pretrained from VLMs, generalist GUI agents are post-trained using Behavioral Cloning (BC) [3,9,10,26] or multi-step Reinforcement Learning (RL) [2,27,28]. However, post-training methods struggle under the capability ceiling of the base model [29,30], underscoring the necessity of Continual Pre-Training (CPT) prior to policy alignment. A fundamental challenge for CPT is the data scalability bottleneck, where collecting high-quality human demonstrations is prohibitively expensive. To bypass the challenge, existing research mainly uses the following two learning tasks in CPT: (1) static UI understanding task such as element grounding or screen captioning [3,13], which requires powerful foundation models to label GUI screenshots and lacks grounding in real execution; (2) dynamic interacting with environments under instructions [31,32,33,34], which is notoriously difficult due to the low yield rates for high-quality long-horizon samples. Our UI-Oceanus proposes a new CPT task: learning on forward dynamics of atomic transitions. Such dynamic learning task enables UI-Oceanus to overcome the bias of distillation caused by lack of grounding, and the fragility of long-horizon trajectory synthesis.

Conceptualizing the GUI as a dynamic system aligns with the broader literature on world models. In the specific GUI domain, prior works have explored this direction through visual state prediction [35,36] and action prediction from state changes [37]. However, there still lacks a scalable, task-agnostic CPT objective to master global environment dynamics. We distinguish our work by leveraging autonomous exploration and intrinsic environmental feedback to internalize a GUI world model of the environment via CPT, establishing a robust dynamics foundation before agentic post-training.

Appendix A discusses related work in more detail.

3. Problem Formulation

We formalize the GUI navigation problem not merely as trajectory execution, but as learning the underlying transition dynamics of the interface.

3.0.0.1. GUI as a state transition graph.

We model the GUI environment as a directed state transition graph $\mathcal{G}=(\mathcal{S},\mathcal{E})$. Each node $s\in \mathcal{S}$ represents a unique UI state, formally defined as a tuple $s=(I,X)$, where $I\in {\mathbb{R}}^{H\times W\times 3}$ is the pixel-level screenshot and X denotes structural metadata (e.g., the Accessibility Tree). A directed edge $e\in \mathcal{E}$ represents an atomic transition $(s_t,a_t,s_{t+1})$. Here, an action $a_t\in \mathcal{A}$ is defined as a tuple $a_t=(\tau ,\theta )$, where $\tau$ denotes the operation type (e.g., click, scroll, input) and $\theta$ represents the corresponding parameters (e.g., screen coordinates or input text content), with the full specification of $\mathcal{A}$ detailed in Appendix C. Executing $a_t$ on state $s_t$ leads to state $s_{t+1}$.

3.0.0.2. Forward dynamics (outcome prediction).

This objective constitutes the agent’s world model, predicting the next state $s_{t+1}$ given the current state $s_t$ and action $a_t$. We formulate this by minimizing the negative log-likelihood:

$${\mathcal{L}}_{\mathrm{fwd}}=-{\mathbb{E}}_{(s_t,a_t,s_{t+1})\sim \mathcal{D}}[log{P}_{\theta }(s_{t+1}\mid s_t,a_t)]$$

(1)

3.0.0.3. Inverse dynamics (action inference).

Inverse dynamics aims to infer the action $a_t$ responsible for the transition between $s_t$ and $s_{t+1}$. The loss function is defined as:

$${\mathcal{L}}_{\mathrm{inv}}=-{\mathbb{E}}_{(s_t,a_t,s_{t+1})\sim \mathcal{D}}[log{P}_{\theta }(a_t\mid s_t,s_{t+1})]$$

(2)

3.0.0.4. Backward dynamics (precondition inference).

Complementary to forward dynamics, this objective learns to infer the precondition state $s_t$ given the executed action $a_t$ and the outcome $s_{t+1}$. We minimize:

$${\mathcal{L}}_{\mathrm{bwd}}=-{\mathbb{E}}_{(s_t,a_t,s_{t+1})\sim \mathcal{D}}[log{P}_{\theta }(s_t\mid s_{t+1},a_t)]$$

(3)

4. The UI-Oceanus Framework

To instantiate the theoretical world model defined in Section 3, we introduce UI-Oceanus, a unified framework for learning GUI dynamics from large-scale autonomous interaction. As illustrated in Figure 2, UI-Oceanus consists of four sequential stages: scalable acquisition via autonomous exploration, strict multi-step data filtering pipeline, grounded instruction generation based on environmental feedback, and continual pre-training that optimizes a GUI dynamics world model on the constructed supervision.

4.1. Scalable Acquisition via Autonomous Exploration

We autonomously explore the WeChat mini-program ecosystem to harvest open-domain transitions. Using a distributed fleet of 50 nodes, we employ a structured random walk policy: agents interact with UI elements identified via accessibility trees without human intervention. For each step t, we record the transition tuple $(s_t,a_t,s_{t+1})$, where $s_t=(I_t,X_t)$ denotes the screenshot and structural metadata. This process yielded over 20.8M raw transitions over one month.

4.2. Multi-Step Data Filtering Pipeline

We refine ${\mathcal{D}}_{\mathrm{raw}}$ into a high-quality corpus ${\mathcal{D}}_{\mathrm{cpt}}$ via a three-stage pipeline(details in Appendix D): (1) Structural Deduplication: MinHash signatures on accessibility trees remove repeated content templates, reducing data to 8.2M. (2) Visual Deduplication: pixel-level pHash/dHash identify visually static transitions (e.g., buffering or invisible DOM updates), narrowing it to 4.3M. (3) Semantic Flitering: A VLM filters system errors and rendering artifacts by verifying action-feedback consistency, resulting in a final set of 3.4M transitions.

4.3. Grounded Instruction Generation

Following the data filtering stage, we convert the cleaned transition tuples into high-quality multimodal instructions using a vision-language model (Qwen3-VL-235B-A22B-Instruct [38]) as a semantic synthesizer. Unlike standard distillation methods, our approach utilizes the actual next state $I_{t+1}$ provided directly by the environment, with the synthesizer acting solely as an interpreter to articulate the observed transition. This strategy effectively prevents the synthesizer from generating hallucinations typically found in purely model-based approaches.

For each transition $(s_t,a_t,s_{t+1})$, we construct a visual prompt that includes the pre-transition screenshot $I_t$, annotated with a visual marker $m\left(a_t\right)$ indicating the action location (e.g., a circle highlighting the clicked area), along with the post-transition screenshot $I_{t+1}$. Given this prompt, the synthesizer generates a structured output consisting of three distinct components: (1) Observation description (${\mathcal{D}}_t$): a concise description of the initial GUI state before the action. (2) Action description ($u_t$): a brief natural-language summary describing the executed action. (3) Outcome description (${\mathcal{D}}_{t+1}$): a precise description of the resulting GUI state after the action.

By generating instructions directly grounded in actual environmental state transitions, this stage produces large-scale, reliable, and high-fidelity data for CPT.

4.4. Training Implementation

4.4.1. Continual Pretraining

Using the curated dataset ${\mathcal{D}}_{\mathrm{cpt}}$ and generated grounded instructions, we construct a unified training corpus designed to facilitate understanding of GUI dynamics.

We define three distinct categories of training tasks to comprehensively capture GUI dynamics:

Forward dynamics: Given the screenshot of an initial state and an action (either as an exact action or a natural-language summary), the model predicts the resulting GUI state description. Input: $\mathcal{V}=[I_t,a_t]$ or $\mathcal{V}=[I_t,u_t]$; Target: $\mathbf{y}={\mathcal{D}}_{t+1}$.

Inverse dynamics: Given screenshots of the initial and resulting states, the model predicts the action connecting them. Input: $\mathcal{V}=[I_t,I_{t+1}]$; Target: $\mathbf{y}=u_t$ or $\mathbf{y}=a_t$.

Backward dynamics: Given the screenshot of a resulting state and an action summary, the model predicts a description of the initial GUI state. Input: $\mathcal{V}=[u_t,I_{t+1}]$; Target: $\mathbf{y}={\mathcal{D}}_t$.

Data Mixing. We construct the final training set ${\mathcal{D}}_{\mathrm{mix}}$ by strategically combining three distinct data sources: (1) GUI dynamics (70%): Informed by our ablation study (Section 5.3), we exclusively utilize Forward Dynamics ($I_t,a_t\to {\mathcal{D}}_{t+1}$) to maximize generative world modeling capabilities; (2) General multimodal data (20%): General data [39] acts as a regularizer to prevent the catastrophic forgetting of foundational capabilities; (3) UI grounding data (10%): Grounding data is incorporated to preserve fine-grained spatial localization skills, ensuring that precise execution capabilities are not compromised. We detail the specific training hyperparameters in Appendix F.1.

4.4.2. Agentic Post-Training

Following the CPT phase, we conduct an agentic post-training stage. In this phase, the model is fine-tuned on high-quality GUI agent trajectories to explicitly align the GUI world model with user intents, bridging the gap between physical understanding and task execution. We detail the specific training hyperparameters in Appendix F.2.

5. Experiments

In this section, we systematically evaluate the UI-Oceanus framework. Our evaluation is structured to answer four critical questions: (1) Scalability: Can autonomous exploration serve as a scalable data source that yields consistent performance gains? (Section 5.1) (2) Online efficacy: Does the learned world model translate effectively to real-world online navigation and act as a persistent prior that synergizes with agentic post-training? (Section 5.2) (3) Mechanism: Which self-supervised objective yields the most significant performance gains for downstream GUI navigation? (Section 5.3) (4) Generalization: Does the learned world model generalize to unseen apps, novel domains (Android), and complex compositional tasks? (Section 5.4)

5.1. Scaling Laws of UI-Oceanus

A central premise of our framework is that autonomous environmental feedback can overcome the data scarcity bottleneck. We first investigate the scaling properties of UI-Oceanus.

5.1.1. Setup

Training configurations. During the CPT phase, we utilize the data mixture detailed in Section 4.4, totaling approximately 5M samples (3.2B tokens). For the subsequent agentic post-training phase, we employ 8K high-quality GUI navigation samples. To verify data scaling laws, we vary the volume of CPT data injected from 0% to 100%. Evaluation Protocol. To support large-scale experiments, we evaluate performance on a held-out offline benchmark comprising 8K diverse mini-program tasks not seen during training. Following prior works [3,8,12], we report Exact Match (EM), which requires both the action type and its parameters to be correct. We assess performance across Qwen3-VL [38] (2B, 4B, 8B, 32B) and Qwen2.5-VL [40] (3B, 7B, 32B) families. We compare our method against two distinct baselines: (1) Base Models: We evaluate raw base models in a zero-shot setting. To decouple planning from grounding, we also report a “w/ grounding” setting, where an external specialized grounding model based on Qwen2.5-VL-32B is employed to predict an action based on the natural language action descriptions; (2) SFT-only Baselines: Models fine-tuned solely on the post-training data without any dynamics CPT (denoted as 0% data scale).

5.1.2. Results

As presented in Table 1 and visualized in Figure 3, our empirical findings validate the existence of scaling laws for GUI world models across both data and model dimensions.

5.1.2.1. Data scaling.

We observe a consistent positive correlation between the volume of pre-training dynamics data and downstream performance. Starting from the standard SFT baseline (0% data scale), the injection of our dynamics data yields consistent improvements across all model sizes. For instance, the Qwen3-VL-2B model improves from 47.9% (0%) to 52.7% (100%), while the larger Qwen3-VL-32B advances from 61.5% to 65.0%. The performance curves exhibit a strong log-linear trend, confirming that autonomous exploration serves as a scalable data source.

5.1.2.2. Model scaling.

UI-Oceanus demonstrates robust scalability with model size. Comparing the Qwen3-VL series, the EM score improves steadily from 52.7% (2B) to 65.0% (32B) as parameters increase. Crucially, the performance gains over the SFT baseline remain robust across all scales. This indicates that the internalized interaction dynamics provide fundamental physical knowledge that complements even larger capacity models, rather than diminishing as model size grows.

5.1.2.3. Absence of saturation.

Notably, we observe no signs of performance saturation across either dimension. Even at the maximal data scale(5M samples, 3.2B tokens) and model size (32B), the trend lines maintain their upward trajectory. This suggests that further scaling would likely yield continued gains.

5.2. Online Evaluation: Synergy with Post-Training

While offline metrics quantify predictive accuracy, the ultimate test lies in online execution. We investigate the effectiveness of UI-Oceanus when integrated into a progressive post-training pipeline.

5.2.1. Setup

Training configurations. We conduct a comparative analysis between agents initialized with and without our proposed CPT (UI-Oceanus vs. w/o CPT). The post-training pipeline consists of three progressive stages: (1) SFT (cold start): Supervised fine-tuning using simple samples from the SFT dataset to establish basic instruction-following capabilities; (2) Step-level GRPO: Optimization on hard samples from the SFT dataset using dense step-wise rewards to refine complex reasoning; (3) Multi-step GRPO: Further aligning using approximately 1K instructions in the real environment, utilizing a VLM as an outcome reward model to provide sparse trajectory-level reward.

Evaluation protocol. We report the Success Rate (SR) on a held-out benchmark of 149 instructions covering diverse mini-programs. All evaluation episodes are executed in the real online environment, and task success is manually verified by human annotators to ensure rigorous correctness.

5.2.2. Results

As shown in Table 2, UI-Oceanus provides a robust performance foundation that synergizes effectively with the entire post-training pipeline.

5.2.2.1. Consistent superiority across post-training stages.

UI-Oceanus establishes an immediate advantage in the initial SFT phase and, crucially, maintains this lead throughout the subsequent RL alignment steps. Across both step-level and multi-step GRPO stages, agents initialized with our world model consistently outperform the baselines (e.g., a +20.8% relative gain in step-level GRPO). This persistence demonstrates that the internalized physical understanding is not overwritten by optimization but rather serves as an intrinsic prior that facilitates more efficient policy learning.

5.2.2.2. Amplified benefits in online environments.

Notably, the performance gains yielded by UI-Oceanus are more pronounced in the online setting compared to the offline benchmark (Section 5.1). While offline evaluation relies on static matching, online execution demands resilience to dynamic rendering variations and error recovery. The amplified gain in this challenging environment highlights that our world model equips the agent with the robust physical understanding necessary for real-world interaction.

5.3. Mechanism: The Superiority of Forward Dynamics

We dissect the contributions of different CPT objectives to understand the source of the performance gains.

5.3.1. Setup

Training configuration. To isolate the impact of objective formulation, we conduct controlled experiments across three model scales (Qwen3-VL-2B, 4B, and Qwen2.5-VL-3B). We compare the three distinct categories of self-supervised tasks detailed in Section 4.4, while keeping the underlying UI transitions corpus constant (5M samples).

Evaluation protocol. We adhere to the identical SFT and evaluation dataset settings established in Section 5.1. In addition to the previously defined EM, we report Type Match (TM), which solely evaluates the classification accuracy of the predicted action type against the ground truth.

5.3.2. Results and Analysis

As detailed in Table 3, our ablation study reveals critical insights into how different physical objectives shape the agent’s representations.

5.3.2.1. The dominance of forward dynamics.

Forward dynamics dominates, with the simplest formulation $I_t,a_t\to {\mathcal{D}}_{t+1}$ objective achieving the highest EM (54.4%). Predicting “what happens next” forces the model to encode the causal logic of the environment. Crucially, distinct from methods employing separate world models for planning [35,41], our approach embeds this transition reasoning directly into the agent’s representation. This eliminates the need for external models, allowing the agent to reason about dynamics implicitly.

5.3.2.2. The failure of inverse dynamics.

A counter-intuitive finding is the poor performance of Inverse Dynamics. Despite sharing the identical action space to the navigation task, variants like $I_t,I_{t+1}\to a_t$ yield an Overall EM of only 48.2%, performing even worse than the non-CPT baseline (51.0%). We attribute this degradation to two factors:

• Sparse supervision signal: Unlike forward dynamics which generates rich textual descriptions, the inverse task only outputs action types and coordinates. This limited token coverage and lack of diversity restrict the model’s ability to learn dense, semantically meaningful representations during CPT.
• Insufficient task difficulty: As illustrated in Figure A1, inverse dynamics converges rapidly to a low loss value. This indicates that the task lacks sufficient predictive complexity. Upon rapid convergence, the objective ceases to provide a meaningful gradient signal, rendering it ill-suited for effective CPT where sustained predictive challenge is essential [42,43,44,45].

5.3.2.3. Backward dynamics and temporal directionality.

While backward dynamics ($u_t,I_{t+1}\to {\mathcal{D}}_t$) also requires learning environment physics, it lags behind forward dynamics (52.2% vs. 54.4%). This indicates that while “reconstructing the past” offers some regularization benefits, it is less effective than “predicting the future”, which directly aligns with the agent’s inferential goal of planning subsequent steps based on current observations.

5.4. Cross-Domain and Compositional Generalization of World Model

Finally, we investigate whether the agent has merely memorized specific transition pairs or internalized a robust world model capable of cross-domain transfer and compositional reasoning. To strictly assess this, we define two levels of tasks: Level 1 (L1, atomic) utilizes standard single-step transitions ($t\to t+1$) to evaluate cross-domain transfer performance; Level 2 (L2, compositional) introduces multi-step chaining ($t\to t+2$) which never seen during training to assess compositional generalization, testing the ability to combine atomic physical rules for long-horizon prediction.

5.4.1. Setup

Dataset construction. We construct a controlled evaluation benchmark using atomic transitions from mini-programs, partitioned at the application level into seen and unseen groups. We randomly sample 1.2M transitions for training, while reserving 10K samples for L1 test sets and constructing 10K samples for L2 test sets within each group. To evaluate out-of-distribution (OOD) robustness, we additionally sample 10K random transitions from AndroidControl [12].

Training configurations. We train two specialized variants of UI-Oceanus-7B using the same data mixture as in Section 5.3. Specifically, UI-Oceanus-7B-F is trained on L1 forward tasks ($I_t,u_t\to {\mathcal{D}}_{t+1}$), and UI-Oceanus-7B-I is trained on L1 inverse tasks ($I_t,I_{t+1}\to u_t$). Both models are trained on approximately 1.7M total samples.

Evaluation protocol. We employ VLM-as-a-Judge to handle the open-ended nature of generative predictions. For forward dynamics, we explicitly query the model to predict 5 distinct UI elements of the outcome page to facilitate objective verification via a VLM judge. For inverse dynamics, the model infers the first action given the start and end states, with correctness verified by a VLM judge.

5.4.2. Results

As shown in Table 4, UI-Oceanus demonstrates robustness across both domain shifts and reasoning horizons.

5.4.2.1. Cross-domain generalization.

Our model exhibits strong transfer capabilities across distribution shifts. Notably, on L1 Forward tasks, even under a challenging format shift where the model must adapt from generating holistic descriptions (training) to listing specific elements (inference), UI-Oceanus-7B still achieves 56.9 on unseen mini-programs, surpassing the significantly larger Base-32B (49.6). This indicates that our method learns universal interaction logic rather than memorizing app-specific layouts. Furthermore, on the challenging OOD Android benchmark, UI-Oceanus-7B consistently outperforms its base model across all tasks, confirming effective cross-platform transfer.

5.4.2.2. Compositional generalization.

Crucially, although trained strictly on single-step transitions ($s_t\to s_{t+1}$), UI-Oceanus exhibits robust compositional generalization on Level 2 tasks. This implies that UI-Oceanus does not merely memorize single-step transitions but enables the agent to mentally “chain” atomic physical rules. This capability equips the agent with the look-ahead simulation capabilities necessary for long-horizon planning.

6. Conclusion

We introduce UI-Oceanus, a framework that overcomes the data scalability bottleneck by learning a GUI world model from autonomous exploration. By shifting from trajectory imitation to mastering atomic interaction physics, we unlock a scalable supervision source independent of human annotation. Our results identify forward dynamics as the critical objective for this capability, yielding log-linear performance scaling on the massive WeChat ecosystem with no signs of saturation up to 32B parameters and 3.2B tokens. Crucially, this internalized world model acts as a persistent policy prior: it boosts real-world online performance by over 15% and serves as a robust foundation for agentic post-training. By separating the acquisition of interaction physics from the execution of user intent, UI-Oceanus provides a scalable pathway toward generalist agents capable of navigating complex, open-domain interfaces.

Appendix A.1. Learning Paradigms for GUI Agents

Recent advancements in generalist GUI agents have primarily focused on refining policy optimization paradigms. While initial efforts relied on straightforward Behavioral Cloning (BC) [3,9,10,26], the field has rapidly shifted towards multi-step Reinforcement Learning (RL) [2,27,28] integrated with Chain-of-Thought (CoT) [46] reasoning to handle non-stationary, long-horizon tasks. However, recent studies on RL reveal a critical bottleneck: RL alone struggles to surpass the inherent capability ceiling of the base model [29,30]. This underscores the necessity of elevating the foundation model’s intrinsic capabilities via Continual Pre-Training (CPT) prior to policy alignment. Existing CPT approaches for GUI agents, however, are largely confined to static UI understanding, such as element grounding or screen captioning [3,13]. While these methods improve perception, they fail to capture the causal mechanics of interaction. Distinct from these static objectives, our work targets a foundational dynamic objective: the internalization of a “World Model” via CPT on atomic transitions. By grounding the model in the forward dynamics of the interface (i.e., predicting consequences), we effectively elevate the capability ceiling of the base model, providing a scalable path to establishing this essential foundation for generalist GUI agents.

Appendix A.2. Scalable Data Acquisition for GUI Agents

A fundamental challenge to training generalist GUI agents is the data scalability bottleneck of Behavioral Cloning (BC). Practically, collecting high-quality human demonstrations is prohibitively expensive. To bypass these limitations, the field has pivoted toward synthetic data generation, primarily following two directions. One line of work attempts to synthesize execution trajectories by deploying agents to interact with the environment under specific instructions [31,32,33,34]. However, due to the strict long-horizon dependencies of GUI tasks, generating valid data is notoriously difficult; a single intermediate error invalidates the entire trajectory, resulting in extremely low yield rates for high-quality samples. Alternatively, other approaches focus on static tasks such as screen captioning or VQA by leveraging powerful foundation models to label GUI screenshots [1,3,13]. Yet, this relies on Model-based Distillation, creating an inherent “distillation ceiling”: the agent is bounded by the teacher model’s hallucinations and lacks objective grounding in real execution. In contrast, our UI-Oceanus framework shifts the source of supervision from fallible teacher models to intrinsic environmental dynamics. By treating state transitions as objective verification, we overcome the fragility of long-horizon synthesis and the bias of distillation, ensuring that performance scales robustly with autonomous exploration.

Appendix A.3. World Models and Dynamics in Digital Interfaces

Conceptualizing the GUI as a dynamic system aligns with the broader literature on world models in model-based Reinforcement Learning and representation learning, where frameworks [47,48,49] enable agents to plan by modeling future latent states. In the specific domain of GUIs, prior works such as ViMo [35] and VAGEN [36] have explored this direction through explicit visual state prediction, while GUI-Shift [37] employs an inverse dynamics objective to infer actions from state changes. Recent concurrent work [50] proposes utilizing implicit world modeling as an auxiliary task, yet remains constrained by local branching from expert demonstrations, lacking a scalable, task-agnostic Continual Pre-Training objective to master global environment dynamics. We distinguish our work by leveraging autonomous exploration and intrinsic environmental feedback to internalize a GUI world model via Continual Pre-Training, establishing a robust dynamics foundation before agentic post-training.

Appendix B.1. Synthetic Environmental Dynamics Tasks

The CPT tasks are designed to enable the model to master the underlying transition dynamics of the GUI environment. We adopt the following notations: $I_t$ denotes the screenshot at step t; $u_t$ denotes the natural language description of the action; $a_t$ denotes the atomic action (e.g., coordinates); and ${\mathcal{D}}_t$ denotes the textual description of the interface state.

Forward Dynamics (I t ,u t →D t+1 and I t ,a t →D t+1 ).

This task requires the model to predict the future state description given the current image and an action.

Inverse Dynamics (I t ,I t+1 →u t /a t ).

This task infers the action performed between two states.

Inverse Dynamics with Goal (I t ,D t+1 →u t /a t ).

The agent infers the action required to reach a specific described state.

Backward Dynamics (u t ,I t+1 →D t ).

This task reconstructs the previous state description.

Appendix B.2. GUI Navigation Task

For the downstream navigation task, we utilize a Chain-of-Thought (CoT) approach.

Appendix B.3. Generalization Evaluation Prompts

To rigorously assess cross-domain transfer (Level 1) and compositional generalization (Level 2) as discussed in Section 5.4, we employ specialized prompt templates that facilitate objective verification via a VLM judge.

Forward Dynamics Generalization (L1 & L2).

Unlike the standard CPT objective which generates a holistic description, the evaluation prompts require the model to explicitly predict 5 distinct UI elements.

Inverse Dynamics Generalization (L2).

Appendix B.4. VLM-based Verification Judges

To automate the evaluation of open-ended generation in our generalization experiments (Section 5.4), we employ two distinct VLM judges. Both judges utilize a standardized structure to ensure rigorous and consistent verification.

Judge for Inverse Dynamics (Action Consistency).

This judge evaluates whether the predicted action is visually and functionally equivalent to the ground truth (Binary Score: 0 or 1).

Judge for Forward Dynamics (Element Prediction).

This judge evaluates the accuracy of the predicted next-state elements by calculating the precision of the top-5 predictions (Discrete Score: 0, 0.2, ..., 1).

Appendix D.1. Structural Transition Deduplication

To identify interface states with identical logic but varying content, we model transitions as sets of structural tokens.

Appendix D.8.8.11. Tokenization & MinHash.

We extract tokens from the accessibility tree nodes based on semantic attributes (e.g., $\mathtt{tag}$, $\mathtt{xpath}$, $\mathtt{events}$). A transition is represented by the union of hashed tokens from both the pre- and post-action states. We generate MinHash signatures to efficiently estimate Jaccard similarity, reducing variable-length token sets to fixed-length vectors.

Appendix D.8.8.12. LSH Indexing.

We employ a banding strategy to index these signatures. Transitions colliding in any band are retrieved as candidates. We then verify candidates against a Jaccard similarity threshold, retaining only unique representatives for the final dataset.

Appendix D.2. Visual Transition Deduplication

For opaque components (e.g., WebViews), we utilize a composite visual fingerprinting strategy combining frequency and gradient domains.

Appendix D.9.9.13. Composite Hashing.

For each transition, we concatenate the Perceptual Hash (pHash) and Difference Hash (dHash) of the start and end screenshots. This combination ensures robustness against rendering noise while remaining sensitive to significant layout changes.

Appendix D.9.9.14. Clustering Strategy.

We employ bit-sampling LSH to project high-dimensional hashes into lower-dimensional buckets for indexing. Candidates are clustered using a Union-Find data structure based on Hamming distance thresholds. For each connected component, the transition with the highest data source priority is retained.

Appendix D.3. Semantic Filtering

We utilize Qwen3-VL-235B-Instruct as a semantic verifier. The model is prompted to output a binary validity score, retaining only transitions where the screen changes logically correspond to the annotated action.

Appendix F.1. Continual Pre-Training (CPT)

The hyperparameters for the CPT phase are summarized in Table A2.

Table A2. Hyperparameters for Continual Pre-Training.

Hyperparameter	32B Models	7B-8B Models	2B-4B Models
Optimizer	AdamW
Global Batch Size	2048	1024	1024
Peak Learning Rate	$1\times {10}^{-5}$	$2\times {10}^{-5}$	$3\times {10}^{-5}$
LR Scheduler	Cosine
Warmup Ratio	0.03
Max Sequence Length	4096
Weight Decay	0.1	0.01	0.01
Epochs	1

Table A2. Hyperparameters for Continual Pre-Training.

Hyperparameter	32B Models	7B-8B Models	2B-4B Models
Optimizer	AdamW
Global Batch Size	2048	1024	1024
Peak Learning Rate	$1\times {10}^{-5}$	$2\times {10}^{-5}$	$3\times {10}^{-5}$
LR Scheduler	Cosine
Warmup Ratio	0.03
Max Sequence Length	4096
Weight Decay	0.1	0.01	0.01
Epochs	1

Appendix F.2. Agentic Post-Training: SFT

Table A3 lists the settings for the Supervised Fine-Tuning stage.

Table A3. Hyperparameters for SFT.

Hyperparameter	32B Models	7B-8B Models	2B-4B Models
Optimizer	AdamW
Global Batch Size	64
Peak Learning Rate	$3\times {10}^{-6}$	$6\times {10}^{-6}$	$1\times {10}^{-5}$
LR Scheduler	Constant
Max Sequence Length	4096
Weight Decay	0
Epochs	2

Table A3. Hyperparameters for SFT.

Hyperparameter	32B Models	7B-8B Models	2B-4B Models
Optimizer	AdamW
Global Batch Size	64
Peak Learning Rate	$3\times {10}^{-6}$	$6\times {10}^{-6}$	$1\times {10}^{-5}$
LR Scheduler	Constant
Max Sequence Length	4096
Weight Decay	0
Epochs	2

Appendix G.1. Offline Scalability Benchmark Comparison

Table A4 presents the performance comparison between our UI-Oceanus framework and state-of-the-art proprietary models (including GPT-5.2, Claude-4.5-Opus, and Gemini-3-Flash) as well as large-scale open-weight baselines on the offline scalability benchmark.

Table A4. Offline Benchmark Performance vs. Proprietary & Large-Scale Models. We report Exact Match (EM) and Type Match (TM) scores across different model families.

Model	Exact Match (EM)	Type Match (TM)
Proprietary Models
GPT-5.2 [51] (w/ Grounding)	61.1	76.9
Claude-4.5-Sonnet [52] (w/ Grounding)	64.8	81.2
Claude-4.5-Opus [53] (w/ Grounding)	69.2	82.7
Gemini-3-Flash [54] (w/ Grounding)	69.2	82.0
Open-Weight Baselines
Qwen2.5-VL-32B	33.9	56.6
Qwen2.5-VL-72B	51.4	77.2
Qwen3-VL-32B	47.1	79.2
Qwen3-VL-235B-A22B	47.5	79.4
Qwen2.5-VL-32B (w/ Grounding)	56.5	77.9
Qwen2.5-VL-72B (w/ Grounding)	56.8	77.2
Qwen3-VL-32B (w/ Grounding)	61.2	79.3
Qwen3-VL-235B-A22B (w/ Grounding)	61.5	79.3
Ours
Qwen3-VL-32B + UI-Oceanus (CPT+SFT)	65.0	81.1
Qwen2.5-VL-32B + UI-Oceanus (CPT+SFT)	64.8	82.1
Qwen2.5-VL-32B + UI-Oceanus (CPT+SFT+GRPO)	68.9	84.5

Table A4. Offline Benchmark Performance vs. Proprietary & Large-Scale Models. We report Exact Match (EM) and Type Match (TM) scores across different model families.

Model	Exact Match (EM)	Type Match (TM)
Proprietary Models
GPT-5.2 [51] (w/ Grounding)	61.1	76.9
Claude-4.5-Sonnet [52] (w/ Grounding)	64.8	81.2
Claude-4.5-Opus [53] (w/ Grounding)	69.2	82.7
Gemini-3-Flash [54] (w/ Grounding)	69.2	82.0
Open-Weight Baselines
Qwen2.5-VL-32B	33.9	56.6
Qwen2.5-VL-72B	51.4	77.2
Qwen3-VL-32B	47.1	79.2
Qwen3-VL-235B-A22B	47.5	79.4
Qwen2.5-VL-32B (w/ Grounding)	56.5	77.9
Qwen2.5-VL-72B (w/ Grounding)	56.8	77.2
Qwen3-VL-32B (w/ Grounding)	61.2	79.3
Qwen3-VL-235B-A22B (w/ Grounding)	61.5	79.3
Ours
Qwen3-VL-32B + UI-Oceanus (CPT+SFT)	65.0	81.1
Qwen2.5-VL-32B + UI-Oceanus (CPT+SFT)	64.8	82.1
Qwen2.5-VL-32B + UI-Oceanus (CPT+SFT+GRPO)	68.9	84.5

Appendix G.2. Online Evaluation Benchmark Comparison

Complementing the offline metrics, Table A5 presents the Success Rate (SR) on the online benchmark. We list the performance of UI-Oceanus across three progressive post-training stages and compare them against representative external models, including state-of-the-art proprietary models.

Table A5. Online Success Rate vs. Proprietary Models. Comparison of Success Rate (SR) on live mini-programs between our progressive pipeline and external baselines.

Category	Model / Stage	SR (%)	Gap w/ Best Ours
Ours (32B)	UI-Oceanus (SFT Cold Start)	29.5	-14.8
	+ Step-level GRPO	38.9	-5.4
	+ Multi-step GRPO	44.3	–
[l]Proprietary &
External	Seed-1.8 [55] (w/ Grounding)	27.5	-16.8
	Claude-4.5-Opus [53] (w/ Grounding)	46.3	+2.0
	Gemini-3-Flash [54] (w/ Grounding)	49.0	+4.7

Table A5. Online Success Rate vs. Proprietary Models. Comparison of Success Rate (SR) on live mini-programs between our progressive pipeline and external baselines.

Category	Model / Stage	SR (%)	Gap w/ Best Ours
Ours (32B)	UI-Oceanus (SFT Cold Start)	29.5	-14.8
	+ Step-level GRPO	38.9	-5.4
	+ Multi-step GRPO	44.3	–
[l]Proprietary &
External	Seed-1.8 [55] (w/ Grounding)	27.5	-16.8
	Claude-4.5-Opus [53] (w/ Grounding)	46.3	+2.0
	Gemini-3-Flash [54] (w/ Grounding)	49.0	+4.7