GUI-R1: A Generalist R1-Style Vision-Language Action Model For GUI Agents

## Abstract

Abstract Existing efforts in building graphical user interface (GUI) agents largely rely on the training paradigm of supervised fine-tuning (SFT) on large vision-language models (LVLMs). However, this approach not only demands extensive amounts of training data but also struggles to effectively understand GUI screenshots and generalize to unseen interfaces. The issue significantly limits its application in real-world scenarios, especially for high-level tasks. Inspired by reinforcement fine-tuning (RFT) in large reasoning models (e.g., DeepSeek-R1), which efficiently enhances the problem-solving capabilities of large language models in real-world settings, we propose GUI-R1, the first reinforcement learning framework designed to enhance the GUI capabilities of LVLMs in high-level real-world task scenarios, through unified action space rule modeling. By leveraging a small amount of carefully curated high-quality data across multiple platforms (including Windows, Linux, MacOS, Android, and Web) and employing policy optimization algorithms such as group relative policy optimization (GRPO) to update the model, GUI-R1 achieves superior performance using only 0.02% of the data (3K vs. 13M) compared to previous state-of-the-art methods like OS-Atlas across eight benchmarks spanning three different platforms (mobile, desktop, and web). These results demonstrate the immense potential of reinforcement learning based on unified action space rule modeling in improving the execution capabilities of LVLMs for real-world GUI agent tasks.
The codebase is available at https://github.com/ritzz-ai/GUI-R1.git .

## 1 Introduction

Recent studies [1; 2; 3] have explored the use of large vision-language models (LVLMs) [4] to develop graphical user interface (GUI) agents capable of performing high-level complex tasks. These agents analyze the screen as a self-contained source of information for decision-making, without relying on environment-based textual descriptions such as HTML or accessibility trees. This approach offers greater flexibility in agent decision-making. However, previous works have predominantly relied on the training paradigm of supervised fine-tuning (SFT), which not only requires large amounts of high-quality training data but also struggles to effectively comprehend GUI screenshots and generalize to unseen interfaces. These limitations have significantly hindered the real-world applicability of these works, particularly for high-level GUI tasks that lack explicit step-by-step instructions.

Rule-based reinforcement fine-tuning has recently emerged as an efficient and scalable alternative to SFT, requiring only a small number of examples to fine-tune models effectively while demonstrating strong performance and generalization capabilities in domain-specific tasks. RFT has been increasingly adopted for developing various LVLMs [5; 6; 7; 8; 9]. Inspired by these advancements, this study extends the rule-based reinforcement learning (RL) paradigm to the domain of GUI agents, which focuses on GUI action prediction tasks within a unified action space driven by high-level instructions. Specifically, LVLMs generate multiple responses (trajectories) for each input, containing both reasoning traces and final answers. These responses are evaluated using a unified action space reward function designed in this work, and the model is updated through policy optimization [10]. This iterative self-learning process enhances the model’s reasoning capabilities in action prediction and its generalization to out-of-distribution (OOD) scenarios.
By modeling a unified action space, we efficiently curate high-quality data spanning multiple platforms, including Windows, Linux, MacOS, Android, and Web, while avoiding action prediction conflicts across different platforms.

