acceptodds
Under review as a conference paper at ICLR 2027

EASE: Efficient Mobile Agents with Self-Maintained State and Executor-Calibrated Planning for Long-Horizon Tasks

Abstract

Graphical user interface (GUI) agents have achieved strong performance by integrating perception, reasoning, and action generation within a single model, yet still struggle with long-horizon and complex tasks. Hierarchical systems address these challenges through specialized modules for planning, memory, and execution, but incur substantial inference overhead. This creates a fundamental trade-off between efficient end-to-end execution and higher-overhead hierarchical assistance. We address this trade-off with EASE-Agent, a mobile GUI agent that preserves lightweight execution while leveraging sparse strong-model assistance to improve long-horizon task performance. To realize this design, we introduce two complementary mechanisms. First, we equip the executor EASE-UI with Self-Maintained State and introduce Token-level Advantage Policy Optimization (TAPO) to reduce cross-objective interference during joint training. Second, we introduce executor-calibrated Skill Memory for task decomposition, enabling the planner to adapt subgoal granularity to the executor's capabilities. Extensive experiments demonstrate the effectiveness and efficiency of our approach. On GUI-Odyssey, EASE-UI achieves the best performance among the compared methods, with TAPO outperforming GRPO and GDPO. On MemGUI-Bench, EASE-Agent achieves 31.3% pass@3, while stronger configurations further improve performance: EASE-Agent-Pro reaches 50.0%, and EASE-Agent-Max reaches 75.0%, compared with 49.2% for Agent-S2. EASE-Agent-Max incurs only 11.1% of Agent-S2's API cost per attempt.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
GUI Agent, Multi-Agent Collaboration, Reinforcement Learning

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_AsLQOpenReview ↗
Rating
4(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper presents EASE, a mobile GUI agent that uses a lightweight executor for interaction and a stronger planner for long tasks. The executor keeps a short history summary as it works. The authors introduce TAPO to train action and summary generation together, and build Skill Memory from execution traces to help the planner choose suitable subgoals. Results on GUI-Odyssey and MemGUI-Bench show improvements in performance and efficiency.

Critical strengths
  1. Having the executor maintain its own summary is a practical way to keep the context manageable without a separate summarization call.
  2. TAPO gives actions and summaries separate training signals. This is a sensible way to account for their different roles.
  3. The experiments cover both performance and cost, with useful ablations of the main components.
Critical weaknesses
  1. The planner–executor setup and history summarization are established ideas. The paper could explain more clearly what TAPO and the skill-construction method add beyond prior work.

  2. The full system is evaluated online, but the direct comparison between TAPO, GRPO, and GDPO is limited to offline action prediction. It is unclear how much TAPO improves end-to-end task success.

  3. Repeated summarization may lose important information. The paper provides REMEMBER and task-level storage, but does not closely examine when these mechanisms fail.

Questions for authors
  1. Does TAPO outperform GRPO and GDPO in online evaluation when the planner, skill memory, and interaction budget are kept the same?

  2. How often do missing information or summary errors cause task failures, even with REMEMBER and task-level storage?

  3. How much of the cost reduction comes from fewer planner calls versus lower token usage per call? A token breakdown would be helpful.

5 comments

We sincerely thank the reviewer for the thoughtful and constructive feedback, as well as the positive assessment of our work. Due to the comment length limit, we divide our response into two parts. This first part addresses Weakness 1 and Question 3.

Reviewer (Weakness 1): The planner–executor setup and history summarization are established ideas. The paper could explain more clearly what TAPO and the skill-construction method add beyond prior work.

We agree that hierarchical planning and history summarization are established ideas. Our contributions focus on addressing two limitations in their integration.

Regarding TAPO, jointly training action generation and history summarization introduces cross-objective interference. GRPO assigns a shared advantage to both outputs, while GDPO separately normalizes rewards but still combines their advantages. TAPO instead assigns objective-specific advantages to the corresponding action and summary tokens, providing more targeted training signals. As shown in Table 5, TAPO achieves 64.9% SR, outperforming both GRPO and GDPO by 1.9 percentage points, without requiring additional rollouts or training stages.

Regarding Skill Memory, our contribution lies primarily in its role in executor-calibrated planning. While prior work primarily provides reusable procedural and operational guidance for GUI tasks, our Skill Memory guides task decomposition according to the executor's observed capabilities, avoiding overly coarse subgoals and unnecessary planner interventions. We construct Skill Memory by comparing execution outcomes across different planning granularities, rather than relying on naturally collected trajectories. As shown in Table 6, this multi-granularity construction improves pass@3 from 28.1% to 31.3%.


Reviewer (Question 3): How much of the cost reduction comes from fewer planner calls versus lower token usage per call? A token breakdown would be helpful.

Thank you for this suggestion. We provide a token-level breakdown to clarify the sources of cost reduction. M3A relies entirely on Gemini-2.5-Pro, while EASE-Agent-Pro/Max use the same model as the planner and delegate frequent GUI interactions to lower-cost executors. The following results are measured under pass@3.

ModelPlanner Calls/Att.Executor Calls/Att.Planner Tokens/Call (In/Out)Executor Tokens/Call (In/Out)Cost/Att. ($)
M3A71.35—5,783 / 76—0.5703
EASE-Pro4.5547.724,180 / 1,3943,844 / 1410.1499
EASE-Max5.1751.193,484 / 1,1183,775 / 1580.1760

For M3A, planner calls refer to all Gemini-2.5-Pro invocations.

Compared with M3A, EASE-Pro and EASE-Max reduce expensive Gemini-2.5-Pro calls by 93.6% and 92.8%, respectively, while reducing input tokens per strong-model call by 27.7% and 39.8%. Although output tokens per call increase, these results indicate that reducing expensive model invocations, rather than merely reducing tokens per call, is the primary source of efficiency gains.

This improvement comes from allocating tasks according to model capabilities: unlike M3A, which repeatedly invokes Gemini-2.5-Pro during GUI interaction, EASE delegates most GUI operations to lower-cost executors and invokes the strong planner only for task decomposition, subgoal verification, and replanning. Self-Maintained State enables the executor to maintain execution progress independently, while executor-calibrated Skill Memory further reduces unnecessary planner interventions (Figure 5). As a result, EASE-Pro and EASE-Max reduce API cost per attempt by 73.7% and 69.1%, respectively, while achieving higher pass@3 (50.0% and 75.0% versus M3A's 47.7%).

Our responses to Weakness 2 / Question 1 and Weakness 3 / Question 2 are provided in a separate comment (Part 2/2).

This is Part 2/2 of our response, addressing Weakness 2 / Question 1 and Weakness 3 / Question 2.

Reviewer (Weakness 2 & Question 1): W2: The full system is evaluated online, but the direct comparison between TAPO, GRPO, and GDPO is limited to offline action prediction. It is unclear how much TAPO improves end-to-end task success.

Q1: Does TAPO outperform GRPO and GDPO in online evaluation when the planner, skill memory, and interaction budget are kept the same?

Thank you for highlighting this limitation. We conducted additional online evaluations on MemGUI-Bench, keeping the planner, Skill Memory, interaction budget, and all other settings identical. Only the executor differs, using models trained with GRPO, GDPO, or TAPO.

Executor trainingpass@1 (%)pass@3 (%)
GRPO11.725.8
GDPO13.324.2
TAPO (EASE-Agent)19.531.3

TAPO outperforms GRPO and GDPO by 7.8 and 6.2 percentage points in pass@1, and 5.5 and 7.1 points in pass@3, respectively. These results demonstrate that TAPO's improvements extend beyond offline action prediction to end-to-end task completion.


Reviewer (Weakness 3 & Question 2): W3: Repeated summarization may lose important information. The paper provides REMEMBER and task-level storage, but does not closely examine when these mechanisms fail.

Q2: How often do missing information or summary errors cause task failures, even with REMEMBER and task-level storage?

We agree that repeated summarization may introduce errors despite the use of REMEMBER and task-level storage. To better understand these limitations, we analyzed 286 failed attempts from EASE-Agent's online evaluation (19.5% pass@1 and 31.3% pass@3, Table 2).

Each attempt was assigned to one primary failure category based on the earliest identifiable failure-related error that was not effectively corrected. We further examined whether errors in the history summary or REMEMBER mechanism contributed to each failure.

OutcomePrimary failure categoryFailures (%)Incorrect summaryProgress lostNot rememberedIncorrectly remembered
Reported completionIncorrect information used5 (1.7%)0023
Reported completionRequired operations omitted29 (10.1%)26100
Did not completeStalled during information retrieval103 (36.0%)100213
Did not completeStalled during GUI operations126 (44.1%)4000
Did not completeUnreported app/login blockage23 (8.0%)0000
Total286 (100%)401416

Primary failure categories are mutually exclusive, while memory-error annotations may overlap. We count a memory error only when the execution trace indicates that it contributed to failure. All percentages are calculated over the 286 failed attempts.

Overall, incorrect summaries contributed to 40 failures (14.0%), primarily involving falsely reporting incomplete operations as completed, misrepresenting execution progress, or incorrectly recording the outcomes of GUI interactions. In contrast, loss of progress was identified in only one case (0.3%). Incorrectly remembered information contributed to 16 failures (5.6%), leading to errors in subsequent task execution.

The two mechanisms serve complementary roles: history summaries provide a compact overview of execution progress, rather than preserving every interaction detail, while REMEMBER explicitly retains task-critical information that might otherwise be lost through repeated summarization. Nevertheless, our analysis shows that inaccurate progress tracking and missing or incorrect retained information can still contribute to task failures. We will incorporate these findings and discuss these limitations in the revised paper.

We sincerely appreciate the reviewer's constructive suggestions. We hope these additional experiments and analyses help clarify our methodological contributions and the limitations of our approach.

Thank you for your response. I have another question about Table 2: why does the model perform better on tasks involving 4 or 3 apps than on those involving 2 apps? Intuitively, tasks involving more apps would seem more difficult and might be expected to yield lower performance.

I have a similar question about task difficulty: why is performance better on hard tasks than on medium tasks? Could you explain these results?

Reviewer_Kk39OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

EASE-Agent targets long-horizon mobile GUI tasks under a cost constraint. A lightweight executor, EASE-UI (Qwen3-VL-2B trained with TAPO), emits a GUI action and a compact history summary on every step, and can store facts with a REMEMBER action. A stronger planner is invoked only to decompose the instruction, check subgoal completion, and replan. Skill memory is built from 30 tasks run under fine, medium, and coarse plans, then distilled into granularity guidelines for that executor.

Critical strengths
  1. TAPO addresses a specific failure of shared advantages. GRPO broadcasts one sequence advantage; GDPO normalizes the two rewards and then merges the advantages before the update. Eq. 5–6 standardize each reward inside the rollout group and write the advantage only onto the action span or the history span.

  2. Skill construction has a real control. Section 3.2 changes only the granularity prompt. Table 6 and Figure 5 show a success gain together with less planner time (39.7 s to 25.0 s per attempt).

  3. The full 2B loop is stronger than the 2B model alone, and the efficiency tables are multi-metric. Standalone EASE-UI is at 11.7% MemGUI pass@3 (Table 1); EASE-Agent is at 31.3% (Table 2). Against end-to-end Qwen3-VL-32B, pass@3 moves from 28.1% to 31.3% and response time from 322 s to 145 s (Table 3). Pro ties Agent-S2’s pass@3 (50.0 vs 49.2) at $0.1499 versus an estimated $1.5897 per attempt (Table 4).

Critical weaknesses
  1. The 75.0% result is a backbone change. The trained system, EASE-UI plus Qwen3-VL-32B, reaches 31.3% pass@3, behind Agent-S2 (49.2%), M3A (47.7%), and end-to-end Qwen3.8-27B (68.8%) (Table 2). Max swaps in Qwen3.8-27B and Gemini-2.5-Pro. Against that same 27B model run end-to-end, the gain is 6.2 pass@3 points (75.0 vs 68.8) at about twice the cost ($0.1760 vs $0.0813, Table 4). The abstract’s 25.8-point, 11.1%-cost comparison is across different model pairs.

  2. TAPO’s gain is too small for the interference claim. GRPO and GDPO both reach 63.0% SR; TAPO reaches 64.9% (Table 5). With the executor frozen, the three summary sources differ by 47.5 / 47.8 / 48.3 (Figure 4). One run, no interval. Eq. 8 also averages over tokens, so a longer history span weighs more than the action span.

  3. Skill memory is a 30-task Gemini distillation, and its use in Pro and Max is unspecified (Sec. 4.1). In Table 6, any skills move pass@3 from 19.5 to 28.1; the three-granularity contrast adds 3.2 points. The paper does not say whether M_skill is rebuilt for the 32B and 27B executors. Skills fit to the 2B model do not calibrate those systems.

Questions for authors
  1. For Pro and Max, was M_skill rebuilt by rerunning the three granularities with that executor, or was the EASE-UI list reused? Please report pass@3 for each configuration with and without M_skill.

  2. Please report Max and Pro with the planner/executor split removed, using the same backbones, so the 75.0 vs 68.8 gap in Table 2 can be read as a framework effect.

  3. During GUI-Odyssey training, can REMEMBER ever receive a positive action advantage? If the reference actions contain no such label, please ablate REMEMBER and the history summary separately on MemGUI and report easy / medium / hard pass@3.

  4. Please give standard deviations over at least three seeds for Tables 5 and 6, and the average token counts of the history span and the action span used in the expectation of Eq. 8.

  5. After early cutoff at four mismatches, what group size enters Eq. 5 at late timesteps, and what advantage is written on summary tokens at the last step, where Eq. 4’s future sum is empty?

5 comments

We sincerely thank the reviewer for the thoughtful and constructive feedback, as well as the recognition of our work's strengths. Due to the comment length limit, we divide our response into three parts. This first part addresses Weakness 1 and Question 2.

Reviewer (Weakness 1 & Question 2): W1: The 75.0% result is a backbone change. The trained system, EASE-UI plus Qwen3-VL-32B, reaches 31.3% pass@3, behind Agent-S2 (49.2%), M3A (47.7%), and end-to-end Qwen3.8-27B (68.8%) (Table 2). Max swaps in Qwen3.8-27B and Gemini-2.5-Pro. Against that same 27B model run end-to-end, the gain is 6.2 pass@3 points (75.0 vs 68.8) at about twice the cost (0.0813, Table 4). The abstract’s 25.8-point, 11.1%-cost comparison is across different model pairs.

Q2: Please report Max and Pro with the planner/executor split removed, using the same backbones, so the 75.0 vs 68.8 gap in Table 2 can be read as a framework effect.

Thank you for raising these important concerns. We agree that comparisons across different model backbones should not be interpreted as isolated framework gains. We provide additional experiments to clarify the contribution of the planner–executor framework and its cost trade-off.

Regarding the framework effect, Table 2 already includes end-to-end baselines using the same executor backbones as Pro and Max: Qwen3-VL-32B achieves 28.1% pass@3 versus 50.0% for Pro, while Qwen3.8-27B achieves 68.8% versus 75.0% for Max. However, these comparisons also involve a stronger Gemini planner. To further examine its influence, we introduce EASE-Agent-Max (27B Planner), which uses Qwen3.8-27B for both planning and execution while retaining the EASE framework. We also evaluate EASE-Agent-Max*, which reduces the Gemini-2.5-Pro planner's thinking budget to 128 tokens while keeping other settings unchanged.

Modelpass@1 (%)pass@3 (%)Cost/Step p@1 ($)Cost/Step p@3 ($)Cost/Attempt p@1 ($)Cost/Attempt p@3 ($)
Qwen3.8-27B (E2E)41.468.80.0021110.0020030.07950.0813
EASE-Agent-Max51.675.00.00370.00340.16770.1760
EASE-Agent-Max*49.275.00.0027080.0026900.1144630.127420
EASE-Agent-Max (27B Planner)47.776.60.0022770.0023770.1036310.114003

Regarding cost efficiency, Max* maintains 75.0% pass@3 while reducing cost per attempt by 27.6%. Using Qwen3.8-27B as the planner further achieves 76.6% pass@3 at $0.1140 per attempt, a 35.2% cost reduction relative to the original Max. Compared with end-to-end Qwen3.8-27B, this configuration improves pass@3 by 7.8 points at approximately 40.2% higher cost. These results suggest that the improvement is not solely attributable to the stronger Gemini planner, while demonstrating a more favorable performance–cost trade-off.

We will incorporate the additional results in the revision.

Our responses to Weakness 2 / Question 4 and Question 5 are provided in Part 2/3, while Weakness 3 / Question 1 and Question 3 are addressed in Part 3/3.

This is Part 2/3 of our response, addressing Weakness 2 / Question 4 and Question 5.

Reviewer (Weakness 2 & Question 4): W2: TAPO’s gain is too small for the interference claim. GRPO and GDPO both reach 63.0% SR; TAPO reaches 64.9% (Table 5). With the executor frozen, the three summary sources differ by 47.5 / 47.8 / 48.3 (Figure 4). One run, no interval. Eq. 8 also averages over tokens, so a longer history span weighs more than the action span.

Q4: Please give standard deviations over at least three seeds for Tables 5 and 6, and the average token counts of the history span and the action span used in the expectation of Eq. 8.

Thank you for these valuable observations. We agree that the 1.9-percentage-point SR improvement on GUI-Odyssey warrants further validation, and we provide additional experiments to assess its robustness and effectiveness.

Regarding statistical reliability, we further evaluated GRPO, GDPO, and TAPO across three random seeds (42, 30, and 20). Results on GUI-Odyssey are reported as mean ± standard deviation (%):

MethodTRGRSR
GRPO80.13 ± 0.2170.23 ± 0.3863.13 ± 0.12
GDPO79.97 ± 0.2170.23 ± 0.4063.00 ± 0.10
TAPO80.80 ± 0.2070.13 ± 0.2164.90 ± 0.10

For Figure 4, the frozen-executor SR is 48.37 ± 0.12 with TAPO summaries, compared with 47.40 ± 0.10 (GRPO) and 47.77 ± 0.06 (GDPO). Each GUI-Odyssey evaluation covers over 1,500 tasks and 25,000 action steps. TAPO achieves higher SR than GRPO and GDPO across the three seeds.

Regarding TAPO's effectiveness, TAPO mitigates cross-objective credit-assignment interference by assigning objective-specific advantages to their corresponding token spans (Eqs. 5–6). To further assess its impact, we compare the three trained executors on MemGUI-Bench, keeping the planner, Skill Memory, and interaction budget unchanged:

Executor Trainingpass@1 (%)pass@3 (%)
TAPO (EASE-Agent)19.531.3
GRPO11.725.8
GDPO13.324.2

TAPO improves pass@3 by 5.5 and 7.1 points over GRPO and GDPO, respectively, providing stronger evidence of its effectiveness in interactive long-horizon execution.

Regarding Table 6, we additionally evaluated the Skill Memory ablations across three seeds on the same 128 MemGUI-Bench tasks, reporting mean ± sample standard deviation (%):

Methodpass@1 (%)pass@3 (%)
w/o Skills12.24 ± 1.1918.23 ± 1.19
w/o Multi-granularity14.58 ± 0.9027.60 ± 0.90
Ours19.01 ± 0.9030.73 ± 0.90

Regarding token-length weighting, Eq. (8) averages the loss over all valid tokens in each response, without separately normalizing the action and history spans. Their average lengths are 17.381 and 33.345 tokens, respectively. Thus, the aggregate contributions of the two spans depend on their token counts. TAPO separates objective-specific advantages but does not enforce equal weighting between spans.

We will incorporate these results and clarifications in the revision.


Reviewer (Question 5): After early cutoff at four mismatches, what group size enters Eq. 5 at late timesteps, and what advantage is written on summary tokens at the last step, where Eq. 4’s future sum is empty?

Thank you for pointing out these implementation details. We clarify both cases below.

Regarding group size, Eq. (5) computes advantages across rollouts of the same task that reach timestep (t). Due to early termination after four action mismatches, the effective group size varies from 1 to 8. Terminated rollouts are not padded with zero rewards. If only one rollout remains, its normalized advantage is zero; if none remains, no training sample is generated for that timestep.

Regarding the final step, the history reward in Eq. (4) is set to zero for the last step of each rollout, whether naturally completed or terminated early, since no future actions are available. This zero reward still participates in group normalization, and the resulting history advantage is assigned to the summary tokens via Eq. (6).

We will clarify these boundary cases in the revision.

Our response to Weakness 1 / Question 2 is provided in Part 1/3, while Weakness 3 / Question 1 and Question 3 are addressed in Part 3/3.

This is Part 3/3 of our response, addressing Weakness 3 / Question 1 and Question 3.

Reviewer (Weakness 3 & Question 1): W3: Skill memory is a 30-task Gemini distillation, and its use in Pro and Max is unspecified (Sec. 4.1). In Table 6, any skills move pass@3 from 19.5 to 28.1; the three-granularity contrast adds 3.2 points. The paper does not say whether M_skill is rebuilt for the 32B and 27B executors. Skills fit to the 2B model do not calibrate those systems.

Q1: For Pro and Max, was M_skill rebuilt by rerunning the three granularities with that executor, or was the EASE-UI list reused? Please report pass@3 for each configuration with and without M_skill.

Thank you for raising this concern. We clarify how Skill Memory is constructed for different executors and provide additional ablation results.

Regarding executor-specific skill construction, we construct Skill Memory separately for EASE-Agent, Pro, and Max by running their respective executors (EASE-UI, Qwen3-VL-32B-Instruct, and Qwen3.8-27B) on the same 30 tasks under three planning granularities, following Section 3.2. Thus, Pro and Max do not reuse the Skill Memory constructed for EASE-UI. We apologize for not making this clear in Section 4.1 and will clarify it in the revision.

Regarding the ablation, we evaluate all three configurations with and without Skill Memory on 64 odd-ID tasks from MemGUI-Bench. Since the benchmark contains near-matched task pairs differing mainly in parameters, we select one task from each pair to reduce evaluation cost.

ConfigurationSkill Memorypass@1 (%)pass@3 (%)
EASE-Agentw/23.432.8
EASE-Agentw/o10.915.6
EASE-Agent-Prow/31.351.6
EASE-Agent-Prow/o20.339.1
EASE-Agent-Maxw/51.675.0
EASE-Agent-Maxw/o40.659.4
Removing Skill Memory consistently reduces pass@3 across all three configurations, supporting its effectiveness across different executors.

Regarding multi-granularity construction, we acknowledge its additional 3.2-point pass@3 improvement over skills extracted from naturally collected trajectories (Table 6). Figure 5 further shows that, under pass@1 evaluation, our method reduces planner calls and response time to 4.5 calls and 25.0 seconds per attempt, compared with 5.9 calls and 33.3 seconds without multi-granularity and 7.2 calls and 39.7 seconds without Skill Memory.

We will incorporate these ablations and clarify the executor-specific construction procedure in the revision.


Reviewer (Question 3): During GUI-Odyssey training, can REMEMBER ever receive a positive action advantage? If the reference actions contain no such label, please ablate REMEMBER and the history summary separately on MemGUI and report easy / medium / hard pass@3.

Thank you for this question. We clarify the training of REMEMBER and provide separate ablations of the two memory mechanisms.

Regarding REMEMBER training, REMEMBER was not included in the GUI-Odyssey training action space and therefore received no action advantage. Existing agent training datasets provide limited explicit supervision for when and what task-relevant information should be remembered. Instead, we introduce REMEMBER at inference time through prompt instructions and examples (Appendix E), which we found sufficient for the executor to invoke it without dedicated training. We will clarify this distinction in the revision.

Regarding the ablations, we separately disabled REMEMBER and removed history summaries from subsequent-step inputs in the trained standalone EASE-UI, keeping other settings unchanged. Results on MemGUI-Bench (%) are shown below:

MethodEasy p@3Medium p@3Hard p@3Overall p@1Overall p@3
EASE-UI31.30.00.05.511.7
w/o REMEMBER20.80.00.03.17.8
w/o History Summary18.80.00.03.97.0

Both ablations reduce task completion. The two mechanisms are complementary: history summaries track execution progress to avoid redundant actions or premature completion, while REMEMBER preserves task-critical facts for later use. These results demonstrate their benefits on easy tasks, although the 2B executor remains limited on medium and hard tasks.

We will include these results and clarifications in the revision.

We sincerely appreciate the reviewer's constructive suggestions. We hope these clarifications and additional experiments help address the concerns raised.

Reviewer_uZ6vOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

EASE-Agent is a mobile graphical user interface (GUI) framework that balances speed and accuracy by pairing a fast, lightweight executor with sparse guidance from a powerful planner for complex, long-horizon tasks. The executor (EASE-UI) handles state tracking locally and is trained using Token-level Advantage Policy Optimization (TAPO) to seamlessly learn actions without training conflicts, while the planner utilizes calibrated Skill Memory to break down tasks into subgoals tailored to the executor's abilities. Benchmark results on GUI-Odyssey and MemGUI-Bench show that EASE-Agent outperforms existing models on complex multi-step tasks while drastically reducing overall API and operational costs.

Critical strengths
  • The motivation of this work is clear and reasonable
  • The experiment results are comprehensive and promising
  • The skill memory design is practical and seems improving the empirical performance
Critical weaknesses
  • The framework proposed in this paper is more like a systems engineering implementation, so could the authors elaborate more on their technical contributions rather than the integration as a framework.
Questions for authors
  • What exactly EASE is abbreviated for?
  • How exactly merging similar entries, reconciling conflicting recommendations, and removing redundant information are done in practice? Do authors quantify the efficiency and effectiveness of this process?
  • I do not get the point why in figure 1, EASE does not need verifier. In addition, if I understand it correctly, EASE is still a hierarchical setting. Please correctly me if I am wrong, but it sounds that EASE is a hierarchical framework with additional supports in memory skill and post-training.
  • Can you elaborate more on multi-granularity trajectory collection? Why using three levels of planning prompt? Do you ablation on the number of levels to see if there is an efficient number of levels because it is intuitively that we just use two levels for contrastive analysis.
6 comments

Dear Reviewer,

We sincerely thank you for your careful review, constructive feedback, and positive assessment of our work. Due to the comment length limit, we divide our response into three parts. This is Part 1/3, addressing the Critical Weakness and Question 1.

Reviewer (Critical Weakness): The framework proposed in this paper is more like a systems engineering implementation, so could the authors elaborate more on their technical contributions rather than the integration as a framework.

Thank you for raising this important concern. We agree that the hierarchical planner–executor architecture itself is not new. Our methodological contributions lie in two complementary mechanisms that address specific bottlenecks in efficient long-horizon GUI execution:

(1) Self-Maintained State with TAPO. Without requiring a separate model call for history summarization, EASE-UI maintains a compact execution state alongside GUI action generation. We introduce TAPO to jointly optimize action generation and history summarization while mitigating interference between their learning objectives. In addition to the offline evaluation on GUI-Odyssey reported in Table 5, we conducted controlled online evaluations on MemGUI-Bench, keeping the planner, Skill Memory, and all other settings fixed while varying only the executor's training method.

Training MethodGUI-Odyssey SR (%)MemGUI-Bench pass@1 (%)MemGUI-Bench pass@3 (%)
GRPO63.011.725.8
GDPO63.013.324.2
TAPO64.919.531.3

TAPO improves GUI-Odyssey SR by 1.9 percentage points over both GRPO and GDPO (Table 5). On MemGUI-Bench, it further improves pass@1 by 7.8 and 6.2 points and pass@3 by 5.5 and 7.1 points, respectively, demonstrating that its benefits extend from offline action prediction to online task completion.

(2) Executor-Calibrated Skill Memory. Our Skill Memory guides task decomposition according to the executor's observed capabilities, helping avoid overly coarse subgoals and unnecessary planner interventions. Additional ablations across three model configurations further demonstrate its effectiveness. Since MemGUI-Bench contains pairs of structurally similar tasks differing mainly in task parameters, we evaluate these ablations on a 64-task subset, selecting one task from each pair:

ConfigurationSkill Memorypass@1 (%)pass@3 (%)
EASE-Agentw/23.432.8
EASE-Agentw/o10.915.6
EASE-Agent-Prow/31.351.6
EASE-Agent-Prow/o20.339.1
EASE-Agent-Maxw/51.675.0
EASE-Agent-Maxw/o40.659.4

Skill Memory improves pass@3 by 17.2, 12.5, and 15.6 percentage points across the three configurations, respectively. Beyond task success, Figure 5 shows that Skill Memory reduces planner calls from 7.2 to 4.5 and planner response time from 39.7s to 25.0s per attempt under pass@1, confirming its effectiveness in reducing unnecessary planning overhead.

At the system level, EASE-Agent achieves higher pass@3 (31.3% vs. 28.1%) with less than half the API response time (144.95s vs. 322.28s) of the end-to-end Qwen3-VL-32B baseline (Table 3). EASE-Agent-Pro also achieves comparable pass@3 to Agent-S2 (50.0% vs. 49.2%) at only 9.4% of its estimated API cost per attempt (Table 4).

Together, these two mechanisms enable EASE-Agent to achieve a favorable balance among task completion performance, inference efficiency, and API cost. We will further clarify these methodological contributions in the revised manuscript.


Reviewer (Question 1): What exactly EASE is abbreviated for?

EASE stands for Efficient Mobile Agents with Self-Maintained State and Executor-Calibrated Planning, reflecting the two key mechanisms of our framework.

Our responses to Questions 2 and 3 are provided in Part 2/3, and our response to Question 4 is provided in Part 3/3.

This is Part 2/3 of our response, addressing Questions 2 and 3, concerning Skill Memory consolidation, integrated verification, and the hierarchical architecture of EASE.

Reviewer (Question 2): How exactly merging similar entries, reconciling conflicting recommendations, and removing redundant information are done in practice? Do authors quantify the efficiency and effectiveness of this process?

Thank you for raising this question. We clarify the practical consolidation procedure and quantify its efficiency.

Regarding skill consolidation, we first extract candidate skills from execution trajectories of the same task under different planning granularities. Each skill contains applicability conditions, planning recommendations, and execution evidence. An LLM then groups candidate skills across tasks by the planning decisions they address, bringing together similar or opposing recommendations. Within each group, the LLM applies these consolidation rules:

Planning RecommendationsApplicability ConditionsExecution EvidenceConsolidation Strategy
SameSame—Merge into one rule and remove redundancy
SameDifferent—Merge into one rule while preserving the applicable conditions
OpposingDistinct, non-overlapping—Consolidate into a conditional rule specifying when each recommendation applies
OpposingSameOne better supportedRetain the recommendation with stronger execution evidence
OpposingSameInconclusiveDiscard the conflicting recommendations

Regarding efficiency, we analyzed the skill library constructed for Qwen3-VL-32B-Instruct using 30 tasks:

  • Extraction: 30 Gemini 3.1 Pro Preview calls produced 67 candidate skills, averaging 7,731 input and 703 output tokens per call.
  • Grouping: One LLM call organized 67 candidates into 30 groups, including 15 singletons requiring no consolidation.
  • Consolidation: Two LLM calls consolidated the remaining 15 groups. Across grouping and consolidation, the three calls averaged 3,801 input and 3,006 output tokens per call.

Output token counts include reasoning tokens.

Overall, the 33 LLM calls incurred an API cost of only USD 0.85 under standard Gemini 3.1 Pro Preview pricing, demonstrating low offline skill-processing overhead.


Reviewer (Question 3): I do not get the point why in figure 1, EASE does not need verifier. In addition, if I understand it correctly, EASE is still a hierarchical setting. Please correctly me if I am wrong, but it sounds that EASE is a hierarchical framework with additional supports in memory skill and post-training.

Thank you for these questions. We clarify EASE's verification process and architectural contributions.

Regarding verification, EASE does not eliminate verification; instead, this functionality is integrated into the planner rather than implemented as a separate verifier module. As described in Section 3.1 (Eq. 3), when the executor reports subgoal completion or inability to proceed, the planner assesses the execution outcome based on the available context. It then advances to the next subgoal if verified as complete, or revises the current one otherwise. We agree that Figure 1 could make this distinction clearer and will clarify the integrated verification process.

Regarding the architecture, EASE and the rightmost design in Figure 1 are both hierarchical planner–executor systems (Section 3.1). We will rename the latter “Module-Intensive” to describe the illustrated design with separate planning, execution, memory, and verification modules, which may introduce additional inference and coordination overhead. In contrast, EASE improves planner–executor collaboration through executor-calibrated Skill Memory, which aligns subgoals with the executor's capabilities and reduces unnecessary planner interventions, and a TAPO-trained executor, which jointly generates GUI actions and maintains execution state in a single model call. Our goal is therefore not to introduce a new architectural paradigm, but to improve the effectiveness and efficiency of existing hierarchical agents through these two methodological contributions.

Our response to Question 4, concerning multi-granularity trajectory collection, is provided in Part 3/3.

This is Part 3/3 of our response, addressing Question 4, concerning multi-granularity trajectory collection and the choice of planning granularities.

Reviewer (Question 4): Can you elaborate more on multi-granularity trajectory collection? Why using three levels of planning prompt? Do you ablation on the number of levels to see if there is an efficient number of levels because it is intuitively that we just use two levels for contrastive analysis.

Thank you for this insightful question. We would like to clarify the motivation for using three planning granularities and provide an additional ablation study.

Motivation. Multi-granularity trajectory collection characterizes the executor's capabilities by comparing its performance under different subgoal decompositions of the same task, identifying which operations can be reliably combined or should be separated. Comparing only fine- and coarse-grained plans may overlook suitable intermediate decompositions, while exploring more granularities can provide richer evidence for constructing executor-calibrated planning skills.

Additional ablation. To examine whether two levels are sufficient, we constructed Skill Memory using only fine- and coarse-grained trajectories, excluding the medium level, and evaluated it on MemGUI-Bench (128 tasks).

Planning Granularitiespass@1pass@3
Fine + Coarse (2 levels)15.626.6
Fine + Medium + Coarse (3 levels, ours)19.531.3
Improvement+3.9+4.7

Experimental Analysis. Including the intermediate granularity improves pass@1 and pass@3 by 3.9 and 4.7 percentage points, respectively. Trajectory analysis of the two-level setting identified 10 tasks with problematic subgoal decompositions, including overly combined operations beyond the executor's capabilities and unnecessarily separating related operations(e.g. starting and stopping a recording or entering a note's title and body). These findings suggest that two-level comparisons may provide insufficient evidence to adequately characterize the executor's capabilities for task decomposition.

We do not claim that three levels are theoretically optimal. In a preliminary exploration with four granularities, we observed substantial overlap with the three-level setting in both extracted skills and resulting subgoal decompositions. Given the additional collection and processing costs, we adopt three levels as a practical trade-off between informative capability exploration and construction overhead.

We sincerely appreciate the reviewer's constructive suggestions. We hope these clarifications and additional experiments help address the concerns raised and better explain our methodological contributions and design choices.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.