Test-Time Self-Evolving GUI Visual Grounding via Reflection-Guided On-Policy Self-Distillation

Test-Time Self-Evolving GUI Visual Grounding via Reflection-Guided On-Policy Self-Distillation Shiyu Xuan1 , Zechao Li1 1

School of Computer Science and Engineering, Nanjing University of Science and Technology, Nanjing, China, 210094 {shiyu_xuan, zechao.li}@njust.edu.cn

arXiv:2608.11191v1 [cs.CV] 11 Aug 2026

Abstract GUI Visual Grounding is a fundamental capability for GUI agents. Existing models typically freeze their parameters after deployment, limiting their ability to adapt to unseen interfaces. Although recent methods attempt to adapt models via testtime reinforcement learning, they cannot reflect upon failed exploration. To overcome this, we propose a Test-Time SelfEvolving framework that enables models to improve after deployment without human-annotated ground truth. It constructs a closed-loop of Exploration, Evaluation, Reflection, and Internalization. Specifically, the agent first explores unseen interfaces by predicting grounding coordinates for given instructions. To evaluate these explorations, we introduce an MLLMbased Reflector to assess the generated results and provide the corresponding reasoning reflections. To internalize reflection knowledge into the model weights, we propose ReflectionGuided On-Policy Self-Distillation, which translates highlevel reasoning into dense token-level supervision via a conditioned self-teacher. Furthermore, we design a Contrastive Calibration method to prevent incorrect auto-regressive prefixes from corrupting the supervisory signals during failed explorations. Extensive experiments across six benchmarks demonstrate our framework’s effectiveness, achieving an average accuracy improvement of 7.4% over the base model. To the best of our knowledge, this is the first work to successfully exploit on-policy self-distillation for test-time adaptation in GUI visual grounding. By filling the gap in post-deployment adaptation, our framework completes the self-evolving capability of GUI agents. The code will be released.

Introduction GUI agents capable of navigating and interacting with digital environments have recently emerged as a promising direction for human-computer interaction (Xie et al. 2025). As a fundamental capability of GUI agents, GUI Visual Grounding aims to localize UI elements according to natural-language instructions. Recent advances have substantially improved grounding performance through large-scale supervised finetuning (Qin et al. 2025; Cheng et al. 2024), specialized action heads (Wu et al. 2025; Lin et al. 2025), and reinforcement learning (Luo et al. 2025a; Yuan et al. 2025). Despite these advances, existing GUI grounding models remain static after deployment, with model parameters frozen once training is completed. Consequently, when encountering unseen applications or interface layouts, their perfor-

GUI Screenshot

Instruction: Click the button “Next”

Grounding Model

Failed Grounding (e.g., [100, 200])

Incapable of learning after deployment

(a) Static Methods GUI Screenshot [100, 200] [120, 200]

Grounding Model

Sparse Reward

[120, 240]

Instruction: Click the button “Next”

[400, 300]

Incapable of reflection and cannot instruct the model on why a failure occurred. (b) TTRL Methods GUI Screenshot

R-OPSD Dense Per-token Feedback

Grounding Model Instruction: Click the button “Next”

[100, 200]

Reflector

Reasoning Reflection

Evaluation Result

Enabling the model to learn from both successful and failed explorations via R-OPSD. (c) Ours

Figure 1: (a) Static methods operate on frozen parameters after deployment and cannot learn from exploration. (b) TTRL Methods adapt the model using sparse scalar rewards, but lack a mechanism to reason about failures and internalize textual reflections. (c) Test-Time Self-Evolving introduces a Reflector to provide detailed textual reflections, which are translated into dense token-level feedback via R-OPSD, enabling the model to self-evolve.

mance cannot improve through interaction. A recent testtime adaptation method (Du et al. 2026) attempts to alleviate this limitation by optimizing the model online with reinforcement learning. This method relies on sparse scalar rewards that merely indicate whether an exploration succeeds. Such feedback provides little information about why a prediction fails or how the model should correct it.

A natural solution is to train the model with the reflection on its own explorations. Rather than merely assigning a success or failure signal, reflection explains why a prediction is incorrect by identifying the intended UI element, examining the predicted location, and diagnosing the failure. Such reasoning provides richer supervisory information than scalar rewards. However, existing reinforcement learning algorithms cannot directly leverage these textual reflections based on scalar rewards. To overcome this, we propose a Test-Time Self-Evolving framework. It constructs a closed-loop that equips the agent with four core capabilities: Exploration in unknown interfaces, Evaluation of generated coordinates, Reflection upon evaluation results, and Internalization of these reflections into its parameters. Specifically, upon deployment, the agent first explores the interface with instructions by predicting grounding coordinates. To evaluate this exploration, we introduce an MLLM-based Reflector that estimates whether the prediction is consistent with the instruction while simultaneously generating a reflection explaining its evaluation. The remaining challenge is how to internalize the reflection into the model parameters. Unlike scalar rewards, textual reflections cannot be directly exploited by policy optimization algorithms. To bridge this gap, we propose ReflectionGuided On-Policy Self-Distillation (R-OPSD). Instead of learning from scalar rewards, R-OPSD conditions a selfteacher on the Reflector’s evaluation results and reflections, converting high-level reasoning into dense token-level supervision over the generated coordinate tokens. However, this dense feedback encounters a bottleneck in the auto-regressive generation of coordinates. During failed explorations, the model predicts incorrect tokens. If the teacher model conditions its subsequent supervision on these prefixes, the supervisory signals gradually become unreliable. To mitigate this issue, we propose a Contrastive Calibration Method. It treats a failed exploration as successful by using an inverse-prompted student. The trajectory is sampled from the model’s own policy, conditioning it on a success prompt amplifies its confidence in this specific sequence. Consequently, at the initial error step, the inverse student assigns a high probability to the incorrect token, while the reflection-guided teacher yields a lower probability. This discrepancy produces a negative advantage that suppresses the initial error. As generation continues, the corrupted prefix dominates both models, aligning their output distributions. This decays the advantage to almost zero, preventing corrupted feedback from being internalized. Extensive experiments across ScreenSpot and ScreenSpotv2 (Cheng et al. 2024), ScreenSpot-Pro (Li et al. 2025), MMBench-GUI (Wang et al. 2025), OSWorld-G and OSWorld-G-Refine (Xie et al. 2025) demonstrate the effectiveness of our framework. By enabling self-evolving without ground truth annotations, our method achieves an average accuracy improvement of 7.4% over the base model. Furthermore, compared to the recent test-time reinforcement learning method GUI-RCPO, our method achieves an average performance gain up to 7.7%. In summary, our main contributions are three-fold: (a) We introduce a Test-Time Self-Evolving framework, which