As demonstrated in Figure [1](https://arxiv.org/html/2504.10458v4#S0.F1), the proposed framework (GUI-R1) achieves superior performance using only 0.02% of the data (3K vs. 13M) compared to previous state-of-the-art methods like OS-Atlas [1] across eight benchmarks covering three different platforms (mobile, desktop, and web) and three levels of task granularity (low-level grounding, low-level tasks, and high-level tasks). Before delving into details, we clearly emphasize our
contribution as follows.

- •
We propose GUI-R1, the first framework that utilizes rule-based reinforcement fine-tuning to enhance the reasoning capabilities of LVLMs in high-level GUI action prediction tasks.
- •
We design a rule-based unified action space reward function, which efficiently validates GUI task responses across different platforms and task granularities. This ensures reliable and efficient data selection and model training.
- •
Leveraging the rule-based unified action space reward function, we construct GUI-R1-3K, which is a high-quality fine-tuning dataset with diversity and complexity. This dataset significantly improves both training efficiency and model performance.
- •
We conduct a comprehensive evaluation of GUI agents, covering three distinct platforms (desktop, mobile, and web) and three levels of task granularity (low-level grounding, low-level tasks, and high-level tasks) across eight benchmarks. Experimental results demonstrate that our GUI-R1 is leading in multiple realistic cases. This creates a strong baseline of GUI agents for future research.

## 2 Related Work

### 2.1 GUI Agents

Autonomous agents driven by large foundation models (e.g., large language models (LLMs) and large vision-language models (LVLMs)) have gained significant attention for their powerful interactive capabilities [11]. These operating systems via programs or API calls [12; 13]. However, the closed-source nature of most commercial software limits access to internal APIs or code, which promotes a shift in research toward GUI agents. Different from traditional programmatic agents, GUI agents simulate human interactions via mouse and keyboard inputs, which enable broader flexibility in solving complex tasks. Recent works have advanced this direction. For instance, UGround [14] developed a specialized GUI grounding model for precise GUI element localization. OS-Atlas [1] introduced large action models to handle general agent tasks by interpreting human intentions and predicting actions in the form of function calls. UITars [2] proposed a more comprehensive method by combining GUI-related pretraining with task-level reasoning fine-tuning to better capture the complexity of GUI interactions.
Nevertheless, these methods all rely on the paradigm of supervised fine-tuning (SFT), which suffers from two main limitations: (1) the training process requires vast amounts of diverse data; (2) the models exhibit limited generalization capabilities, which struggle to understand GUI screenshots and adapt to unseen interfaces. These limitations motivate the development of a more advanced learning paradigm for GUI agents beyond traditional SFT methods.

### 2.2 Reinforcement Fine-Tuning

Rule-based reinforcement fine-tuning, exemplified by OpenAI o1 [15] and DeepSeek-R1 [10], has demonstrated strong performance in mathematical reasoning [16], code generation [17], and multi-step logic tasks [18]. Subsequent studies have extended this paradigm to multimodal models by designing task-specific reward functions for vision-based tasks, such as correct class prediction in image classificati [19; 7; 20], intersection-over-union (IoU) metrics in image localization and detection [6; 5], and accurate click position prediction in low-level GUI grounding tasks [9]. These works demonstrate that verifiable reward signals, e.g., symbolic correctness or execution-based feedback, can effectively substitute traditional supervision.
Despite the strong potential of RFT in various tasks, it remains underexplored in complex high-level GUI agent tasks. Compared to other domains, building intelligent agents for high-level GUI tasks is particularly challenging due to diverse UI layouts, implicit task semantics, and long-horizon action dependencies. This imposes higher demands on the model’s contextual learning and understanding capabilities.
To the best of our knowledge, GUI-R1 is the first RFT-based framework specifically designed for high-level GUI agents.

## 3 GUI-R1 Framework

Figure: Figure 2: Overview of the GUI-R1 Framework. Given the high-level instruction, action history, and visual image inputs, the policy model generates multiple responses containing reasoning steps. Then the verifiable rewards, such as action type reward, click point reward, and input text reward, are used with the policy gradient optimization algorithm to update the policy model.
Refer to caption: x4.png

GUI-R1 is based on a reinforcement learning training paradigm designed to enhance the ability of GUI agents to complete sophisticated instructional tasks. As shown in Figure [2](https://arxiv.org/html/2504.10458v4#S3.F2), unlike low-level tasks, high-level GUI tasks lack explicit and fine-grained instructions, which require action predictions based on high-level task objectives and execution history. This imposes greater demands on the model’s contextual learning and understanding capabilities.

### 3.1 Preliminaries

We define the goal of GUI agents in high-level instructional tasks as understanding and executing low-level instructions to complete the high-level task $Q$, based on the current interface image $I$, and the execution history $H$. Formally, given the input $Q$, $I$, and $H$, the model generates a set of candidate responses $O=\{o_{1},o_{2},\dots,o_{N}\}$, where each response contains attributes of the predicted low-level action $o^{\text{act}}$, input text $o^{\text{text}}$, and input point $o^{\text{point}}$. Each response is evaluated using a unified action space reward function to compute its reward $\{r_{1},r_{2},\dots,r_{N}\}$. GRPO [10] is applied to estimate advantages and update the policy model under KL divergence constraints. The relative advantage $A_{i}$ of the $i$-th response is calculated as follows:

$$ $A_{i}=\frac{r_{i}-\texttt{mean}(\{r_{1},r_{2},\dots,r_{N}\})}{\texttt{std}(\{r_{1},r_{2},\dots,r_{N}\})},$ $$

where mean and std denote the mean and standard deviation of the rewards, respectively.

### 3.2 Verifiable Rewards in Unified Action Space

We adopt a unified action space modeling strategy, which extracts action space categories across different platforms and integrates them into a unified action space. This ensures that all high-level instructions can be decomposed into a sequence of atomic actions, resolving action space conflicts in multi-platform data joint training. Based on the unified action space, we design verifiable reward functions to evaluate the accuracy of predicted actions to guide reinforcement learning. We detail these verifiable rewards below.

Format reward. Following previous work [20; 10; 6], we introduce format rewards during training to evaluate whether the generated output adheres to the expected structural format, including both syntactic and semantic validity. Specifically, format rewards guide the model to generate reasoning processes and final answers in a structured format, which play a critical role in self-learning and iterative improvement during reinforcement fine-tuning. The format reward templates used in training and inference are as follows, where ‘$<$think$>$’ represents the reasoning process and ‘$<$answer$>$’ represents the final answer.

Accuracy rewards. For the model’s predicted output $o=\{o^{\text{act}},o^{\text{text}},o^{\text{point}}\}$, which consists of three components: $o^{\text{act}}$ (action type, e.g., click, scroll), $o^{\text{point}}$ (click point position), and $o^{\text{text}}$ (input text), we define the accuracy reward $R_{\text{acc}}$ as a combination of action type reward $R_{\text{act}}$, click point reward $R_{\text{point}}$, and input text reward $R_{\text{text}}$, i.e., $R_{\text{acc}}=R_{\text{act}}+R_{\text{point}}+R_{\text{text}}.$ This design provides reliable correctness rewards for all actions.

Action type reward. The action type reward $R_{\text{act}}$ is calculated by comparing the predicted action type $o^{\text{act}}$ with the ground truth action type $gt^{\text{act}}$. If $o^{\text{act}}==gt^{\text{act}}$, the reward is 1; otherwise, it is 0. This simple yet effective evaluation mechanism guides action type prediction.

Click point reward. The click point reward $R_{\text{point}}$ is calculated by comparing the predicted click point $o^{\text{point}}=[x,y]$ with the ground truth bounding box $gt^{\text{bbox}}=[x_{1},y_{1},x_{2},y_{2}]$. The calculation formula is as follows:

$$ $R_{\text{point}}=\begin{cases}1&\text{if }o^{\text{point}}\in gt^{\text{bbox}},\\ 0&\text{otherwise}.\end{cases}$ $$

Input text reward The input text reward $R_{\text{text}}$ is calculated by comparing the predicted input text $o^{\text{text}}$ with the ground truth text parameter $gt^{\text{text}}$ using the semantic $F_{1}$ score. The calculation formula is as follows:

$$ $R_{\text{text}}=\begin{cases}1&\text{if }F_{1}(o^{\text{text}},gt^{\text{text}})>0.5,\\ 0&\text{otherwise}.\end{cases}$ $$

Response reward. The final response reward is composed of format rewards and accuracy rewards, defined as:$R_{o}=\alpha R_{\text{f}}+\beta R_{\text{acc}},$ where $R_{\text{f}}$ represents the format reward, $R_{\text{acc}}$ represents the accuracy reward, and $\alpha$ and $\beta$ are weighting parameters respectively.

### 3.3 Training Data Curation

Data collection. We collect data related to GUI tasks from multiple open-source datasets, including FineWeb [21], UIBert [22], AMEX [23], RICOSCA [24], as well as portions of pretraining data from Seeclick [3] and OS-Otlas [1]. This leads to $\sim$14M examples of grounding and low-level task data. Additionally, we collect $\sim$30K high-level GUI data points from OS-Otlas instruction datasets. In total, we gather $\sim$14M examples spanning multiple platforms (including Windows, Linux, MacOS, Android, and Web) and various task granularities (grounding, low-level, and high-level).

Data filtering. To filter out low-quality data for efficient RFT, we use the Qwen2.5VL-7B [4] model to generate 10 responses for each example and evaluate them using a rule-based reward function designed for unified action space modeling. We remove the problems with an estimated accuracy of 0 or 1 to ensure a stable training process, resulting in 140K low-level data and 1.5K high-level data. Since the quantity of low-level data far exceeds that of high-level data, we randomly sample 1.5K low-level data and combine it with all high-level data to create a balanced dataset of 3K high-quality training examples, named GUI-R1-3K. The distribution of image categories, action types, and corresponding difficulty levels is demonstrated in Figure [3](https://arxiv.org/html/2504.10458v4#S3.F3).

Figure: (a) Image category quantity and difficulty distribution.
Refer to caption: x5.png

## 4 Experiments

### 4.1 Implementation Details

Training and inference details. For supervised fune-tuning (SFT), we use the QwenVL2.5-3B/7B [4] model as the base model for experiments and employ the LLaMA Factory [25] framework for one epoch of training to avoid overfitting. For RFT, we use the EasyR1 [26] framework for training over nine epochs. During inference, to ensure fairness, we apply a unified and simple prompt across all comparison methods, and conduct experiments under zero-shot prompt configurations. All experiments are conducted using 8$\times$NVIDIA A100-80G GPUs.

Evaluation benchmarks. We evaluate our model on eight agent benchmarks on three different platforms, including AndroidControl-Low [27], AndroidControl-High [27], GUI-Odyssey [28], ScreenSpot [3], ScreenSpot-Pro [29], GUI-Act-Web [30], OmniAct-Web [31], and OmniAct-Desktop [31]. We only use the test splits of these benchmarks for evaluation.

Evaluation metrics. Following Os-Atlas [1], we use three commonly adopted metrics for GUI agents in evaluation: action type prediction accuracy, click point prediction accuracy, and step success rate, denoted as Type, Grounding, and SR, respectively. In more detail, Type measures the exact match score between the predicted action types (e.g., ‘click’ and ‘scroll’) and the ground truth. Grounding evaluates the performance of GUI grounding in downstream tasks. Besides, SR represents the step-wise success rate, where a step is deemed successful only if both the predicted action and its associated arguments (e.g., point for click actions and input text for scroll actions) are correct.

### 4.2 Experimental Results

We here evaluate our GUI-R1 model by comparing it with current state-of-the-art (SOTA) models on various tasks including GUI grounding tasks, GUI low-level tasks, and GUI high-level tasks.

Grounding capability. We evaluate the grounding capability of GUI-R1 using ScreenSpot [3] and ScreenSpot-Pro [29]. ScreenSpot assesses GUI grounding performance across mobile, desktop, and web platforms, while ScreenSpot-Pro focuses on high-resolution professional environments, featuring expert-annotated tasks spanning 23 applications, five industries, and three operating systems.

As shown in Table [1](https://arxiv.org/html/2504.10458v4#S4.T1), compared to the previous SOTA model Os-Atlas-7B, which was trained with large-scale data using supervised fine-tuning (SFT), the RFT approach achieves superior performance on the 3B-sized Qwen2.5-VL model using only 0.2% of the data (3K vs. 14M). Furthermore, compared to the base models QwenVL2.5-3B/7B and the SFT-trained QwenVL2.5* 3B/7B models using the same dataset, the RFT-based GUI-R1 demonstrates significantly better performance in GUI grounding tasks. Moreover, at the 3B scale, GUI-R1 achieves substantial gains over SFT models on ScreenSpot (80.08 vs. 63.55) and ScreenSpot-Pro (25.23 vs. 13.80), representing improvements of 26.3% and 82.8%, respectively. This highlights the effectiveness of the RL training framework in leveraging small-scale datasets to achieve significant performance improvements, which demonstrates its potential as a data-efficient and scalable approach for model training in resource-constrained environments.

**Table 1: GUI grounding accuracy on ScreenSpot and ScreenSpot-Pro. All experiments are conducted under the same zero-shot prompt for fair comparison. * denotes supervised fine-tuned on GUI-R1-3K. The best results are in bold.**
| Models | ScreenSpot-Pro | ScreenSpot |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Dev | Creative | CAD | Scientific | Office | OS | Web | Desktop |  |  |  |  |  |  |  |  |  |
| Text | Icon | Text | Icon | Text | Icon | Text | Icon | Text | Icon | Text | Icon | Text | Icon | Text | Icon |  |
| Supervised Fine-Tuning |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| SeeClick | 0.6 | 0.0 | 1.0 | 0.0 | 2.5 | 0.0 | 3.5 | 0.0 | 1.1 | 0.0 | 2.8 | 0.0 | 55.7 | 32.5 | 72.2 | 30.0 |
| Os-Atlas-4B | 7.1 | 0.0 | 3.0 | 1.4 | 2.0 | 0.0 | 9.0 | 5.5 | 5.1 | 3.8 | 5.6 | 0.0 | 82.6 | 63.1 | 72.1 | 45.7 |
| ShowUI-2B | 16.9 | 1.4 | 9.1 | 0.0 | 2.5 | 0.0 | 13.2 | 7.3 | 15.3 | 7.5 | 10.3 | 2.2 | - | - | - | - |
| CogAgent-18B | 14.9 | 0.7 | 9.6 | 0.0 | 7.1 | 3.1 | 22.2 | 1.8 | 13.0 | 0.0 | 5.6 | 0.0 | 70.4 | 28.6 | 74.2 | 20.0 |
| Aria-GUI | 16.2 | 0.0 | 23.7 | 2.1 | 7.6 | 1.6 | 27.1 | 6.4 | 20.3 | 1.9 | 4.7 | 0.0 | - | - | - | - |
| UGround-7B | 26.6 | 2.1 | 27.3 | 2.8 | 14.2 | 1.6 | 31.9 | 2.7 | 31.6 | 11.3 | 17.8 | 0.0 | 80.4 | 70.4 | 82.5 | 63.6 |
| Claude** | 22.0 | 3.9 | 25.9 | 3.4 | 14.5 | 3.7 | 33.9 | 15.8 | 30.1 | 16.3 | 11.0 | 4.5 | - | - | - | - |
| Os-Atlas-7B | 33.1 | 1.4 | 28.8 | 2.8 | 12.2 | 4.7 | 37.5 | 7.3 | 33.9 | 5.7 | 27.1 | 4.5 | 90.8 | 74.2 | 91.7 | 62.8 |
| QwenVL2.5-3B* | 20.3 | 1.8 | 24.6 | 2.8 | 11.2 | 4.7 | 39.5 | 6.4 | 28.6 | 5.7 | 17.8 | 2.2 | 73.0 | 48.5 | 85.7 | 46.2 |
| QwenVL2.5-7B* | 31.4 | 1.8 | 27.3 | 3.5 | 15.7 | 5.1 | 40.7 | 7.9 | 39.7 | 8.9 | 32.4 | 6.9 | 87.8 | 68.2 | 90.3 | 62.8 |
| Zero Shot |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| QwenVL-7B | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.7 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | - | - | - | - |
| GPT-4o | 1.3 | 0.0 | 1.0 | 0.0 | 2.0 | 0.0 | 2.1 | 0.0 | 1.1 | 0.0 | 0.0 | 0.0 | - | - | - | - |
| QwenVL2.5-3B | 16.2 | 1.4 | 23.3 | 1.4 | 10.2 | 4.7 | 38.2 | 6.4 | 24.3 | 3.8 | 15.0 | 1.1 | 60.8 | 43.5 | 70.1 | 35.0 |
| QwenVL2.5-7B | 33.1 | 2.1 | 23.7 | 3.5 | 12.2 | 6.3 | 36.8 | 7.3 | 37.8 | 7.5 | 30.8 | 6.9 | 86.9 | 65.1 | 89.7 | 60.0 |
| Reinforcement Fine-Tuning |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| UI-R1-3B | 22.7 | 4.1 | 27.3 | 3.5 | 11.2 | 6.3 | 43.4 | 11.8 | 32.2 | 11.3 | 13.1 | 4.5 | 85.2 | 73.3 | 90.2 | 59.3 |
| GUI-R1-3B | 33.8 | 4.8 | 40.9 | 5.6 | 26.4 | 7.8 | 61.8 | 17.3 | 53.6 | 17.0 | 28.1 | 5.6 | 89.6 | 72.1 | 93.8 | 64.8 |
| GUI-R1-7B | 49.4 | 4.8 | 38.9 | 8.4 | 23.9 | 6.3 | 55.6 | 11.8 | 58.7 | 26.4 | 42.1 | 16.9 | 91.3 | 75.7 | 91.8 | 73.6 |

Low-level task capability. We evaluate the low-level task execution capability of GUI-R1 using four benchmark datasets: AndroidControl-Low [27], GUI-Act-Web [29], OmniAct-Web, and OmniAct-Desktop [31]. AndroidControl-Low evaluates low-level task execution on mobile platforms, while GUI-Act-Web and OmniAct-Web focus on low-level task execution on web platforms. OmniAct-Desktop is used to test low-level task execution on desktop platforms.

As demonstrated in Table [2](https://arxiv.org/html/2504.10458v4#S4.T2), our method impressively improves the success rate of GUI low-level tasks for 3B and 7B models, with the average success rate increasing from 55.65 to 80.88 at the 3B scale. Compared to UI-R1 [9], which is concurrent work also trained using RFT, our model achieves a 10-point improvement at the 3B scale, validating that RL training focused on high-level tasks can further enhance the model’s understanding of low-level instructions. Note that an interesting observation is that the use of small-scale SFT data even leads to performance degradation on some metrics such as GR on AndroidControl-Low. This limitation stems from SFT’s reliance on task-specific labeled data, which constrains the model’s ability to adapt to unseen environments. In contrast, our RFT method not only enhances out-of-distribution (OOD) generalization by optimizing task-specific rewards but also achieves this with fewer training examples, which provides a scalable and efficient alternative to traditional SFT methods.

**Table 2: GUI low-level task accuracy on GUI-Act-Web, OmniAct-Web, OmniAct-Desktop, and AndroidControl-Low. All experiments are conducted under the same zero-shot prompt for fair comparison. * denotes supervised fine-tuned on GUI-R1-3K. The best results are in bold.**
| Models | GUI-Act-Web | OmniAct-Web | OmniAct-Desktop | AndroidControl-Low | Overall |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Type | GR | SR | Type | GR | SR | Type | GR | SR | Type | GR | SR |  |  |
| Supervised Fine-Tuning |  |  |  |  |  |  |  |  |  |  |  |  |  |
| Os-Atlas-4B | 79.22 | 58.57 | 42.62 | 46.74 | 49.24 | 22.99 | 63.30 | 42.55 | 26.94 | 64.58 | 71.19 | 40.62 | 50.71 |
| Os-Atlas-7B | 86.95 | 75.61 | 57.02 | 85.63 | 69.35 | 59.15 | 90.24 | 62.87 | 56.73 | 73.00 | 73.37 | 50.94 | 70.07 |
| QwenVL2.5-3B* | 76.95 | 66.34 | 61.69 | 66.24 | 56.91 | 53.02 | 77.62 | 62.54 | 63.76 | 71.08 | 74.53 | 58.79 | 65.79 |
| QwenVL2.5-7B* | 87.66 | 84.77 | 79.89 | 81.62 | 73.45 | 73.39 | 86.23 | 80.17 | 79.80 | 84.00 | 85.74 | 64.32 | 80.09 |
| Zero Shot |  |  |  |  |  |  |  |  |  |  |  |  |  |
| GPT-4o | 77.09 | 45.02 | 41.84 | 79.33 | 42.79 | 34.06 | 79.97 | 63.25 | 50.67 | 74.33 | 38.67 | 28.39 | 54.46 |
| QwenVL2.5-3B | 56.10 | 64.28 | 55.61 | 50.63 | 46.89 | 47.02 | 56.95 | 47.97 | 46.89 | 62.03 | 74.07 | 59.32 | 55.65 |
| QwenVL2.5-7B | 86.59 | 84.39 | 78.63 | 79.15 | 71.32 | 71.21 | 84.74 | 79.89 | 79.66 | 83.44 | 87.08 | 62.50 | 79.05 |
| Reinforcement Fine-Tuning |  |  |  |  |  |  |  |  |  |  |  |  |  |
| UI-R1-3B | 75.89 | 79.43 | 67.31 | 75.42 | 61.35 | 61.33 | 73.41 | 64.12 | 63.98 | 79.15 | 82.41 | 66.44 | 70.85 |
| GUI-R1-3B | 89.86 | 87.42 | 76.31 | 88.58 | 75.10 | 75.08 | 91.86 | 78.37 | 78.31 | 83.68 | 81.59 | 64.41 | 80.88 |
| GUI-R1-7B | 90.85 | 88.06 | 80.31 | 91.16 | 77.29 | 77.35 | 92.20 | 83.36 | 83.33 | 85.17 | 84.02 | 66.52 | 83.30 |

High-level task capability. We evaluate the high-level task execution capability of GUI-R1 using AndroidControl-High [27] and GUI-Odyssey [28]. AndroidControl-High evaluates high-level task execution on mobile platforms, while GUI-Odyssey focuses on cross-app navigation scenarios, featuring high-level tasks spanning six applications and 203 apps.

As shown in Table [3](https://arxiv.org/html/2504.10458v4#S4.T3), due to our unified action space with rule-based reward modeling, GUI-R1 achieves SOTA on high-level GUI tasks. Compared to the closed-source model GPT-4o, our 3B-scale method achieves an absolute improvement of 21.06, demonstrating that RFT, in contrast to SFT, can efficiently and reliably enhance the success rate of GUI agents in real-world tasks. Furthermore, compared to UI-R1 [9], which focuses on improving low-level grounding capabilities, our model achieves an average improvement of 3.4 points at the 3B scale, with a particularly notable 27.2% lead in the step success rate on GUI-Odyssey. This indicates that RL training focused on low-level tasks is insufficient for handling complex high-level instructions. RFT designed for high-level tasks is better suited as a direction for developing GUI agent models.

**Table 3: GUI high-level task accuracy on AndroidControl-High and GUI-Odyssey. All experiments are conducted under the same zero-shot prompt for fair comparison. * denotes supervised fine-tuned on GUI-R1-3K. The best results are in bold.**
| Models | AndroidControl-High | GUI-Odyssey | Overall |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Type | GR | SR | Type | GR | SR |  |  |
| Supervised Fine-Tuning |  |  |  |  |  |  |  |
| OS-Atlas-4B | 49.01 | 49.51 | 22.77 | 49.63 | 34.63 | 20.25 | 37.63 |
| OS-Atlas-7B | 57.44 | 54.90 | 29.83 | 60.42 | 39.74 | 26.96 | 44.88 |
| QwenVL2.5-3B* | 52.05 | 49.53 | 41.22 | 43.69 | 32.21 | 27.31 | 41.00 |
| QwenVL2.5-7B* | 69.15 | 58.69 | 48.11 | 56.78 | 38.65 | 34.44 | 50.97 |
| Zero Shot |  |  |  |  |  |  |  |
| GPT-4o | 63.06 | 30.90 | 21.17 | 37.50 | 14.17 | 5.36 | 28.69 |
| QwenVL2.5-3B | 47.81 | 46.51 | 38.90 | 37.40 | 26.49 | 26.69 | 37.30 |
| QwenVL2.5-7B | 68.67 | 59.71 | 47.06 | 55.60 | 37.78 | 34.37 | 50.53 |
| Reinforcement Fine-Tuning |  |  |  |  |  |  |  |
| UI-R1-3B | 57.85 | 55.70 | 45.44 | 52.16 | 34.46 | 32.49 | 46.35 |
| GUI-R1-3B | 58.04 | 56.24 | 46.55 | 54.84 | 41.52 | 41.33 | 49.75 |
| GUI-R1-7B | 71.63 | 65.56 | 51.67 | 65.49 | 43.64 | 38.79 | 56.13 |

### 4.3 Ablation Study

Image resolution and data quality. To investigate the impact of image resolution and data quality on GUI RFT, we conduct corresponding ablation experiments, with the results shown in Figure [4](https://arxiv.org/html/2504.10458v4#S4.F4). As observed, when using the filtered GUI-R1-3K dataset, the model requires only a few updates to achieve relatively high rewards. In contrast, training with unfiltered and low-quality data necessitates significantly more training time for the model to converge, with a noticeably lower performance ceiling. To further explore the effect of image resolution on model training, we increase the image resolution to twice its original size (from 1,048,576 pixels to 2,097,152 pixels). As shown in Figure [4](https://arxiv.org/html/2504.10458v4#S4.F4), because of the high resolution of GUI task images and the small size of many UI elements, increasing the image resolution allows the model to perceive these elements more clearly, which accelerates the convergence speed of RFT and improves the performance ceiling.

Coefficients in the reward function. To explore the impact of the coefficients for format rewards and accuracy rewards in the reward function on the final performance, we conduct relevant ablation experiments, as shown in Table [4](https://arxiv.org/html/2504.10458v4#S4.T4). The results indicate that reducing the coefficient ratio of format rewards leads to consistent performance improvements. This is because format rewards are easier to learn during training and often converge early in the process. By amplifying the accuracy rewards, the advantages of providing correct answers are further emphasized, ultimately leading to more performance improvements.

Figure: Figure 4: Ablation study of image resolution and data quality.
Refer to caption: x7.png

**Table 4: Ablation study of the coeffient $\alpha$ and $\beta$ in reward function.**
| $\alpha$ | $\beta$ | AndroidControl-High | GUI-Odyssey | Overall |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Type | GR | SR | Type | GR | SR |  |  |  |
| 0.2 | 0.8 | 58.04 | 56.24 | 46.55 | 54.84 | 41.52 | 41.33 | 49.75 |
| 0.5 | 0.5 | 57.93 | 55.91 | 46.62 | 52.77 | 37.44 | 35.66 | 47.72 |
| 0.8 | 0.2 | 57.85 | 55.70 | 45.44 | 52.16 | 34.46 | 32.49 | 46.48 |

### 4.4 Visualization

In Figure [5](https://arxiv.org/html/2504.10458v4#S4.F5), we provide additional visualization of the training process. As shown in Figure [5(a)](https://arxiv.org/html/2504.10458v4#S4.F5.sf1) and Figure [5(b)](https://arxiv.org/html/2504.10458v4#S4.F5.sf2), it can be observed that the format reward converges quickly in the early stages of training, while the accuracy reward becomes the main source of differentiated rewards in the later stages of training. Furthermore, as illustrated in Figure [5(d)](https://arxiv.org/html/2504.10458v4#S4.F5.sf4), the mean response length first decreases and then gradually increases, but the “aha moment” does not occur. This may be due to the single-image input training method in a non-interactive environment, which prevents the model from autonomously tracing back the sequence of incorrect actions. Exploring multi-image high-level tasks in interactive environments could be a potential direction for inducing the emergence of the “aha moment” in future research.

Figure: (a) Accuracy reward curve with training steps.
Refer to caption: x8.png

## 5 Conclusion

This paper presents GUI-R1, which is the first GUI reinforcement learning framework grounded in unified action space rule modeling. By integrating reinforcement fine-tuning with large vision-language models, GUI-R1 enables effective contextual action prediction and verifiable reward-driven learning in GUI environments. Extensive experiments demonstrate that GUI-R1 consistently outperforms baselines on various tasks. Moving forward, we plan to extend GUI-R1 to support collaborative multi-agent interaction and robust error correction policies, enabling the system to handle complex tasks with greater scalability.

## References

- [1]
Zhiyong Wu, Zhenyu Wu, Fangzhi Xu, Yian Wang, Qiushi Sun, Chengyou Jia, Kanzhi Cheng, Zichen Ding, Liheng Chen, Paul Pu Liang, et al.
Os-atlas: A foundation action model for generalist gui agents.
arXiv preprint arXiv:2410.23218, 2024.
- [2]
Yujia Qin, Yining Ye, Junjie Fang, Haoming Wang, Shihao Liang, Shizuo Tian, Junda Zhang, Jiahao Li, Yunxin Li, Shijue Huang, et al.
Ui-tars: Pioneering automated gui interaction with native agents.
arXiv preprint arXiv:2501.12326, 2025.
- [3]
Kanzhi Cheng, Qiushi Sun, Yougang Chu, Fangzhi Xu, Yantao Li, Jianbing Zhang, and Zhiyong Wu.
Seeclick: Harnessing gui grounding for advanced visual gui agents.
arXiv preprint arXiv:2401.10935, 2024.
- [4]
Shuai Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, Sibo Song, Kai Dang, Peng Wang, Shijie Wang, Jun Tang, et al.
Qwen2. 5-vl technical report.
arXiv preprint arXiv:2502.13923, 2025.
- [5]
Ziyu Liu, Zeyi Sun, Yuhang Zang, Xiaoyi Dong, Yuhang Cao, Haodong Duan, Dahua Lin, and Jiaqi Wang.
Visual-rft: Visual reinforcement fine-tuning.
arXiv preprint arXiv:2503.01785, 2025.
- [6]
Wenxuan Huang, Bohan Jia, Zijie Zhai, Shaosheng Cao, Zheyu Ye, Fei Zhao, Yao Hu, and Shaohui Lin.
Vision-r1: Incentivizing reasoning capability in multimodal large language models.
arXiv preprint arXiv:2503.06749, 2025.
- [7]
Liang Chen, Lei Li, Haozhe Zhao, Yifan Song, and Vinci.
R1-v: Reinforcing super generalization ability in vision-language models with less than $3.
[https://github.com/Deep-Agent/R1-V](https://github.com/Deep-Agent/R1-V), 2025.
Accessed: 2025-02-02.
- [8]
Haozhan Shen, Zilun Zhang, Kangjia Zhao, Qianqian Zhang, Ruochen Xu, and Tiancheng Zhao.
Vlm-r1: A stable and generalizable r1-style large vision-language model.
[https://github.com/om-ai-lab/VLM-R1](https://github.com/om-ai-lab/VLM-R1), 2025.
Accessed: 2025-02-15.
- [9]
Zhengxi Lu, Yuxiang Chai, Yaxuan Guo, Xi Yin, Liang Liu, Hao Wang, Guanjing Xiong, and Hongsheng Li.
Ui-r1: Enhancing action prediction of gui agents by reinforcement learning.
arXiv preprint arXiv:2503.21620, 2025.
- [10]
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al.
Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.
arXiv preprint arXiv:2501.12948, 2025.
- [11]
Theodore Sumers, Shunyu Yao, Karthik Narasimhan, and Thomas Griffiths.
Cognitive architectures for language agents.
Transactions on Machine Learning Research, 2023.
- [12]
Lei Wang, Chen Ma, Xueyang Feng, Zeyu Zhang, Hao Yang, Jingsen Zhang, Zhiyuan Chen, Jiakai Tang, Xu Chen, Yankai Lin, et al.
A survey on large language model based autonomous agents.
Frontiers of Computer Science, 18(6):186345, 2024.
- [13]
Qiushi Sun, Zhangyue Yin, Xiang Li, Zhiyong Wu, Xipeng Qiu, and Lingpeng Kong.
Corex: Pushing the boundaries of complex reasoning through multi-model collaboration.
arXiv preprint arXiv:2310.00280, 2023.
- [14]
Boyu Gou, Ruohan Wang, Boyuan Zheng, Yanan Xie, Cheng Chang, Yiheng Shu, Huan Sun, and Yu Su.
Navigating the digital world as humans do: Universal visual grounding for gui agents.
arXiv preprint arXiv:2410.05243, 2024.
- [15]
Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al.
Openai o1 system card.
arXiv preprint arXiv:2412.16720, 2024.
- [16]
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al.
Deepseekmath: Pushing the limits of mathematical reasoning in open language models.
arXiv preprint arXiv:2402.03300, 2024.
- [17]
Jiawei Liu and Lingming Zhang.
Code-r1: Reproducing r1 for code with reliable rewards.
arXiv preprint arXiv:2503.18470, 2025.
- [18]
Zihan Wang*, Kangrui Wang*, Qineng Wang*, Pingyue Zhang*, Linjie Li*, Zhengyuan Yang, Kefan Yu, Minh Nhat Nguyen, Monica Lam, Yiping Lu, Kyunghyun Cho, Jiajun Wu, Li Fei-Fei, Lijuan Wang, Yejin Choi, and Manling Li.
Training agents by reinforcing reasoning, 2025.
- [19]
Zhenyu Pan and Han Liu.
Metaspatial: Reinforcing 3d spatial reasoning in vlms for the metaverse.
arXiv preprint arXiv:2503.18470, 2025.
- [20]
Fanqing Meng, Lingxiao Du, Zongkai Liu, Zhixiang Zhou, Quanfeng Lu, Daocheng Fu, Botian Shi, Wenhai Wang, Junjun He, Kaipeng Zhang, et al.
Mm-eureka: Exploring visual aha moment with rule-based large-scale reinforcement learning.
arXiv preprint arXiv:2503.07365, 2025.
- [21]
Guilherme Penedo, Hynek Kydlíček, Anton Lozhkov, Margaret Mitchell, Colin A Raffel, Leandro Von Werra, Thomas Wolf, et al.
The fineweb datasets: Decanting the web for the finest text data at scale.
In NeurIPS, pages 30811–30849, 2024.
- [22]
Chongyang Bai, Xiaoxue Zang, Ying Xu, Srinivas Sunkara, Abhinav Rastogi, Jindong Chen, and Blaise Aguera y Arcas.
Uibert: Learning generic multimodal representations for ui understanding, 2021.
- [23]
Yuxiang Chai, Siyuan Huang, Yazhe Niu, Han Xiao, Liang Liu, Dingyu Zhang, Peng Gao, Shuai Ren, and Hongsheng Li.
Amex: Android multi-annotation expo dataset for mobile gui agents.
arXiv preprint arXiv:2407.17490, 2024.
- [24]
Yang Li, Jiacong He, Xin Zhou, Yuan Zhang, and Jason Baldridge.
Mapping natural language instructions to mobile ui action sequences.
arXiv preprint arXiv:2005.03776, 2020.
- [25]
Yaowei Zheng, Richong Zhang, Junhao Zhang, Yanhan Ye, Zheyan Luo, Zhangchi Feng, and Yongqiang Ma.
Llamafactory: Unified efficient fine-tuning of 100+ language models.
In ACL, 2024.
- [26]
Yaowei Zheng, Junting Lu, Shenzhi Wang, and Y Xiong.
Easyr1: An efficient, scalable, multi-modality rl training framework, 2025.
- [27]
Wei Li, William Bishop, Alice Li, Chris Rawles, Folawiyo Campbell-Ajala, Divya Tyamagundlu, and Oriana Riva.
On the effects of data scale on computer control agents.
arXiv preprint arXiv:2406.03679, 2024.
- [28]
Quanfeng Lu, Wenqi Shao, Zitao Liu, Fanqing Meng, Boxuan Li, Botong Chen, Siyuan Huang, Kaipeng Zhang, Yu Qiao, and Ping Luo.
Gui odyssey: A comprehensive dataset for cross-app gui navigation on mobile devices.
arXiv preprint arXiv:2406.08451, 2024.
- [29]
Kaixin Li, Ziyang Meng, Hongzhan Lin, Ziyang Luo, Yuchen Tian, Jing Ma, Zhiyong Huang, and Tat-Seng Chua.
Screenspot-pro: Gui grounding for professional high-resolution computer use.
Workshop on Reasoning and Planning for Large Language Models, 2025.
- [30]
Wentong Chen, Junbo Cui, Jinyi Hu, Yujia Qin, Junjie Fang, Yue Zhao, Chongyi Wang, Jun Liu, Guirong Chen, Yupeng Huo, et al.
Guicourse: From general vision language models to versatile gui agents.
arXiv preprint arXiv:2406.11317, 2024.
- [31]
Raghav Kapoor, Yash Parag Butala, Melisa Russak, Jing Yu Koh, Kiran Kamble, Waseem AlShikh, and Ruslan Salakhutdinov.
Omniact: A dataset and benchmark for enabling multimodal generalist autonomous agents for desktop and web.
In ECCV, pages 161–178. Springer, 2024.

## Peer Reviews

confidence: 5
contribution: 2
initial_rating: 2
presentation: 3
questions: 1. Could you provide the average performance in Table 1, which can make it clear for comparison ?
2. How does the trained model perform on online benchmarks (e.g., Android World, OS-World) ?
3. Have you tried on further scaling the data or scaling the model size ? How is the performance ?
soundness: 2
strengths: 1. It is the very early attempt to apply R1-style algorithm in GUI Agent domains.
2. It leverages the rule-based unified action space reward function to construct GUI-R1-3K datasets, which is a good contribution to the community.
3. The experiments cover multiple domains.
summary: This paper proposes to incorporate RL algorithm to enhance the LLM capabilities in GUI domains, named GUI-R1. It only requires a small amount of high-quality data across multiple domains and achieves the comparable performances with previous SOTA models.
weaknesses: 1. The paper overclaims GUI-R1 as "the first reinforcement learning framework designed to enhance the GUI capabilities of LVLMs". Some early works have attempted to apply RL to GUI tasks (e.g., Mobile platform). GUI-R1 is only the early attempt to apply R1-style (rule-based reward) RL to GUI tasks.

2. The experiments lack some important baselines, such as UI-Tars series, JEDI, InfGUL-R1, GUI-G1, GUI-Owl. The comparisons with OS-Atlas and UGround are unfair, because these early works use weak VLMs as the base., for example, OS-Atlas is based on Qwen2-VL.

3. The overall technical contributions are limited. Simply applying GRPO-style loss function in GUI is not difficult. And this kind of single-turn RL has an obvious upper boundary in real applications. Actually, this paper does not evaluate on more challenging tasks / online environments.

---

confidence: 2
contribution: 2
initial_rating: 6
presentation: 3
questions: Besides the concerns I raised in weakness section above, below are other minor questions I have:

- How critical is the quality of the small training set? The paper shows that 3K curated examples are enough—but how important is that curation step? The paper shows results for 3K vs 18K training examples, but it doesn’t test how sensitive the model is to data quality. For example, what happens if we skip their reward-based filtering and use randomly sampled or noisy data? This would help justify the claim that careful curation matters.

- Among the compared baselines, only UI-R1 has been trained with RL. It would be helpful if the authors can add deeper analysis in the key differences between GUI-R1 and UI-R1.
soundness: 3
strengths: - GUI-R1 outperforms larger models like OS-Atlas and GPT-4o using only 3,000 training examples. The performance improvement is from using RL with well-designed rewards.
- Results on 8 benchmarks show clear improvements across grounding, low-level, and high-level tasks. The model also performs well across various platform, even on unseen interfaces and tasks.
summary: The paper introduces GUI-R1, a vision-language model trained with reinforcement learning to perform complex tasks on graphical user interfaces across platforms like Windows, Linux, Android, and the web. Unlike previous models that require millions of labeled examples, GUI-R1 learns effectively from just 3,000 high-quality examples using a rule-based reward system. It achieves state-of-the-art results on eight benchmarks, outperforming larger models while using far less data.
weaknesses: - The paper claims that unifying the action space helps cross-platform generalization, but it doesn’t test this directly. What would the action space look like if we do not unify? It would be helpful if we can compare to a non-unified baseline. In addition, unified action space has been proposed in ShowUI [1].

    [1] Lin, Kevin Qinghong, et al. "Showui: One vision-language-action model for gui visual agent." Proceedings of the Computer Vision and Pattern Recognition Conference. 2025.
- RFT usually is sensitive to how diverse or confident the trajectory pool is, however trajectory sampling is usually pretty example for GUI tasks. it would be helpful to understand how the number of trajectories sampled during training (e.g., 1 vs 5 vs 10) affects performance. 
- There’s no ablation on whether the <think>…</think> reasoning trace helps, hurts, or stays the same. Since the model is rewarded on both reasoning format and final action, it’s useful to test if including reasoning actually improves learning or can be dropped. Especially in the visualization examples, the reasoning traces are usually reiterating the goal, and describing what to do next, feels a little redundant given action is then being predicted.

---

confidence: 4
contribution: 3
initial_rating: 4
presentation: 2
questions: - In 3.1, you mention that “To filter out low-quality data for efficient RFT, we use the Qwen2.5VL-7B (Bai et al., 2025) model to generate 10 responses for each example”. Could you clarify that how many and what kinds of examples do you use to generate responses from Qwen2.5VL-7B? Can you share more details of this process? Why the proportion of the high-level and low-level examples after data filtering seem to be so imbalance?
- Your results in Table 9 show that GUI-GRPO outperforms standard GRPO. However, this ablation combines two distinct modifications: the maximum entropy constraint and sentence-level training granularity. Could you provide an ablation that disentangles these two components? Specifically, what is the performance of:
    - (a) GRPO + maximum entropy constraint (token-level)?
    - (b) GRPO + sentence-level granularity (no max entropy)? This would clarify the individual contribution of each component.
soundness: 3
strengths: - One of the significant strength is the demonstration of extreme data efficiency. By curating a 3K dataset (GUI-R1-3K) and using RFT, the authors achieve SOTA performance, surpassing models trained with orders of magnitude more data (e.g., 3K vs. 13M for OS-Atlas). This illuminates the important of crafting high quality trajectory data in scaling GUI agents.
- The paper thoughtfully identifies unique challenges of the GUI domain and proposes a unified action space and verifiable rewards with a novel algorithm, GUI-GRPO, to solve them.
- The data filtering strategy is an original contribution. By using a pre-trained model to generate responses and then filtering based on the reward function (keeping samples where $0 < \text{accuracy} < 1$), the authors create a dataset with a high concentration of "learnable" examples. The ablation in Figure 4 (comparing filtered vs. unfiltered data) confirms this strategy is critical for rapid convergence and a higher performance ceiling.
- The paper's evaluation is comprehensive and convincing. It spans 8 benchmarks, 3 platforms, and 3 task granularities. The inclusion of SFT-on-3K-data as a baseline is a critical control that isolates the benefit of RFT. The multitude of ablation studies (data quality, image resolution, reward components, algorithm choice) demonstrate a deep understanding of the method.
summary: This paper proposes GUI-R1, a rule-based reinforcement learning framework for training generalist GUI agents. They also introduce a rule-based unified action space and a crafted high-quality dataset.
weaknesses: - Typo at L293-294: “OS-Otlas” should be “OS-Atlas”
- The rationale of the reward design in 2.2 is not well justified. Different components of the reward are isolated. Lack of a unified equation and aggregation of the sub components.
- In 3.1 you briefly mention the data collection and data filtering process. But the details of the rationale behind the claimed data preparation method are omitted.
- Insufficient ablation study. Lack of ablation study on two components (Adding maximum entropy & sentence-level training granularity) introduced in the GUI-GRPO.

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 2
questions: See concerns mentioned above, and I have the following questions:

1. Could you provide more comprehensive ablation studies regarding the two strategies proposed in GUI-GRPO?
2. Could you include comparisons of training curves and entropy curves among PPO, GRPO, and GUI-GRPO to better illustrate the effectiveness of GUI-GRPO?
soundness: 3
strengths: 1. The writing is clear and easy to follow.
2. The chosen benchmarks are comprehensive and sufficient for evaluation.
3. Ablation studies are thorough and provide solid support for the claims.
4. GUI-GRPO effectively addresses key challenges in RL training for GUI agents.
summary: This paper proposes the first RL framework designed to enhance the GUI agents' high-level capabilities. The first contribution lies in the high-quality dataset curation method. GUI-R1-3B and GUI-R1-7B achieve great performance among various benchmarks (grounding, low-level, high-level and online). The second contribution lies in GUI-GRPO, which surpasses GRPO and PPO on GUI agent training. GUI-GRPO adds maximum entropy constraint terms to encourage exploration and changes the training granularity from token-level to sentence-level.
weaknesses: 1. **Novelty**: My primary concerns pertain to the reward design and the claimed innovations.
   - **Reward Functions**: The reward function design for GUI tasks in this work appears to lack substantial novelty. Recent advances such as VLM-R1 [1] and Visual-RFT [2] have already extended DeepSeek-R1-style reward mechanisms to multi-modal scenarios. Works like UI-R1 [3] and InfiGUI-R1 [4] introduce similar reward functions to improve action prediction accuracy, which still heavily depend on labeled data. Furthermore, SE-GUI [5], GUI-G1 [6], and GUI-G$^2$ [7] have explored non-binary and Gaussian-based rewards to strengthen GUI grounding capabilities.
   - **GUI-GRPO**: The proposed GUI-GRPO incorporates maximum entropy constraint terms to encourage exploration; however, this concept was initially explored in CISPO [8]. For sequence-level optimization, approaches such as GSPO [9] and GRPO-S [10] have proposed this prior to this work. As a result, the claimed novelty of GUI-GRPO is limited and the improvement is not specific to the GUI domain. The paper also lacks appropriate citations and further discussion of these related works.
   - **High-Level Tasks**: The only difference between high-level and low-level tasks is the addition of historical ground truth actions as prompts. The interactions remain static and single-turn, and significant limitations regarding multi-turn scenarios are not resolved.

2. **Lack of Baselines**: The experimental evaluation would be more convincing with comparisons to additional open-source models, such as InfiGUI-R1 [4] and UI-Tars [11].

**References:**

[1] VLM-R1: A Stable and Generalizable R1-style Large Vision-Language Model  
[2] Visual-RFT: Visual Reinforcement Fine-Tuning  
[3] UI-R1: Enhancing Efficient Action Prediction of GUI Agents by Reinforcement Learning  
[4] InfiGUI-R1: Advancing Multimodal GUI Agents from Reactive Actors to Deliberative Reasoners  
[5] Enhancing Visual Grounding for GUI Agents via Self-Evolutionary Reinforcement Learning  
[6] GUI-G1: Understanding R1-Zero-Like Training for Visual Grounding in GUI Agents  
[7] GUI-G2: Gaussian Reward Modeling for GUI Grounding  
[8] MiniMax-M1: Scaling Test-Time Compute Efficiently with Lightning Attention  
[9] Group Sequence Policy Optimization  
[10] GTPO and GRPO-S: Token and Sequence-Level Reward Shaping with Policy Entropy  
[11] UI-TARS: Pioneering Automated GUI Interaction with Native Agents


Decision: Reject