- Rating
- 1
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 1
Read review
Paper summary
This paper presents an online RL framework for UI navigation on live iOS applications. The agent is decomposed into an RL-trained planning model and a frozen grounding model. It uses LLM-as-a-judge dense step-level rewards together with terminal rewards, and optimizes the planner with PPO and a proposed neighbor-conditioned critic method, GiGPPO. Experiments on UINavBench, iOSWorld, and AndroidWorld show improvements over the authors’ SFT baseline, with the strongest result being GiGPPO on UINavBench.
Critical strengths
- To be honest, GUI agents in the iOS environment are fascinating and make for compelling reading. Currently, the vast majority of GUI-related work centers on Android and Linux—platforms that differ significantly from iOS at the data level. Furthermore, the scaling of virtual environments on iOS is an interesting topic in its own right.
Critical weaknesses
- There are substantial flaws in the experimental setup, baseline selection, and evaluation. If the primary goal of this paper is to validate an online reinforcement learning (RL) framework for GUI agents, rather than claiming the creation of a new state-of-the-art (SOTA) model, then the current experimental setup appears suboptimal. A more compelling design would utilize standard backbone models, such as established general-purpose models (e.g., Qwen2.5/3/3.5/3.6) or models specifically designed for GUIs (e.g., GUI-Owl, MAI-UI, UI-Venus, UI-TARS), and then evaluate performance gains in iOS environments following training within the proposed framework, alongside out-of-distribution (OOD) transfer capabilities in Android environments.
In contrast, the current system combines a Qwen3-VL-8B-Instruct planner, an internal 3B-parameter grounding model (described as an "internal 3B dense pre-trained model fine-tuned on a large-scale human-annotated dataset"), and Gemini-based components for swipe actions and reward determination. This setup is somewhat atypical, making it difficult to discern whether observed performance improvements stem from the RL framework itself or from the choice of specific internal or proprietary components; this also undermines the comparability and reproducibility of the results. Of course, if your primary objective is to showcase or establish a strong model baseline for the iOS domain, the current results lack competitiveness; the model underperforms compared to others on iOSWorld and UINavBench (the two benchmarks you prioritize most), let alone on other OOD benchmarks.
Furthermore, the results reported in the paper for Gemini and Qwen3.8-27B on AndroidWorld are difficult to reconcile with previously published data. For instance, the official score for Qwen3.8-27B is as high as 81.9, and UI-Venus achieved a score of 70.3 even when using the less powerful Qwen3.6-27B; in contrast, the scores reported in this paper range only from 49 to 60, raising questions regarding the reliability of the evaluation protocol and the comparative results on AndroidWorld. In my own experience, while achieving a score of over 80 on AndroidWorld with Gemini and Qwen3.8-27B might require some prompt and harness adaptation, reaching a score of over 70 is easily achievable.
- Method and Writing At this point, I think I understand why the authors opted for such a complex system design—it resembles a full-duplex, live interaction model (Planner + Actor). However, this raises a question regarding the paper's motivation: what is the rationale for employing this type of full-duplex, live interaction? Is it driven by specific real-world use cases, or is the goal to create a more seamless interaction between the user and the agent system? Furthermore, demonstrating the advantages of this approach requires supporting data (such as the system's average execution time, the latency distribution across the full action pipeline, and a comparison with the latency of end-to-end models) .
Questions for authors
Q1: In the context of online RL, how much time overhead is incurred by the step-level "Dense judge" and the trace-level "Terminal judge," respectively? How is the pipeline for this component designed?
Q2: In online RL, are rollout and training synchronous or asynchronous? Do they share the GPU, use time-division multiplexing, or operate on separate, independent GPUs? Is there a model offloading phase? If so, when does it occur, and what are the approximate synchronization and offloading overheads?