Technical Summary: MIRAGE (Mobile Agents with Implicit Reasoning and Generative World Models)

1. Problem Statement

Mobile agents, which operate everyday applications from screenshots and language goals, face a critical trade-off between reasoning capability and deployment efficiency. Current state-of-the-art systems (e.g., UI-TARS, MAI-UI) rely on explicit Chain-of-Thought (CoT), where models generate verbose textual rationales before executing actions. While this improves decision-making, it introduces significant overhead:

• Inefficiency: Generating long textual thoughts increases decoding latency and token consumption, slowing down interactive control.
• Cost: Supervision requires human-written or synthetic rationale data, increasing training costs.
• Deployment Constraints: In real-world mobile scenarios, every extra token delays feedback, making explicit reasoning impractical for low-latency applications.

The core challenge is to preserve the multi-step reasoning and future-state prediction capabilities of explicit CoT while eliminating the cost of decoding intermediate thoughts into visible text.

2. Methodology

MIRAGE addresses this by shifting reasoning from the visible token stream to continuous latent space. The framework employs a two-stage training pipeline and introduces two novel components: Approximate Parallel Latent Refinement (APLR) and a Q-Former World Model head.

2.1 Latent-Thought Formulation

Instead of generating a sequence of text tokens $\tau_t$ followed by an action $a_t$, MIRAGE generates a sequence of continuous latent variables $z_t = (z_{t,1}, \dots, z_{t,N})$ within the decoder context. These latent slots represent the agent's internal "thoughts" (observation, rationale, and future prediction) without being detokenized. The inference process only decodes the final action tokens, drastically reducing output length.

2.2 Approximate Parallel Latent Refinement (APLR)

To train the model to reason effectively in latent space without the prohibitive cost of serial generation, MIRAGE introduces APLR.

• Concept: Traditional latent CoT requires serial refinement (one step at a time), which is computationally expensive. APLR treats the thought block as $N$ slots and refines them in parallel over $K$ rounds (Jacobi-style).
• Mechanism: In each round $k$, all latent slots $z_i^{(k+1)}$ are updated simultaneously using the values from round $k$.
• Theoretical Guarantee: The method provides a provable bound on approximation error. After $K$ rounds, the first $K$ latent slots exactly match the serial solution, while the remaining "tail" slots retain a bounded error.
• Efficiency: This reduces the training cost from $N$ serial passes to a small number of synchronous passes ($K \ll N$), typically $K=3$.

2.3 Q-Former World Model Alignment

A limitation of parallel refinement is that the "tail" latent slots (which often contain future-state predictions) may not be sufficiently supervised by action-only loss. To address this, MIRAGE integrates a World Model perspective:

• Objective: The model is trained to predict the visual features of the next screenshot ($x_{t+1}$) based on the current latent reasoning state.
• Architecture: A lightweight Q-Former head aligns the refined latent states with stop-gradient visual features extracted from the next screenshot by a frozen vision encoder.
• Benefit: This forces the latent slots to encode environment dynamics and transition predictions, preventing representation collapse and providing dense supervision for the "predict" dimension of the thought process.

2.4 Two-Stage Training Pipeline

1. Stage 1 (Explicit CoT Warm-up): The model is trained on structured text traces containing <THOUGHT> (observation, rationale, prediction) and <ACTION> blocks. This teaches the backbone the mobile action space and reasoning patterns.
2. Stage 2 (Latent Distillation): The <THOUGHT> text block is replaced with latent slots. The model is trained using APLR for refinement and the Q-Former head for world-model alignment. The joint loss function combines Action Cross-Entropy ($L_{ce}$) and World Model alignment loss ($L_{wm}$).

3. Key Contributions

The paper claims three primary contributions:

1. MIRAGE Framework: A mobile agent that reasons entirely in latent space, achieving explicit-CoT level performance with 3–5$\times$ fewer decoded tokens and significantly lower inference latency.
2. APLR: A parallel Jacobi-style refinement procedure that approximates full serial latent CoT at a fraction of the training cost, with a theoretical bound on tail-slot approximation error.
3. Q-Former World Model Head: A mechanism that aligns latent reasoning states with future-screenshot features, enabling the agent to anticipate GUI state transitions and improving task capability without generating pixels or text at inference time.

4. Experimental Results

MIRAGE was evaluated on AndroidControl (instruction following and action accuracy) and AndroidWorld (dynamic on-device task completion).

• AndroidControl:

  • MIRAGE-4B improved Exact Match (EM) from 68.48% to 77.59% and Action Accuracy from 75.15% to 91.09% compared to the Qwen3-VL-4B baseline.
  • Token Reduction: Average generated tokens per step dropped from ~115 to ~19 (an 83% reduction).
  • Latency: First-token-to-last-token latency was reduced by 1.8$\times$ to 2$\times$ compared to strong baselines.

• AndroidWorld:

  • MIRAGE-4B achieved a Task Success Rate (SR) of 52.6%, outperforming the Qwen3-VL-4B baseline (42.9%) by 9.7 percentage points.
  • MIRAGE-8B achieved an SR of 57.8%, a 10.2-point improvement over its baseline.
  • Efficiency: Despite higher success rates, MIRAGE models generated ~70–75% fewer tokens than their baselines.

• Ablation Studies:

  • Removing the World Model objective (APLR only) resulted in lower performance (48.2% SR vs. 52.6% for full MIRAGE), confirming the necessity of future-state alignment for refining tail latent slots.
  • Reducing latent slots from 9 to 3 significantly degraded performance, highlighting the need for sufficient continuous capacity to represent complex reasoning.

5. Significance and Claims

The paper positions MIRAGE as a solution to the "reasoning bottleneck" in mobile agents. It claims that:

• Implicit Reasoning is Viable: High-quality reasoning does not require verbose textual output; it can be effectively compressed into latent states.
• Efficiency without Sacrifice: By decoupling reasoning computation from the token stream, agents can achieve the robustness of explicit CoT while meeting the strict latency and token-budget constraints of mobile deployment.
• Future-State Prediction: Integrating world-model objectives directly into the latent reasoning process allows agents to anticipate interface changes, a capability previously difficult to maintain in compact latent representations.

The authors acknowledge limitations, noting that the current approach relies on supervised training, uses feature-level (rather than pixel-level) world modeling, and requires privacy and safety safeguards before real-world deployment.