empowers grounding agents with exploration, evaluation, reflection, and parameter internalization in unseen environments. (b) We propose Reflection-Guided On-Policy SelfDistillation, which converts textual reflections into dense token-level supervision, together with a Contrastive Calibration method that alleviates corrupted supervision caused by incorrect auto-regressive prefixes. (c) Extensive experiments and ablations validate our framework. This is the first work to applying OPSD in test-time scenarios of GUI grounding, establishing a promising direction for GUI grounding.

Related Works GUI Visual Grounding. GUI visual grounding locates UI elements based on natural language instructions. Recent advancements span three paradigms. Supervised finetuning methods establish baseline alignment using largescale datasets (Qin et al. 2025; Cheng et al. 2024; Gou et al. 2024). To enhance visual perception, models selectively extract UI-related visual tokens (Lin et al. 2025; Ouyang et al. 2026) or employ attention-based action heads to bypass direct coordinate generation (Wu et al. 2025). Reinforcement learning methods further enhance the performance. Recent works adapt GRPO (Shao et al. 2024) with rule-based coordinate rewards (Luo et al. 2025a; Lu et al. 2026), or design complex reward functions incorporating attention maps, box sizes, and bounding-box distributions (Yuan et al. 2025; Zhou et al. 2025; Tang et al. 2026). Test-time scaling methods allocate additional inference compute to enhance performance. RegionFocus (Luo et al. 2025b) dynamically zooms into the image for coarse-to-fine UI grounding, a process similarly guided by attention maps in ZoomUI (Liu et al. 2026). Additionally, GUI-RC (Du et al. 2026) aggregates multiple predictions via region consistency, further refining the model with test-time reinforcement learning (Zuo et al. 2026). On-policy Distillation. To internalize reasoning capabilities into model weights, on-policy distillation (OPD) trains the student model with token-level feedback on its own generation trajectories. Typically, this feedback is derived either from a stronger teacher model (Gu et al. 2024; Agarwal et al. 2024) or a model conditioned on privileged information (Zhang et al. 2026a; Zhao et al. 2026). However, incorrect prefixes generated by the student can degrade the quality of the feedback. To address this issue, ESR (Ziheng et al. 2026) proposes an early stopping rollout mechanism, while EOPD (Jin et al. 2026) assesses the reliability of the teacher model using token entropy. Alternatively, RLSD (Yang et al. 2026) and RLCSD (Pan et al. 2026) leverage token-level feedback to only determine update magnitudes. The potential of OPD has also been explored across various vision-language tasks, such as Video Temporal Grounding (Li et al. 2026), Visual Question Answering (Yuan et al. 2026), and GUI Visual Grounding (Zhang et al. 2026b). Unlike test-time reinforcement learning methods (Du et al. 2026; Zuo et al. 2026) that rely on sparse scalar rewards and fail to leverage reflection reasoning, our framework empowers the model to learn from rich reflections via R-OPSD. Furthermore, Contrastive Calibration effectively migrates the corrupted supervision issue caused by incorrect prefixes through suppressing initial errors and decaying the policy

gradients of drifted tokens, ensuring that the model can safely internalize knowledge from failed explorations.

Methodology Overview Given a screenshot I and a language instruction L, the GUI grounding model πG is required to locate the corresponding UI element B = πG (I, L), where B denotes the coordinates of the bounding box [x1 , y1 , x2 , y2 ] or the center point (x, y) of the target element. Existing GUI grounding models typically remain static after deployment, with model parameters frozen once training is completed. Consequently, when deployed on unseen platforms or applications, the model cannot improve from its own interaction experience. To enable post-deployment adaptation without human annotations, we propose a Test-Time Self-Evolving framework that constructs a closed-loop consisting of four stages: Exploration in unknown interfaces, Evaluation of its generated coordinates, Reflection upon its evaluation result, and Internalization of these reflections into its parameters. Specifically, this framework executes an episodic loop: • Exploration: The GUI grounding model πG explores the unseen interface, i.e., given the UI screenshot I and instruction L, B = πG (I, L). • Evaluation & Reflection: To assess the exploration in the absence of ground truth, we introduce a Reflector πR . It takes the screenshot, instruction, and predicted coordinates as input to output an evaluation score S and a detailed reasoning process R, S, R = πR (I, L, B),

(1)

where S ∈ {0, 1} indicates whether the current exploration is successful, and R represents the reasoning behind this evaluation. Subsequently, S and R are utilized to guide the internalization. • Internalization: The reflection knowledge is then internalized into πG through Reflection-Guided On-Policy Self-Distillation. Specifically, the evaluation score and reasoning process are leveraged as privileged information to construct a self-teacher that provides per-token feedback on the generated coordinates. Furthermore, to alleviate failed explorations from corrupting the feedback, we propose a Contrastive Calibration Method. In the following parts, we will first introduce the Evaluation & Reflection stages, and further propose the Internalization stage. The overall framework is illustrated in Fig.2.

Evaluation and Reflection with Reflector During test-time adaptation, ground-truth annotations are unavailable. Therefore, the model requires an alternative mechanism to estimate whether its exploration is successful. To this end, we introduce an MLLM-based Reflector πR . Its role is to evaluate the alignment between the predicted coordinates B and the language instruction L within the context of the visual screenshot I. Besides producing an estimated evaluation result, it also generates a reflection explaining the

reasoning behind its judgment. This reflection serves as privileged information for the subsequent internalization stage. Inference. To achieve this goal, we design a prompt template that forces the Reflector to engage in step-by-step reasoning before outputting a final result: Reflector Prompt Template Evaluate if the given click coordinate correctly executes the user instruction on the provided UI image. Answer with Yes or No. Instruction: {L} Click Coordinate: {B} Before providing your final answer, you must think step-bystep. Address the following in your reasoning: 1. Intent Analysis: What specific UI element (text, icon, button) does the instruction intend to interact with? 2. Coordinate Grounding: Look at the exact location of the Click Coordinate [x,y] on the UI. What specific element or visual feature is located at that coordinate? 3. Verification: Does the element at the given coordinate match the intended element from the instruction? Is it the correct target, or did it hit the background, a different element, or an empty space? 4. Conclusion: Explicitly state whether the verification passed (Yes) or failed (No). Output the thinking process in <think> </think> and final answer in <answer> </answer> tags. You must strictly format your output as follows: <think> Your step-by-step reasoning and conclusion here </think> <answer>Yes|No</answer>

Once receiving the generated response from πR , we parse the output according to the specified tags to obtain R and S. Specifically, the text extracted from the <think>...</think> tags serves as the reflection R, The discrete binary label extracted from the <answer>...</answer> tags serves as S. Training. To improve the reliability of the Reflector, we optimize it using GRPO (Shao et al. 2024) on an offline collected dataset. Each sample in this dataset comprises a UI screenshot I, a language instruction L, a sampled click coordinate B, and a ground-truth label S ∗ ∈ {0, 1} indicating whether the coordinate successfully executes the instruction. The construction details of the dataset are shown in the Appendix. We employ the format and binary rewards during training, i.e., r = rformat + rbinary : • rformat ensures the model strictly adheres to the requested output template. • rbinary supervises discrimination capability: ( 1, if S = S ∗ and format is valid rbinary = 0, if S ̸= S ∗ or format is invalid

(2)

After training, the Reflector remains frozen throughout testtime adaptation.

Internalization with Reflection-Guided On-Policy Self-Distillation After obtaining the evaluation result S and reflection R, the final stage is to internalize this knowledge into the ground-

Exploration

GUI Screenshot

Evaluation & Reflection

GUI Screenshot

Prediction [150, 20] Instruction (L): Enable Wi-Fi

Instruction (L): Enable Wi-Fi

Evaluate if the given click coordinate correctly … think step-bystep … Yes | No

[150, 20]

<think> User intends to enable Wi-Fi. The click is on the top-right of the screen. This hits a background area. </think> <answer> No </answer>

Internalization

Privileged Information

S R

Reflection-guided Teacher Template

GUI Screenshot

v.s.

+ [150, 20]

Inverse-prompted Student Template

Instruction (L): Enable Wi-Fi

Per-token Advantage Self-Evolving

Figure 2: Test-Time Self-Evolving Framework consists of four core stages: Exploration, Evaluation, Reflection, and Internalization. During test-time adaptation, πG explores the environment to predict coordinates. The Reflector πR then assesses the prediction to generate a binary score S and a step-by-step reasoning R. The reflection knowledge is internalized via ReflectionGuided On-Policy Self-Distillation to update the grounding policy. To optimize memory efficiency, both πG and πR share a base model and we alternate between the roles of πG and πR by switching the active LoRA adapters. ing model πG . The remaining challenge is how to transform textual reflection into effective optimization signals. Unlike reinforcement learning, which is based on scalar rewards, reflection consists of free-form natural language and therefore cannot be directly exploited by standard policy optimization algorithms. To bridge this gap, we propose ReflectionGuided On-Policy Self-Distillation (R-OPSD), which converts reflection into dense token-level supervision. R-OPSD. Given a rollout B ∼ πG (· | I, L) generated by the policy, OPD trains the policy πG on its own rollout with the token-level supervisory signals provided by a teacher model πT . Following the standard policy optimization formulation, the token-level advantage is defined as: ai = log

πT (Bi | B<i , I, L) . πG (Bi | B<i , I, L)

(3)

The optimization objective maximizes the expected return, defined as the sum of token-level advantages: T

LOPD = −

1 X sg(ai ) log πG (Bi | B<i , I, L), T i=1

(4)

where sg(·) denotes the stop-gradient operator. To internalize the knowledge from the Reflector, we construct a self-teacher by utilizing the πG itself conditioned on the evaluation result S and reflection R as the privileged information. Conditioning on this additional information enables the teacher to produce a more informative conditional distribution over the generated coordinate sequence. Specifically, the input prompt L(S, R) is formulated as follows,

Reflection-guided Teacher Prompt Template If Success (S = 1) The previous prediction {B} has been verified to correctly fulfill the instruction. Outline the position corresponding to the instruction: {L}. The output should be only [x1,y1,x2,y2]. If Failure (S = 0) Previous wrong prediction: {B} Feedback: {R} Based on the feedback, outline the position corresponding to the instruction: {L}. The output should be only [x1,y1,x2,y2].

The token-level advantage is then computed as: ai = log

πG (Bi | B<i , I, L(S, R)) . πG (Bi | B<i , I, L)

(5)

Contrastive Calibration Method. MLLM-based GUI grounding is formulated as an auto-regressive generation of coordinate tokens. Performing R-OPSD on failed explorations introduces a challenge. If the teacher model conditions its subsequent feedback on these incorrect prefixes, its predicted probabilities become meaningless. To mitigate this, we propose a Contrastive Calibration Method (CC) to calibrate the learning advantage based on the state of the generated prefix: it suppresses the initial incorrect token and decays the advantage to zero as the tokens progressively drift. To achieve this, we introduce an inverseprompted student to contrast against the teacher. Specifically, for failed explorations, we construct a contrastive prompt L(¬S) to misinform the model that the prediction is correct,

[ 1

Average Advantage

Predicted Tokens

…, 2 0 1 , 3 9 ] … … … … … Student Probability

2

1.34 0.0033

0 −0.39

−2

−0.97

w/o CC

w/ CC

Initial Incorrect Token (āt ) Drifted Last Token (|āt |)

Teacher Probability

Meaningless Probability

Figure 4: Quantitative analysis of token-level advantage on failed explorations (S = 0). We report the average advantage (āt ) at the initial incorrect token, and the average absolute advantage (|āt |) at the drifted last tokens.

Inverse-prompted Student Probability

Per-token Advantage w/ CC Suppress the Initial Incorrect Tokens

Almost Zero Per-token Advantage w/o CC

Corrupted Feedback

Figure 3: Illustration of Contrastive Calibration Method. During auto-regressive generation, an incorrect prediction, e.g., the initial incorrect token ‘0‘, causes subsequent tokens to drift. Without CC, computing advantages on these drifted tokens results in corrupted feedback. By contrast, CC leverages an inverse-prompted student. This produces a negative penalty to suppress the initial incorrect tokens. As errors accumulate, the conditioned incorrect prefix forces both the teacher and the inverse-prompted student’s distributions to align, decaying the advantage to near zero.

πG (· | L(S, R)) ≈ πG (· | L(¬S)), driving the advantage to almost zero (ai → 0), thereby gradually reducing the magnitude of the token-level advantage. Discussion. To validate CC, we analyze token-level advantage during failed explorations by calculating the average advantage (āt ) at the initial incorrect token and the average absolute advantage (|āt |) at the drifted last token. As shown in Fig. 4, without CC, R-OPSD applies a marginal penalty at the initial error and generates corrupted advantages |āt | = 1.34 on drifted tokens. In contrast, CC generates a strong negative penalty at the initial incorrect token. As tokens progressively drift, the update magnitude decays towards zero, preventing the internalization of corrupted supervision. Direction-based Advantage Clamping. Directly applying token-level feedback of R-OPSD can sometimes destabilize training. To mitigate this, the token-level updates should be aligned with the evaluation result, i.e., if a prediction is successful, its probability should be encouraged. If it fails, its probability should be suppressed. Therefore, we apply direction-based clamping to the advantage,  ai =

Inverse-prompted Student Prompt Template If Failure (S = 0) Previous correct prediction: {B} Based on the feedback, outline the position corresponding to the instruction: {L}. The output should be only [x1,y1,x2,y2].

With L(¬S), we reformulate the advantage in Eq.(5) into the contrastive calibration advantage: ai = log

πG (Bi | B<i , I, L(S, R)) . πG (Bi | B<i , I, L(¬S))

(6)

Note that CC is exclusively applied to failed explorations, as successful samples (S = 1) avoid the incorrect prefix issue. As shown in Fig. 3, CC addresses the incorrect prefix issue across two phases. First, when the prefix B<i is correct, but the current token Bi is incorrect, the inverse-prompted student under L(¬S) is misled to treat the prediction as successful, assigning a high probability to Bi . In contrast, the teacher under L(S, R) leverages the reflection to predict the true target, yielding a lower probability for Bi , producing a negative advantage ai < 0, driving the policy gradient to suppress this token. Second, As more incorrect tokens are generated, both models are conditioned on increasingly similar prefixes, leading to similar probabilities

max(0, ai ), min(0, ai ),

S=1 . S=0

(7)

In addition, this token-level advantage can be seamlessly integrated with the query-level advantage from GRPO. Given a sampled group of size K, the GRPO reward is defined as rGRPO = rformat + rcorrectness , where rcorrectness is evaluation S of the predicted coordinates. The query-level advantage ÂGRPO [k] is computed by standardizing these rewards: ÂGRPO [k] =

rGRPO [k] − mean{rGRPO [1], . . . , rGRPO [K]} . (8) std{rGRPO [1], . . . , rGRPO [K]}

By incorporating the token-level advantage into the GRPO advantage, the final integrated objective is: Â[k] = ÂGRPO [k] + λai ,

(9)

where λ controls the integration strength. Although the proposed framework relies on the Reflector to estimate grounding correctness, it does not require perfect evaluation. Instead, R-OPSD only assumes that the Reflector provides sufficiently informative evaluations and reflections to improve the conditional distribution of the teacher. As demonstrated in our experiments, this assumption is sufficient to improve grounding performance across multiple GUI benchmarks consistently. We also provide quantitative and qualitative evaluations of the Reflector in the Appendix.

Experimental Setup Evaluation Benchmarks and Metrics. We conduct experiments across diverse GUI visual grounding benchmarks covering various platforms and instruction complexities: ScreenSpot and ScreenSpot-v2, ScreenSpot-Pro, MMBenchGUI, as well as OSWorld-G and OSWorld-G-Refine. We adopt Element Accuracy as the evaluation metric, where a prediction is correct if the predicted point falls within the bounding box of the target UI element. Implementation Details. Our method is built upon the Qwen2.5-VL (Team 2025) and Qwen3-VL (Bai et al. 2025). To optimize memory efficiency, both the grounding model (πG ) and the Reflector (πR ) share a base model and are finetuned using LoRA (Hu et al. 2022). During training, we alternate between the roles of πG and πR by switching the active LoRA adapters. This parameter-efficient design restricts the GPU memory to approximately 10GB for 3B/2B models and 30GB for 7B/8B models. During the rollout phase, we set the temperature to 1.0 and top-p to 0.95. For the Reflector πR , we train for 1 epoch via GRPO on 10K samples from GroundCUA (Feizi et al. 2025), with a learning rate of 1 × 10−4 , a group size of 8, and a batch size of 64. For the internalization stage of πG , R-OPSD integrates the GRPO advantage with a strength coefficient λ = 0.2. The model is trained for 2 epochs with a learning rate of 1 × 10−4 and a batch size of 64. To simulate post-deployment self-evolving, we leverage data from ScreenSpot-v2 or MMBench-GUI, strictly omitting their ground-truth annotations.

Main Results The evaluation results across six GUI visual grounding benchmarks are presented in Table 1. Overall, our proposed Test-Time Self-Evolving framework consistently enhances the grounding capabilities of the base models, outperforming the existing test-time adaptation method, e.g., GUI-RCPO. Our method demonstrates performance gains across different base models. When deployed on the unseen SSv2 dataset, our framework boosts the average accuracy of Qwen2.5-VL-3B from 50.2% to 57.4%. When applied to the highly capable Qwen3-VL-2B backbone, our self-evolving framework still raises the average accuracy to 69.4% (+3.7%) and 70.3% (+4.6%) when adapting on SSv2 and MMG, respectively. This validates that our framework achieves the self-evolving without requiring ground-truth. Adapting on complex datasets like MMG frequently results in rollout groups where all test-time explorations fail. GRPO used in GUI-RCPO relies on relative rewards, they fail to optimize from failed groups, causing negative transfer. In contrast, R-OPSD overcomes this limitation by leveraging reflections to provide token-level feedback, guiding the model even from complete failures. Supported by CC to filter out corrupted supervision, our framework achieves performance gains (+7.4% and +4.6%) with MMG.

Ablation Study Qualitative and quantitative analysis of the Reflector, computational overhead analysis, scalability to larger base models,

Accuracy (%)

Experiments

90 88 86 84 82 80

SSv2

MMG

70 66

SSv2 MMG

0

0.1 0.2 0.3 0.4 0.5

SSv2

62 58

MMG

0

0.1 0.2 0.3 0.4 0.5

Figure 5: Sensitivity analysis of the integration strength λ. The subplots indicate the evaluation datasets. The colored lines denote the adaptation datasets.

and comparisons with visual bounding box prompting can be found in the Appendix. Effectiveness of Each Component. To validate the effectiveness of each module in our Test-Time Self-Evolving framework, we conduct ablation studies in Table 2. We establish (a) as our baseline, which applies OPSD using only evaluation results as privileged information. This naive baseline suffers from catastrophic policy collapse. Comparing (d)(e) and (i)(j), incorporating Reflection yields a substantial performance gain, e.g., when adapting on SSv2, Reflection boosts the accuracy from 24.6% to 28.5% on SSP. Utilizing tokenlevel feedback in auto-regressive generation introduces the incorrect prefix issue. (f) utilizes reflection but lacks CC, causing it to collapse. By incorporating CC, (g) filters out this corrupted supervision, turning the negative transfer into massive gains, reaching 64.3% on MMG. A similar substantial boost is observed in (h) vs. (i), confirming CC is important for learning from failed explorations. (i) demonstrates that direction-based advantage clamping prevents token-level updates from contradicting the evaluation result, providing consistent improvements. Building upon this, (j) shows the benefit of integrating the query-level advantage. Necessity of R-OPSD over Standard RL. To demonstrate the necessity of R-OPSD, we compare it against GRPO using various scalar rewards in Table 3. Following TTRL (Zuo et al. 2026), relying on averaged predicted bounding boxes (Avg B) as pseudo-labels suffers negative transfer on complex datasets like MMG. This occurs because when some predictions drift towards visually similar but incorrect UI elements, averaging these bounding boxes leads to completely invalid pseudo-labels. The evaluation result S from Reflector is more robust to this situation, leading to better performance. This also confirms the high reliability of the Reflector. However, GRPO guided by the binary S reward remains limited by the sparsity of scalar signals and cannot instruct the model on how to correct specific coordinate tokens. Furthermore, to verify that our gains stem from the reflection design rather than OPSD, we evaluate GUI-SD (Zhang et al. 2026b), which draws the bounding box in the image as the privileged information. Its severe performance degradation confirms that drawing invalid pseudo-labels directly corrupts the visual context. In contrast, R-OPSD leverages both the evaluation result and the detailed textual reflection (S, R), achieving the highest accuracy. Sensitivity Analysis of Integration Strength. We investigate the impact of λ, which controls the magnitude of the distillation advantage during policy updates. As shown in

Adaptation Datasets

SS

SSv2

SSP

OSW-G

OSW-GR

MMG

Avg.

UGround-V1-2B (Gou et al. 2024) ShowUI-2B (Lin et al. 2025) GUI-Actor-3B (Wu et al. 2025) FocusUI-3B (Ouyang et al. 2026)

-

77.7 75.1 89.7 -

78.8 91.0 91.5

22.7 42.2 43.8

53.4

-

-

-

InfiGUI-R1-3B (Liu et al. 2025) SE-GUI-3B (Yuan et al. 2025) GUI-G2 -3B (Tang et al. 2026)

-

87.5 90.8

91.0

35.7 35.9 37.8

-

-

-

-

Qwen2.5-VL-3B (Team 2025) + GUI-RCPO (Du et al. 2026) + Ours + GUI-RCPO (Du et al. 2026) + Ours

SSv2 SSv2 MMG MMG

78.3 82.3 85.9 79.2 84.6

80.4 85.4 88.8 80.6 87.5

20.3 24.8 30.5 19.8 30.1

27.1 29.3 32.6 25.7 33.7

37.7 38.4 39.7 36.1 41.7

57.5 60.2 66.6 58.2 68.2

50.2 53.4+3.2 57.4+7.2 49.9-0.3 57.6+7.4

Qwen3-VL-2B (Bai et al. 2025) + GUI-RCPO (Du et al. 2026) + Ours + GUI-RCPO (Du et al. 2026) + Ours

SSv2 SSv2 MMG MMG

83.5 84.7 88.5 84.2 88.2

87.6 89.3 91.6 86.9 91.5

42.8 46.3 47.6 42.3 49.3

47.3 51.3 52.1 46.8 52.2

60.8 61.3 61.2 61.8 63.2

72.2 72.8 75.4 71.6 77.6

65.7 67.6+1.9 69.4+3.7 65.6-0.1 70.3+4.6

Method GUI-specific Models

Test-Time Adaptation

Table 1: GUI grounding accuracy on six benchmarks including ScreenSpot-V2 (SSv2), ScreenSpot-Pro (SSP), OSWorld-G (OSW-G), OSWorld-G_R (OSW-GR), and MMBenchGUI (MMG). Bold indicates the best results.

R CC Clamp QA

Adapt on SSv2

Adapt on MMG

Reward

Supervision

SSv2 SSP MMG SSv2 SSP MMG Base Model (a) √ (b) (c) √ (d) √ (e) √ (f) √ √ (g) √ (h) √ √ (i) √ √ (j)

√ √ √ √ √ √

80.4 20.3 57.5 × × 81.2 21.4 79.5 18.0 √ 84.2 24.6 84.2 25.4 × × 84.0 26.8 82.1 21.5 √ 86.8 28.5 88.8 30.5

× 58.7 57.2 61.7 62.6 × 62.9 58.5 64.2 66.6

80.4 20.3 57.5 × × 80.8 21.1 78.6 18.3 82.3 23.5 82.8 23.4 × × 84.0 27.7 80.2 19.8 86.0 29.9 87.5 30.1

× 59.3 57.1 61.5 62.3 × 64.3 57.5 67.4 68.2

Table 2: Ablation study on each component using Qwen2.5VL-3B when adapting on SSv2 and MMG, respectively. R: Reflection R; CC: Contrastive Calibration Method; Clamp: Direction-based advantage clamping; QA: Integrating querylevel advantage. × denotes suffering from policy collapse. Fig. 5, λ = 0.2 leads to the best performance, regardless of the adaptation and evaluation datasets.

Conclusion In this paper, we introduce a Test-Time Self-Evolving framework for GUI visual grounding that enables post-deployment adaptation without requiring ground truth annotations. Our framework introduces a closed-loop of Exploration, Evaluation, Reflection, and Internalization, allowing the model to learn from both the outcomes of its explorations and

Adapt on SSv2

Adapt on MMG

SSv2 SSP MMG SSv2 SSP MMG Base Model

80.4 20.3 57.5

80.4 20.3 57.5

GUI-RCPO Binary IoU GUI-G2 Binary

Avg. B Avg. B Avg. B S

85.4 24.8 84.3 24.6 84.7 22.4 83.0 21.2 85.4 25.9

80.6 19.8 79.1 21.2 80.8 20.4 78.6 19.4 84.2 25.7

58.2 57.5 59.4 55.8 62.8

GUI-SD

Avg. B

78.5 16.7 52.3

×

×

Ours

S, R

88.8 30.5 66.6

87.5 30.1 68.2

60.2 61.7 61.3 59.9 62.3

×

Table 3: Comparison of the performance between GRPO with various scalar rewards and R-OPSD. The “Supervision” denotes the source of feedback used for optimization: Avg. B indicates that the rewards are derived from aggregated bounding box predictions within a rollout group; S is the evaluation results from the Reflector.

the reasons behind its successes and failures. To internalize such reflection knowledge, we propose R-OPSD, which transforms natural-language reflections into token-level supervision through a self-teacher conditioned on privileged information. Furthermore, we introduce a Contrastive Calibration method to alleviate corrupted supervision caused by incorrect auto-regressive prefixes during failed explorations. Extensive experiments across diverse benchmarks and ablations demonstrate that our framework can improve the performance of the model in a self-evolving manner.

References Agarwal, R.; Vieillard, N.; Zhou, Y.; Stanczyk, P.; Ramos Garea, S.; Geist, M.; and Bachem, O. 2024. Onpolicy distillation of language models: Learning from selfgenerated mistakes. In ICLR, volume 2024, 21246–21263. Bai, S.; Cai, Y.; Chen, R.; Chen, K.; Chen, X.; Cheng, Z.; Deng, L.; Ding, W.; Gao, C.; Ge, C.; et al. 2025. Qwen3-vl technical report. arXiv preprint arXiv:2511.21631. Cheng, K.; Sun, Q.; Chu, Y.; Xu, F.; YanTao, L.; Zhang, J.; and Wu, Z. 2024. Seeclick: Harnessing gui grounding for advanced visual gui agents. In ACL, 9313–9332. Du, Y.; Yan, Y.; Tang, F.; Lu, Z.; Zong, C.; Lu, W.; Jiang, S.; and Shen, Y. 2026. Test-time reinforcement learning for gui grounding via region consistency. In AAAI, volume 40, 30593–30601. Feizi, A.; Nayak, S.; Jian, X.; Lin, K. Q.; Li, K.; Awal, R.; Lù, X. H.; Obando-Ceron, J.; Rodriguez, J. A.; Chapados, N.; et al. 2025. Grounding Computer Use Agents on Human Demonstrations. arXiv preprint arXiv:2511.07332. Gou, B.; Wang, R.; Zheng, B.; Xie, Y.; Chang, C.; Shu, Y.; Sun, H.; and Su, Y. 2024. Navigating the digital world as humans do: Universal visual grounding for gui agents. arXiv preprint arXiv:2410.05243. Gu, Y.; Dong, L.; Wei, F.; and Huang, M. 2024. Minillm: Knowledge distillation of large language models. In ICLR, volume 2024, 32694–32717. Hu, E. J.; Shen, Y.; Wallis, P.; Allen-Zhu, Z.; Li, Y.; Wang, S.; Wang, L.; Chen, W.; et al. 2022. Lora: Low-rank adaptation of large language models. ICLR, 1(2): 3. Jin, W.; Min, T.; Yang, Y.; Kadhe, S. R.; Zhou, Y.; Wei, D.; Baracaldo, N.; and Lee, K. 2026. Entropy-Aware OnPolicy Distillation of Language Models. arXiv preprint arXiv:2603.07079. Li, J.; Yin, H.; Xu, H.; Xu, B.; Tan, W.; He, Z.; Ju, J.; Luo, Z.; and Luan, J. 2026. Video-OPD: Efficient PostTraining of Multimodal Large Language Models for Temporal Video Grounding via On-Policy Distillation. arXiv preprint arXiv:2602.02994. Li, K.; Meng, Z.; Lin, H.; Luo, Z.; Tian, Y.; Ma, J.; Huang, Z.; and Chua, T.-S. 2025. Screenspot-pro: Gui grounding for professional high-resolution computer use. In ACM MM, 8778–8786. Lin, K. Q.; Li, L.; Gao, D.; Yang, Z.; Wu, S.; Bai, Z.; Lei, S. W.; Wang, L.; and Shou, M. Z. 2025. Showui: One visionlanguage-action model for gui visual agent. In CVPR, 19498– 19508. Liu, Y.; Li, P.; Xie, C.; Hu, X.; Han, X.; Zhang, S.; Yang, H.; and Wu, F. 2025. Infigui-r1: Advancing multimodal gui agents from reactive actors to deliberative reasoners. arXiv preprint arXiv:2504.14239. Liu, Z.; Feng, T.; Kang, B.; Yang, Y.; and Luo, J. 2026. Zoom to Essence: Trainless GUI Grounding by Inferring upon Interface Elements. arXiv preprint arXiv:2603.14448. Lu, Z.; Chai, Y.; Guo, Y.; Yin, X.; Liu, L.; Wang, H.; Xiao, H.; Ren, S.; Zhao, P.; Liu, G.; et al. 2026. Ui-r1: Enhancing

efficient action prediction of gui agents by reinforcement learning. In AAAI, volume 40, 17608–17616. Luo, R.; Wang, L.; He, W.; Chen, L.; Li, J.; and Xia, X. 2025a. Gui-r1: A generalist r1-style vision-language action model for gui agents. arXiv preprint arXiv:2504.10458. Luo, T.; Logeswaran, L.; Johnson, J.; and Lee, H. 2025b. Visual test-time scaling for gui agent grounding. In ICCV, 19989–19998. Ouyang, M.; Lin, K. Q.; Shou, M. Z.; and Ng, H. T. 2026. FocusUI: Efficient UI Grounding via Position-Preserving Visual Token Selection. arXiv preprint arXiv:2601.03928. Pan, L.; Tao, S.; Zhai, Y.; Zhang, L.; Liu, Z.; Ding, B.; Liu, A.; and Wen, L. 2026. RLCSD: Reinforcement Learning with Contrastive On-Policy Self-Distillation. arXiv preprint arXiv:2606.11709. Qin, Y.; Ye, Y.; Fang, J.; Wang, H.; Liang, S.; Tian, S.; Zhang, J.; Li, J.; Li, Y.; Huang, S.; et al. 2025. Ui-tars: Pioneering automated gui interaction with native agents. arXiv preprint arXiv:2501.12326. Shao, Z.; Wang, P.; Zhu, Q.; Xu, R.; Song, J.; Bi, X.; Zhang, H.; Zhang, M.; Li, Y.; Wu, Y.; et al. 2024. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300. Tang, F.; Gu, Z.; Lu, Z.; Liu, X.; Shen, S.; Meng, C.; Wang, W.; Zhang, W.; Shen, Y.; Lu, W.; et al. 2026. GUI-G2 : Gaussian Reward Modeling for GUI Grounding. In AAAI, volume 40, 33214–33222. Team, Q. 2025. Qwen2.5-VL. Wang, X.; Wu, Z.; Xie, J.; Ding, Z.; Yang, B.; Li, Z.; Liu, Z.; Li, Q.; Dong, X.; Chen, Z.; et al. 2025. Mmbenchgui: Hierarchical multi-platform evaluation framework for gui agents. arXiv preprint arXiv:2507.19478. Wu, Q.; Cheng, K.; Yang, R.; Zhang, C.; Yang, J.; Jiang, H.; Mu, J.; Peng, B.; Qiao, B.; Tan, R.; et al. 2025. Guiactor: Coordinate-free visual grounding for gui agents. arXiv preprint arXiv:2506.03143. Xie, T.; Deng, J.; Li, X.; Yang, J.; Wu, H.; Chen, J.; Hu, W.; Wang, X.; Xu, Y.; Wang, Z.; et al. 2025. Scaling computeruse grounding via user interface decomposition and synthesis. arXiv preprint arXiv:2505.13227. Yang, C.; Qin, C.; Si, Q.; Chen, M.; Gu, N.; Yao, D.; Lin, Z.; Wang, W.; Wang, J.; and Duan, N. 2026. Self-Distilled RLVR. arXiv preprint arXiv:2604.03128. Yuan, Q.; Lou, J.; Yu, X.; Lin, H.; Sun, L.; Han, X.; and Lu, Y. 2026. Vision-opd: Learning to see fine details for multimodal llms via on-policy self-distillation. arXiv preprint arXiv:2605.18740. Yuan, X.; Zhang, J.; Li, K.; Cai, Z.; Yao, L.; Chen, J.; Wang, E.; Hou, Q.; Chen, J.; Jiang, P.-T.; et al. 2025. Enhancing visual grounding for gui agents via self-evolutionary reinforcement learning. arXiv preprint arXiv:2505.12370. Zhang, X.; Ding, Z.; Pan, T.; Yang, R.; Kang, C.; Xiong, X.; and Gu, J. 2026a. OPSDL: On-Policy Self-Distillation for Long-Context Language Models. arXiv preprint arXiv:2604.17535.

Zhang, Y.; Wu, D.; Shen, H.; Ma, C.; and Zhou, Y. 2026b. Learn where to Click from Yourself: On-Policy Self-Distillation for GUI Grounding. arXiv preprint arXiv:2605.00642. Zhao, S.; Xie, Z.; Liu, M.; Huang, J.; Pang, G.; Chen, F.; and Grover, A. 2026. Self-Distilled Reasoner: On-Policy Self-Distillation for Large Language Models. arXiv preprint arXiv:2601.18734. Zhou, Y.; Dai, S.; Wang, S.; Zhou, K.; Jia, Q.; and Xu, J. 2025. Gui-g1: Understanding r1-zero-like training for visual grounding in gui agents. arXiv preprint arXiv:2505.15810. Ziheng, Z.; Li, J.; Tang, H.; Wu, Y. N.; and Terzopoulos, D. 2026. Less is More: Early Stopping Rollout for On-Policy Distillation. arXiv preprint arXiv:2605.27028. Zuo, Y.; Zhang, K.; Sheng, L.; Qu, S.; Cui, G.; Zhu, X.; Li, H.; Long, X.; Hua, E.; Qi, B.; et al. 2026. Ttrl: Test-time reinforcement learning. NeurIPS, 38: 131459–131483.

Appendix This Appendix provides the details of construction of the Reflector training dataset, additional qualitative and quantitative analysis of the Reflector, computational overhead analysis, scalability to larger base models, extension of our method to the unsupervised training setting, and comparisons with visual bounding box prompting.

Construction of the Reflector Training Dataset To train the MLLM-based Reflector πR to accurately evaluate test-time explorations and provide diagnostic reasoning, we construct a training dataset based on the Functional Split of GroundCUA (Feizi et al. 2025). The constructed Reflector training dataset will be released. It is designed to capture a diverse set of predictions while maintaining balanced labels, proceeding as follows: Prediction Generation. For each instruction-image pair in the GroundCUA, we employ the base model to perform inference. To encourage a diverse range of predictions, we set the sampling temperature to 1.0 and sample 8 distinct coordinate predictions per instruction. Label Assignment. Each generated coordinate is evaluated against the ground-truth bounding box. A discrete binary label S ∗ ∈ {0, 1} is assigned to each prediction, where S ∗ = 1 indicates a successful grounding (the predicted point falls within the target bounding box) and S ∗ = 0 indicates a failure. Sample Filtering. We group the 8 predictions by their instruction and apply a filtering strategy: we exclusively retain the groups that exhibit mixed results. Specifically, an instruction is kept only if its 8 rollouts contain at least one correct prediction S ∗ = 1 and at least one incorrect prediction S ∗ = 0. Balanced Sampling. To ensure a balanced distribution of positive (“Yes”) and negative (“No”) evaluation results, we randomly select exactly one correct prediction S ∗ = 1 and one incorrect prediction S ∗ = 0 from the 8 generated rollouts for each retained instruction. The final Reflector training dataset consists of approximately 10, 160 prediction-label pairs, yielding a 1:1 ratio of positive to negative samples. Discussion on Cold-Start SFT. Additionally, we have explored a supervised fine-tuning cold-start strategy by synthesizing 30K high-quality reasoning trajectories using Qwen3.7-plus. However, results indicated that incorporating this cold-start phase yielded no noticeable performance gain compared to directly applying RL to the base model for the training of the Reflector.

More Experimental Results Reliability Evaluation of the MLLM-based Reflector. The efficacy of our Test-Time Self-Evolution framework relies heavily on the quality of the evaluation score S and diagnostic reasoning R provided by the Reflector πR . We evaluate the Reflector on a held-out test set consisting of 1,000 randomly sampled instruction-prediction pairs from SSv2, SSP, and MMG. We maintain a balanced 1:1 ratio of successful and failed groundings. We assess its performance as a

binary classifier S ∈ {0, 1} using three metrics: Accuracy, Precision, and Recall. Here, the positive class represents successful groundings S ∗ = 1. Model Qwen2.5-VL-3B (Zero-shot) Trained Reflector πR Qwen3-VL-2B (Zero-shot) Trained Reflector πR

Accuracy Precision Recall 76.5 89.5 80.5 91.7

72.9 86.9 78.9 88.8

85.4 93.3 86.0 95.7

Table 4: Performance metrics of the MLLM-based Reflector. As shown in Table 4, after training via GRPO with format and binary rewards, our Reflector achieves an evaluation Accuracy of 89.5% and 91.7%, demonstrating its capability in determining whether a predicted coordinate aligns with the user instruction. Computational Overhead and Training Time Analysis. To provide a comprehensive understanding of the computational overhead, we conduct a training time analysis using the Qwen2.5-VL-3B model with 4 NVIDIA A100 40GB GPUs. As shown in Table 5, to compute relative advantages, GRPO samples a group of trajectories K = 8 for every single query, leading to the total training time of 449 minutes. R-OPSD operates on a different mechanism. By utilizing the Reflector’s feedback as privileged information to construct a self-teacher, R-OPSD performs a token-level knowledge distillation. The model only needs to sample a single trajectory per query. Even with the additional forward passes required for the self-teacher and the inverse-prompted student in Contrastive Calibration (CC), the R-OPSD w/ CC only takes 151 minutes, reducing the training time by more than 34% compared to GRPO. Our full framework (R-OPSD w/ CC & QA) achieves the optimal performance by integrating the token-level advantage. Re-introducing QA necessitates returning to the K = 8 group rollout setting, which increases the training time to 778 minutes (1.73×). For resource-constrained deployment environments, R-OPSD w/ CC serves as a highly efficient learning method that operates at 1/3 the cost of standard RL. The full framework leverages the combined strengths of both token-level and query-level advantages, offering a computational trade-off. Scalability to Larger Base Models. In the main text, our experiments are conducted on the 3B and 2B parameter scales, e.g., Qwen2.5-VL-3B and Qwen3-VL-2B. To further demonstrate the scalability of our Test-Time Self-Evolution frameMethod

Time (m)

Relative Cost

GRPO + GUI-RCPO GRPO + Binary

449 447

1.00× 1.00×

R-OPSD (w/o CC) R-OPSD (w/ CC) R-OPSD (w/ CC & QA)

129 151 778

≈ 0.29× ≈ 0.34× ≈ 1.73×

Table 5: Training time Analysis. The Relative Cost is normalized against the standard GRPO baseline.

Method

Adapt on SSv2

Adapt on MMG

Method

SSv2 SSP MMG SSv2 SSP MMG Qwen2.5-VL-7B + GUI-RCPO + Ours

86.8 89.2 92.7

19.9 25.9 31.4

68.2 70.3 77.9

86.8 88.3 92.5

19.9 25.5 32.3

68.2 70.9 79.2

Qwen3-VL-8B + GUI-RCPO + Ours

92.9 93.2 94.5

53.5 53.8 55.8

82.7 83.3 84.3

92.9 93.5 94.1

53.5 54.6 56.3

82.7 83.4 84.7

Table 6: Scalability evaluation using Qwen2.5-VL-7B and Qwen3-VL-8B base models. We report the target dataset accuracy when adapting on SSv2 and MMG, respectively. Model

Accuracy Precision Recall

Qwen2.5-VL-3B (Zero-shot) Trained Reflector πR Qwen2.5-VL-3B + V (Zero-shot) Trained Reflector + V πR

76.5 91.7 73.2 78.3

72.9 88.8 73.5 78.5

85.4 95.7 78.6 79.5

Table 7: Performance comparison of the Reflector with visual bounding box prompt and textual coordinate prompt. work, we extend our evaluation to a larger base model. The evaluation results are shown in Table 6. The Qwen2.5-VL7B and Qwen3-VL-8B base models exhibit stronger initial grounding capabilities than 3B/2B versions. However, even with this baseline, our framework consistently yields performance improvements. For instance, adapting the 7B model on MMG using our framework boosts the accuracy from 68.2% to 79.2%. Our method still outperforms the TTRL method GUI-RCPO. These results further demonstrate the scalability of our framework. Comparison with Visual Bounding Box Prompting. Many methods directly draw a bounding box or point on the UI screenshot for representing grounding coordinates (Zhang et al. 2026b; Luo et al. 2025b). To evaluate this design, we conduct an ablation study comparing textual coordinate representation against visual bounding box representation in two critical components of our framework: the Reflector’s evaluation and the teacher model’s privileged information prompt. For the Reflector + V and Ours + V, instead of feeding the textual coordinate token B in the prompt, we draw a red bounding box corresponding to the prediction on the input image I. Table 7 summarizes the evaluation results. Our trained Reflector with textual coordinates achieves a remarkable ac-

Method

Adapt on SSv2

Adapt on MMG

SSv2 SSP MMG SSv2 SSP MMG Qwen2.5-VL-3B + Ours + Ours + V

80.4 88.8 77.3

20.3 30.5 18.3

57.5 66.6 53.2

80.4 87.5 77.5

20.3 30.1 17.4

57.5 68.2 54.7

Table 8: Performance comparison of our method with visual bounding box prompt and textual coordinate prompt.

Qwen2.5-VL-3B + Ours

GUI-R1 Training Set SSv2 SSP

MMG

80.4 87.8

57.5 67.2

20.3 29.2

Table 9: Performance of our method on the unsupervised training setting. curacy of 91.7%, outperforming the zero-shot base model by 15.2%. Conversely, employing visual prompts (+ V), the Trained Reflector + V only reaches 78.3% accuracy. The negative impact of visual prompting is amplified during the parameter internalization stage. As demonstrated in Table 8, leveraging drawn images (Ours + V) as the privileged visual context for the self-teacher in R-OPSD leads to negative transfer. Extension beyond Test-Time Data. While our Test-Time Self-Evolving framework is designed to adapt models to unseen interfaces after deployment, its core internalization mechanism, R-OPSD, inherently serves as an unsupervised training algorithm. Instead of episodic exploration on test sets, we train the base model directly on the training set of GUI-R1 (Luo et al. 2025a), which contains about 3000 samples. To simulate the unsupervised training setting, we only leverage the image and instruction. The results are summarized in Table 9. It is shown that our method consistently outperforms the base model across all three datasets, demonstrating its effectiveness in unsupervised training setting.

Qualitative Analysis of the Reflector To provide an intuitive understanding of the Reflector’s capabilities, we present qualitative visualizations of its evaluation process in Fig. 6. The visualization showcases the Reflector’s multi-modal reasoning across two typical testtime exploration scenarios: a successful grounding (S = 1) and a failed grounding (S = 0). As illustrated in the successful case, the Reflector accurately parses the user’s intent, spatially grounds the agent’s predicted coordinate to the corresponding UI element, and logically confirms the match. More importantly, in the failed case, the Reflector does not merely output a binary rejection. Instead, it explicitly pinpoints the exact cause of the failure within its step-by-step reflection R.

Add a new app to the desktop Add a new shortcut to the toolbar <think> The instruction intends to add a new shortcut to the toolbar. The Click Coordinate [809, 14] is positioned near the top right corner of the screen, which typically corresponds to the toolbar area. However, there is no visible toolbar or shortcut icon at this exact location. Instead, there are icons for downloading, sharing, and other functions. Therefore, the click coordinate does not correctly execute the user's instruction. </think> <answer>No</answer>

<think> The instruction intends to add a new app to the desktop. The Click Coordinate [102, 59] is positioned near the top left corner of the screen, which typically corresponds to the '+' button used for adding new apps. This is consistent with the action described in the instruction. </think> <answer>Yes</answer> View attachment

Open gallery

<think> The instruction intends to open the 'Gallery' section. The UI shows a menu with various options, including 'Gallery'. The click coordinate [105, 129] corresponds to the 'Gallery' option in the menu. This matches the intended action of opening the Gallery section. </think> <answer>Yes</answer>

(a) Successful Exploration (S = 1)

<think> The instruction intends to view an attachment, but the provided click coordinate [151, 465] is not aligned with any visible attachment icon or text. The closest element is a redacted text area, which is likely part of the email content rather than an attachment. Therefore, the click coordinate does not correctly execute the user's instruction to view an attachment. </think> <answer>No</answer>

(b) Failed Exploration (S = 0)

Figure 6: Qualitative visualizations of the Reflector’s evaluation and reasoning. The red bounding boxes denote the predicted coordinates. The yellow bounding boxes highlight the corresponding UI element.

Related documents

• Seeing Before Reasoning: Decoupling Perception and Reasoning for Shortcut-Resilient Multimodal On-Policy Self-Distillation#287147
• VisionCoach: Reinforcing Grounded Video Reasoning via Visual-Perception Prompting#665678
• VisionCoach: Reinforcing Grounded Video Reasoning via Visual-Perception Prompting#664178
• Coincidence: The Grounding Problem, Object-Specifying Principles, and Some Consequences#111914
• CLiViS: Unleashing Cognitive Map through Linguistic-Visual Synergy for Embodied Visual Reasoning#1012027