K²-Agent: Co-Evolving Know-What and Know-How for Hierarchical Mobile Device Control
Authors: Zhe Wu
Donglin Mo
Hongjin Lu
Junliang Xing
Jianheng Liu
Yuheng Jing
Kai Li
Kun Shao
Jianye HAO
Yuanchun Shi
Venue: ICLR 2026 Poster (2026)
Keywords: LLM/VLM Agent
Self-Evolving Agent
Mobile Device Control
Decision-Making
Primary area: applications to robotics, autonomy, planning

Abstract: Existing mobile device control agents often perform poorly when solving complex tasks requiring long-horizon planning and precise operations, typically due to a lack of relevant task experience or unfamiliarity with skill execution. We propose $\textbf{K²-Agent}$, a hierarchical framework that models human-like cognition by separating and co-evolving declarative ("knowing what") and procedural ("knowing how") knowledge for planning and execution. K²-Agent’s high level reasoner is bootstrapped from a single demonstration per task and runs a Summarize–Reflect–Locate–Revise (SRLR) loop to distill and iteratively refine task-level declarative knowledge through self-evolution. The low-level executor is trained with our curriculum-guided Group Relative Policy Optimization (C-GRPO), which (i) constructs a balanced sample pool using decoupled reward signals and (ii) employs dynamic demonstration injection to guide the model in autonomously generating successful trajectories for training. On the challenging AndroidWorld benchmark, K$^2$-Agent achieves a new $\textbf{state of the art}$ with $\textbf{76.1\% success rate}$, ranking $\textbf{1st}$ among all methods $\textbf{using only raw screenshots and open-source backbones}$. Furthermore, K²-Agent shows powerful dual generalization: its high-level declarative knowledge transfers across diverse base models, while its low-level procedural skills achieve competitive performance on unseen tasks in ScreenSpot-v2 and Android-in-the-Wild (AitW).

Published as a conference paper at ICLR 2026
K2- :Z-AGENT: CO-EVOLVING KNOW-WHAT AND KNOW- How FOR HIERARCHICAL MOBILE DEVICE CONTROL
Zhe Wu Donglin Mo Hongjin Lu' Junliann Xingi
Jianheng Liu", Yuheng Jing', Kai Li", Kun Shao", Jianye Hao?, Yuanchun Shi! Department of Computer Science and Technology. Tsinghua University Huawei Noah's 's Ark Lab, Institute of Automation, Chinese Academy of Sciences
ABSTRACT
Existing mobile device control agents often perform poorly when solving com- plex tasks requiring long-horizon planning and precise operations, typically due to lack of relevant task experience or unfamiliarity with skill execution. We propose K2-Agent, a hierarchical framework that models human-like cogni- tion by separating and co-evolving declarative ("knowing what") and procedu- ral ("knowing how") knowledge for planning and execution. K2-Agent's high level reasoner is bootstrapped from single demonstration per task and runs a Caamaarize-Rfleet--Leee
Revise (SRLR) loop to distill and iteratively refine task-level declarative knowledge through self-evolution. The low-level executor is trained with our curriculum-Pe -uudeeg Group Relative Policy Optimization (C- GRPO), which (i) constructs balanced sample pool using decoupled reward sig- nals and (ii) employs dynamic demonstration injection to guide the model au- tonomously generating successful trajectories for training. On the challenging AndroidWorld benchmark, K²-Agent achieves a 76. % success rate using only screenshots and open-source backhones. Furthermore, K2-Agent shows pow- erful dual generalization: its high-level declarative knowledge transfers across diverse base models, while its low-level procedural skills achieve competitive per- formance unseen tasks in ScreenSpot-v2 v2 and Android-in-tee Wild (AitW).
Human level
80
Ke-Agent
AutoGLM
Mobils-Agcat-vd
UI-TARS-2 X
U-
Se
Success (%))
60
App Menrey Pregnes 2
55
Agent S2
Round 4-4)
50
U-Venng-
LI-TARS
45
Ape Nartery Nogeur Reae
tasks sohved tades app.
35
K3-Agent
K7-Agent w/o hierarchy
K7-Agent w/o loop
Evolution round
Figure 1: K2-Agent's co-evolutionary learning curve on AndroidWorld. The main curve shows the agent's 'ss success rate steadily improving. Ablations (lower curves) confirm the contribution of key components, and subplots below illustrate the expanding mastery over new apps and tasks. "Equal contribution
1 "Corresonndigg Author: jlxing@ssingghuu.cd...

---

Published as a conference paper at ICLR 2026
INTRODUCTION
Human intelligence relies on a fundamental distinction between two types of knowledge (Squire) 2009]: declarative knowledge (knowing what) and procedural knowledge (knowing how). Declar- ative knowledge is symbolic and explicit; it can be articulated, summarized from one or few demonstrations, and refined through recall. In contrast, procedural knowledge manifests as exe- cutable skills (e.g., cycling, swimming). It is often implicit, difficult to verbalize, and acquired through repeated practice to form "muscle memory". These two knowledge systems, believed to be supported by distinct cognitive circuits (Squire & Knowlton, [195), are co-activated in complex tasks-one to decide what to do, the other to determine how to do it.
This division of labor is especially critical for long-horizon mobile device control. Recall when you performed a multi-step task in an unfamiliar app. You need declarative knowledge about the task to guide the generation of operational intent. For example, you need to know in advance that clicking the "trash icon" means delete. At the same time, you need procedural knowledge to accurately translate that intent into atomic actions such as clicking, swiping, and text input.
Existing methods for mobile device control (Li et al. | 2024) largely fall into two lines. (i) Training- free agents (Zhang et al., 2025; Wang et al. 2024b] Agashe et al.) 2024 2025). These agents carefully design workflows and encode relkere knowledge into prompts or in-context exam- ples. Development relatively cheap and edits are quick, but their performance is capped by the foundation models, which are often closed-source and cannot be fine-tuned to fix domain-specific,
persistent errors. (ii) Learning-baat -aased agents (Hong et al., 2024 Pan et al. 2024: Zhang & Zhang
2023 Bai et al. 2024: Wang et al., 2024c). These agents train parametric policies with supervised fine-tuning (SFT) or reinforcement learning (RL) on large labeled datasets. While stable on in- distribution actions, they struggle with long-horizon credit assignment and poor task generalization.
On the decision paradigm, recent work increasingly separates reasoning from action (Qin et al, 2025 Gu et al. 2025), adopts an explicit planner-executor hierarchy (Agashe et al. 2024 2025) In practice, this design often beats flat policies. However, most hierarchies remain only a structural split. Either both layers are training-fre ffree or both trained with SFT/RL. This results in systems lying either on extensive manual design or on massive amounts of data and computational resources (typically requiring 10k+ samples and hundreds of GPUs) (Qin et al.] 2025 Gu et al. 2025). Our key insight is that know-what and know-how naturally match the hierarchical design; they should follow different update rules and co-evolve through continuous interaction.
To this end, we propose K²AAget,, a hierarchical planner-executor framework for mobile device control. explicitly decouples and co-evolves declarative (know-what) and procedural (know-how) capabilities, while connecting high-level planning and low-level execution through clear single-step sub-goals. The high-level planner starts from one demonstration per task and runs Summa- Pize-RefecttLLoateeRRe
(SRLR) loop that keeps updatable task memory. Using execution feedback collected in the loop, SRLR locates failure points and revises the knowledge so the plan improves over time. The low-level executor is trained using our curriculum- -orruudlum-uieddd Group Relative Policy Optimization (C-GRPO). The method first decouples task exccution rewards across action- type and parameter dimensions, routing samples into different experience pools by error type for proportional sampling. It then introduces a dynamic demonstration injection that prepends variable- length expert prefixes to the model's prompts, conditioned on sample difficulty and training stage. This guides the model to autonomously generate successful trajectories for GRPO-style training, thereby building reusable skill library. These two evolutionary processes are mutually coupled, forming closed-loop system where "thinking" and "practice" reinforce each other.
On the challenging AndroidWorld benchmark (Rawles et al. 2024p, K2- ---Attet sets a new SOTA with a 76.1% % success rate. This surpasses all leading learning- based models (Qin et al. 2025 Gu al., 2025 Ye et al.) 2025) and rivals top closed-source models (FinalRun) (025) that leverage additional inputs from the accessibility (A1 tree. More importantly, K K²-Agent attains this with high efficiency: the planner requires only one demonstration per task, and the executor is trained on single server equipped with 8x NVIDIA A100 80GB GPUs. Moreover, K2-Agent exhibits dual generalization that supports our core hypothesis: (1) Declarative knowledge transfer -te high- level planner's 's learned knowledge transfers across backbone models; and (2) Procedural knowledge transfer the executor's learned skills generalize to entirely novel tasks on Android-in -n-thhhh------------eeeeeeeeeeee Wild (AitW) (Rawles et al. 2023) and ScreenSpot-v2 (Wu et al. 2024
2

---

Published as a conference paper at ICLR 2026
update SRLR
Create contact for (name). Their number is (number).
Declorative Knowledge
Procedural Knowledge
damin
Summorizert
High-level Reasoner
Low-level Executor
+
Single Demonstration
Declarative
DB
Procedural Knowledge
Knowledge
Bootstrapp:
High leve! Reasoner
Low level Executor
update via C-GRPO
The SRLR loop where declarative knowledge (knowing what) is iteratively improved using feedback. Bottom: The skill acquisition process where proce- dural knowledge (knowing how) is learned via C-GRPO, bootstrapped from single demonstration.
Figure 2: Overview of the K²-Agent. Top:
To summarize, our contributions are as follows:
We introduce K2-Agent, a hierarchical framework that enables closed-loop co-evolution of declarative and procedural knowledge.
We design soggle-demmosttation-nnniin tion feedback to refine task knowledge base.
SRLR cycle that continuously incorporates execu-
We propose a curriculum-guien -ugidddd RI. algorithm (C-GRPO) that efficiently acquires procedural skills via crror-decoupeed experience-porr pool balancing and dynamic demonstration injection.
We provide extensive evidence of dual generalization declarrriee knowledge across back- bones and procedural skills across benchmarks highlightin the critical role of co-evolution in enhancing generalization.
RELATED WORK
2.1 TRAINING-FREE AGENTS
Training-free agents leverage the in-context learning capabilities of large vision-language models (VLMs) to solve mobile control tasks carefully engineered prompts and reasoning loops (Zhang
ct al. 2025 Wang al. 2024b). Recent works have explored various mechanisms, such building explicit knowledge bases (Zhang et al. 2025), incorporating reflection steps (Wang et al. (024b), or adopting multi-agent (Wang al. 2024a) and hierarchical architectures (Agashe al. 2024 2025 Wang et al. 20256). While these methods excel at leveraging the fixed knowledge of powerful foundation models, their self-improvemeent mechanisms are typically non-parametric (e.g.. memory editing). In contrast, K²-Agent introduces a hybrid approach: it uses a non-parametric SRLR loop to evolve declarative knowledge while simultaneously fine-tumin tine-tuning dedicated executor with C-GRPO to parametrically improve its procedural skills through interaction.
2.2 LEARNING- BASED AGENT
Learning-basee based agents fine-tune models on domain-specific data to adapt them for mobile control.
The field has rapidly progressed from initial SFT GUI understanding (Hong et 2024 Zhang
& Zhang 2023) to RL for interactive decision maaiinn (Bai et al.) 2024 Waan et al. 2024c). With
the advent of advanced policy optimization techniques like DPO (Rafailov et al.) 2023) and GRPO
(Shao et al., 2024), recent models have achieved significant gains in grounding and task success by post-training strong open-source VLMs (Qin et al. 20255 Lu et al., 2025 Luo et al. 2025 Liu al., 2025b Gu et al. 2025). However, these methods typically train single, monolithic policy, which conflates the learning of high-level task strategy ("knowing what") and low-level action execution ("knowing how"). A2-Agent's core distinction is the explicit decoupling of these two learning pro- cesses. By using different, specialized update rules for declarative and procedural knowledge, our framework enables more targeted, data-efficient, and effective learning for both.
3

---

Published as a conference paper at ICLR 2026
3 PRELIMINARIES
We model mobile device control as a finite-horizon Markov Decision Process (MDP) M (S, A. P, (), . A state E S is multimodal representation (0r, 9), where Or is the current visual observation of the screen (we use only raw screenshots, without any extra UI metadata such as the accessibility tree) and is the task instruction. The action space A consists of parameterized primitive UI operations, such as click, long-press, swipe, and type. The transition func- tion P(s++1 St, az) defines the probability of moving 8141 after taking a, in 8t. The reward function R. provides environmental feedback. This feedback can be sparse trajectory-Ievel rewards, indicating overall task success; dense step-level rewards, guiding fine-grained action generation. The discount factor is The agent's objective is to learn a policy π (aa st) that maximizes the
expected return: (x) = E Ei=0
4
METHOD
We propose K--Agent, a hicrarchical framework that mirrors human cognition by separating and co- evolving declarative ("knowing what") and procedural ("knowing how") knowledge. Section 4.1 outlines our design. Section 4.2 details the high-level planner that evolves declarative knowledge through SRLR ceff-improvement loop. Section 4.3 introduces C-GRPO for learning procedural skills in the low-level executor. Section
4.4 provides implementation and training details.
4.1 OVERVIEW OF THE K2-AGENT FRAMEWORK
As shown in Figure K2-Agent features two-layer layer is initialized by a VLM. The high-level planner, тH operates a training-fres mode to main- tain a declarative knowledge base, Kg. which is iteratively refined via our SRLR loop. Rather than acting directly on the environment, ти consults KG to decompose the global task g into a sequence of immediate sub-goals, 24. The low-level executor, TT. . trainable policy that acquires procedural skills via C-GRPO algorithm. It receives the current observation and the sub-goal 2, from тH, making decisions in augmented state s = (ot, 9; 2+) to produce atomic actions on the device.
architecture, where each
The two modules form closed-loop co-evolution system. Forward communication occurs via the sob-ggoas 24. The feedback loop consists of execution outcomes successes, failures, and error patterns-from Tr being used by лн to revise the knowledge base Kg. A more accurate KG allows тH to generate more feasible and executable sub-goals, turn providing Tr. with a more structured exploration problem and thus more effective learning signals. This creates a synergistic cycle where improved planning and execution reinforce one another.
4.2 HIGE-LEVEL PLANNER: EVOLVING DECLARATIVE KNOWLEDGE VIA SRLR LOOP
The planner, TH. evolves its declarative knowledge base, KG. through four-stage SRLR loop, illustrated in Figure 3 This self-improvement cycle is initiated by a single expert demonstration and performed by the VLM-based planner itself. We detail each stage below. Complete implementation details and a case study of KG evolution are provided in Appendix B.T
4.2.1 SUMMARIZE
Given single demonstration trajectory T (st at) )T and task goal g. T performs one-pass distillation to produce structured initial task knowledge base K (Figure top-left);
KU = Summarize
0n))
(1)
The knowledge base is represented as a set of rules stepwise checklist that captures the core logic for completing the task, key UI elements, and their functions. serves as the starting point for subsequent iterations in the SRLR loop.
4.2.2 REFLECT
During execution, the reflection module is activated upon completing a new trajectory T Reflec- tion operates at granularities:
4

---

Published as a conference paper at ICLR 2026
(1) Summarizze
(2) Reflect
Instruction1:
Swipe up locate the Recarder app
Step-level Reflection
Task-level Reflection
Actionl: ( "swipe" "coordinate:: (1546, 1806]. (546, 602]))
You handling Audio-related tosk.
First. you need xXx. Then, xoox
Declarative Knowledge
(4) Revise
(3) Locate
you MUST by swiping up
access the app drower.
To stort recording, top the prominent circular button xxx After
the the
button the bottom
3
Then,
store audia. X
Highlight Delete
Add
Update
Analysis: Step is cornect, step missing and step should highlight xx
xx,
Figure 3: An illustration the SRLR self-evolution loop. (1) Summarize: An initial knowledge base is automatically distilled from a demonstration. (2) Reflect: The agent analyzes its execution trace to identify deviations. (3) Locate: The failure's root cause is pinpointed. (4) Revise: Atomic operators repair the knowledge base for the next iteration.
The planner continuously verifies whether each action's outcome aligns with the ex- pected result in Kg. This allows for the immediate detection of deviations from the plan.
Step-level.
Task-level. If the episode fails, task-level reflection analyzes the entire trajectory generate structured, root-cause explanation for the failure, such as "failed to identify the Rename button":
Mrsse
Reflectrask (T KG, g On)-
4.2.3 LOCATE
To enable precise revision, the locate module aligns the executed trajectory T with the task knowl- edge encoded in Ka and identifies the first decision point that yields an unexpected outcome:
t" = Locate(T", Kei 0H)) = min {
Verify (5 of KG. t; 0n)) = False }.
(3)
Here, Verify(-) E (True, False) checks whether executing of in state sf produces a next state si41 that matches the expected outcome for critical step t specified by Kg.
4.2.4 REVISE
Finally, given the failure explanation M and the failure point (L*, sf-).. the system performs local surgeries KG using four atomic operators: Add inserts missing steps; Delete removes erroneous instructions; Update modifies parameters; and Highlight emphasizes critical constraints. These operations yield revised version K' (see evolution example in Appendix[B.I]
K' Revise (raise(Ka, (t", s(-,, Mcase; 0,r)
(4)
By iterating the SRLR loop, the KG improve over time, enabling higher-quality planning.
4.3 LOW-LEVEL EXECUTOR: LEARNING PROCEDURAL. SKILLS WITH C-GRPO
Training the low-level executor, TL, faces two challenges: (i) Sample Imbalance: The training data is often biased, with common operations (c.g.. click) heavily more than rare ones (c.g.. long-press, swipe). (ii) Inefficient Exploration: In long-horizon tasks, the huge action space makes difficult for agents to autonomously discover successful trajectories through trial and error.
To address these issues, we propose Curiiulum--uidee Group Relative Policy Optimization (C- GRPO), an algorithm that efficiently acquires procedural skills via a novel error-decoupeed replay balancing mechanism and dynamic demonstration injection strategy.
5

---

Published as a conference paper at ICLR 2026
Update GRPO
type
Dynomic Demonstration Injection
oj
rj
A
Query-1
Query-1
o
A
D cmm
Query-n
Query-2 Hint-1
Policy Model
of
4
Query-1
Query-n
Query-3 Hint-1
Hint-2
m
Fm
A
param
Query-1
Query.4
Hint-1
Hint-2
Oel
Query-n
Procedural Knowledge
A
Srror-Decouples Reploy Balancing
Figure 4: Our C-GRPO framework, featuring its two main curriculum components: Error- Decoupled Replay Balancing (left) to construct balanced mini-batches, and Dynamic Demonstration Injection (center) to provide adaptive guidance for the GRPO update (right).
4.3.1 ERROR-DECOUPLED REPLAY BALANCING
We observe that execution errors at the action level can be decoupled into type errors (e.g., predicting swipe instead of click) and parameter errors (c.g., a click with inaccurate coordinates). For any training input i, the low-level model πL generates candidate actions {a (9) G expert action dj, define binary reward
19=1- Given an
rla, à) type((a) type(ā) A ||coord(a) coord(a)]l, -coord(())corr(())]]) < <e].
(5)
where type(.) denotes the primitive operator (click, long-press, swipe, type), and coord(.) 2 denotes the action's spatial parameters.
Using the G' candidates, we estimate two error rates per input i:
Mtype G
1 Σ
I(yppe(a.) * type((,)),
(6)
1/paaam (1) G
1 [iyeea type(á:) A [coord(a! -coord(a))l 2 Σ
Based on (t)pe (i) and Mparam (i), each input is dynamically assigned to one of three replay buffers: the conventional pool Deon. the oppe-xxploration pool Drype. and the precision-optinie Dparam- During training, each mini-bater formed by sampling from these buffers with preset ra- tios {Beon: Stypes 3param ), ensuring balanced progress on the model's different weaknesses, leading more efficient overall improvement.
pool
4.3.2 DYNAMIC DEMONSTRATION INJECTION
For mobile control agents built (V)LLMs, the action space effectively spans vast textual space grounded to the entire screen. Replay balancing alone cannot make the model reliably discover the correct action sequence in such large space, rewards remain sparse complex tasks. To guide exploration, we introduce a dynamic demonstration injection mechanism that prepends a variable number of atomic expert actions to the input. The injected length (in steps) is scheduled by
(8) where L is the total number of steps in the full demonstration; (kk) = max (0, 1 1-kk k/KKmx)) is lin- annealing scheduler that decays with the training step k; fgate (d,) tanh (d.h(dd// dTT)) is a difficulty- gating function controlled by a temperature T; and the sample difficulty score d, is the total error rate, d; Ttype (i) + 7param (i). The actual prefix consists of the first [1] complete actions.
1 La (k, d:) = I. (kk) Sgate (dd:)

---

Published as a conference paper at ICLR 2026
Intuitively, this mechanism provides more extensive guidance for samples the model currently finds difficult, while gradually weaning the model off all demonstrations as training progresses. This curriculum-bast approach greatly increases the probability of generating successful trajectories, thereby producing denser and higher-quality signals for policy optimization.
4.3.3 C-GRPO OBJECTIVE
Our final objective integrates these curriculum strategies with the GRPO framework. In each training step, we construct a balanced mini-batch B and, for each sample g B, form an augmented context e using dynamic demonstration injection. The policy then updated by maximizing the GRPO objective, where the advantage estimates A,, are derived from group-relative rewards based on the dense, binary expert-matching signal defined in Equation 5
The objective is:
loil
Te: c) = -
min (rr,(0) Ana, clip(ra, c, )) A.t)
~oa (1)))
G
O
(9)
where the importance ratio (0) Tol0,.l000
(c,0),c))) By optimizing this objective, C-GRPO learns
robust procedural skills with denser and more informative signals.
4.4 TRAINING AND IMPLEMENTATION DETAILS
We use (wwn-2.5-VVL-721 as the high-level planner (нH) in the training-free SRLR loop, and the parameter-effiiient Qwen-2.5-1 2L5-VL-7B as the low-level executor (TL), which is post-trained with C- GRPO. The planner's ' knowledge base (KG) is bootstrapped from single expert demonstration, which we recorded for each task type through a dedicated data collection pipeline (data collection, cleaning, and scale are reported in Appendix [B.1.2). For the learning-base -bate executor, the C-GRPO training set is constructed from demonstration samples collected across all AndroidWorld tasks, ensuring strict separation between training and test sets. The executor's ss training is guided by dense, step-level reward signal composed of a binary format reward (for syntactic correctness) and content reward (Equation 5 for semantic correctness). Further details on data format, dataset scale, and reward computation are provided in Appendix B.2
To conserve computational resources, the co-evolution the planner and executor implemented via an efficient alternating update mechanism that follows the pattern (SRLR, )* + C-GRPO,- We set n in our experiments, where the planner first refines its knowledge base KG over several iterations before the executor undergoes single, intensive training phase. All training was conducted on a single server equipped with 8x NVIDIA A100 80GB GPUs. complete list of hyperparameters used during training is available in Appendix B.2.3
5 EXPERIMENTAL EVALUATION
We conduct extensive experiments to evaluate our Ka-Agent. This section is organized as follows. In Section 5.1] we evaluate on the AndroidWorld benchmark and achieve a new state-of-the-ar (SOTA). In Section 5.2) we study generalization along two axes: transfer of high-level declarative knowledge across different backbones, and transfer of low-level procedural skills across bench-
marks. In Section 5.3 we present ablations that quantify the contribution of each core component.
5.1 PERFORMANCE AGAINST BASELINES
Environment. We evaluate on AndroidWorldd
al. 2024 widely used benchmark with
116 tasks across 20 apps. Each task is instantiated with randomized parameters per episode, pre- venting overlap between the training and test splits. Tasks are categorized by difficulty (casy/medi- um/hard). Human experts achieve about 80% (Rawles al. 2024 average success this platform.
Baselines. We compare K2 ---Agent to two families of methods: (1) Training-free agents that rely on few-shot capabilities of (V)LLMs (e.g., GPT series (Achiam al. 2023), Claude-3.7 Sonnet (Antrropic) 2025a). Gemini 2.5 Pro (Comanici et al.) (025)). ). (2) Learning- based: agents that fine- tune open-source backbones with domain data via SFT and/or RI.
7

---

Published as a conference paper at ICLR 2026
Table 1: Comparison of -AgAgent and baselines on AndroidWorld. Our method reports the mean std over independent runs.
Type
Agent
Base Model
Input
SR
M3A (Rawles et al. 2024
GPT-4 Turbo
Screenshot Ally
30.6
AndroidGen (Lai cf al. 2025
GPT-o
Ally Tree
46.8
Training
Agent S2 Agashe ct 2025
Claude-3.5-Some
Screenshot
54.3
free
MobileUse
2025
Qwen2.5-VL-72B
Screenshot
62.9
DroidRun DroidRun 2025
Gemini-2.5-Pra
Screenshot + Ally
63.0
FinalRun FinalRun 2025
GPT-5
Screenshot + Ally
76.7
InfiGU Agent (Liu
2025a
Qwen2-VL-22B
Screenshot
9.0
GUI-critic-RI Wanyyn et al.
2025
Qwen2.5-VL-22B
Screenshot + Ally
27.6
UI-TARS (Qin et al.
2025
Qwen-2-VL-72B
Screenshot
46.6
Learning based
UI- Venus (Gu et al.
2025
Qwen2.5-VL-72B
Screenshot
65.9
Seed1.5-VL (uuo
2025
SeedI.5-VL-72B
Screenshot + AAlly
62.1
Mobile-Agent-v3 (Ye et
2025
Qwen- VL based
Screenshot
73.3
UI-TARS-2 (Wang ct al. 2025a
Sced-thinking-11
Screenshot
73.3
AutoGI.M-Moblec (I.uu et al.
2024
AutoGI.M-Mohile
Screenshot Ally
75.8
Ours
Agent
Qwen2.5-V1.(728--78
Screenshot
76.1 + 1.0
Results and analysis. Table reports success rates AndroidWorld. K2-Agent with a 76.1% % average success rate, surpassing the strongest open-source learning-based methods, UI-TARS (73.3%) and Mobile Seiilee-Agen--ee (73.3%), and outperforming all closed-source models restricted to screenshot inputs. Beyond accuracy, our method offers two key advantages: (i Screenshot-only input-unlike unlike many high-ranked methods that exploit accessibility (Ally) trees, K -'eAgent operates solely from raw screenshots; (ii) Optimization Efficiency the high-level model bootstrapped from a single demonstration per task category, while the low-level executor builds 7B open-source backbone, requiring substantially fewer training resources.
SOTA
5.2 MODEL GENERALIZATION
K2-Agent enables two forms of generalization by design: (i) high-level declarative knowledge transfers across planner backbones, and (ii) low-level procedural skills transfer across benchmarks.
Transfer of declarative knowledge. The SRLR SRLR-produced knowledge KG is language-based, and explicit. We reuse the same KG (without extra tuning) across different VLMs and re-eva re-evaluate on AndroidWorld. Figure (a) reports task success rates. All backbones benefit from the injected KG, indicating that the distilled declarative knowledge model-agnostic and broadly reusable.
Transfer of procedural skills. We directly transfer the low-level executor, trained Android- zero-shot setting. As shown Table 3 K²-Agent's
World, to the ScreenSpot-v2 benchmark outperforming general-purpose closed-source models executor achieves 91.3% % overall accuracy, like Claude 3.7 Sonnet and reaching a level competitive with specialized agents such as GUI-Owl- 32B, which were trained on massive-scale GUI datasets. We further validate transfer Android- in-the-Wild (AitW) across two subsets, where the high-level planner is bootstrapped from a single demonstration per subset and the low-level executor transferred directly. K2 K²-Agent surpasses ex- isting RL- and SFT-based approaches well as closed-source models. Results are shown in Table and Table Additional analysis is provided Appendix E.1
Table 2: Zero-shot transfer to AitW using the low-level executor trained on AndroidWorld.
Agent
AinW-General (SR %) AitW-WebShopping (SR %
SoM (Zhngg al. 2024)
16.7
11.5
AppAgent (Zhang al.
2025
17.7
8.3
CogAgent (Hong et al. 2024
25.0
38.5
AutoUI (Zhang & Zhang
2023
22.9
25,0
DigiRL (Ba et al. 2024
71.9
67.2
K2 K2-Agent
86.5
68.3
8

---

Published as a conference paper at ICLR 2026
Table Zero-shot performance of the KZ-Agent executor on the ScreenSpot-v2 benchmark.
Mobile
Desktop
Web
Agent Model
Text
Icon
Text
Icon
Text
Icon
Overall
Operator (OpenAl 2025
47.3
41.5
90.2
80.3
92.8
84.3
70.5
Claude 3.7 Sonnet Anthropic 2025h
87.6
UI-TARS-72B (Qin
94.8
86.3
91.2
87.9
91.5
87.7
90.3
JEDI-7B (ie al. 2025
96.9
87.2
95.9
87.9
94.4
84.2
91.7
GUI-Owl-32B Ye 2025
98.6
90.0
97.9
87.8
94.4
86.7
93.2
UI- VL-Venus-Grrund-7222
2025
99.7
93.8
95.9
90.0
96.2
92.6
95.3
K--Agent
96.9
80.6
95.9
83.6
95.3
90.6
91.3
wio Declantivv Knowledge
Declarative Knowledge
72.4
1.0
70
(Na)
80
SK.6
50
Rewsnie
1.7
C GRPO
C GRPO w/o raplay balanzing
1.0
C-GRPO w/o éamo injoction
Owen 2.5729 Q.5..2.5.33 2.5-328
GP1-4o
Gemini 2.5 Pro
150
Training Steps
250
335
(a) Transfer declarative knowledge
(b) Training curve low-level executor
Figure 5: Ablation and Component Analysis. (a): The declarative knowledge from our SRLR loop provides substantial performance boost across four different powerful VLM backbones. (b): Training reward curves for the low-level executor comparing full C-GRPO (blue), C-GRPO without replay balancing (red), and C-GRPO without demonstration injection (green).
5.3 ABLATION STUDIES
To assess the contribution of each component in K2-Agent, we conduct ablations on AndroidWorld
by removing or replacing specific modules. We compare five configurations: (1) No Hierarchy.
A flat, end-to-end model. (2) No Hierarchy + SRLR: : A flat model that directly incorporates the knowledge base Ke from the SRLR loop. (3) Hierarchical (SRLR + SFT-Low). Our hierarchical design with an SRLR planner, while the low-level executor is trained only with SFT. (4) Hierar- chical (SRLR + GRPO-Low). The hicrarchical design with a vanilla GRPO-trained executor. (5) K²-Agen (Full). Our complete model with the SRLR planner and C-GRPO executor.
Results are summarized Table 4 and Figure I The Hierarchy model performs poorly, confirming that flat chitecture struggles to manage both planning and execution. Simply adding the SRLR knowledge base (No Hierarchy SRLR) provides a notable boost, demonstrating the value of explicit declarative knowledge. A significant leap occurs when we introduce the hierarchy (SRLR + SFT-Low), iso- lating the structural benefit of decoupling know-what from know-how. Within the hierarchy, replacing SFT with vanilla GRPO improves performance further by enabling interactive learning, but progress is limited by inefficient exploration. Fi- nally, our full K2-Agent with C-GRPO achieves the highest success rate. The superiority of C-GRPO over vanilla GRPO not only reflected the final success rate but also evident during training, as shown in Figure (b), where C-GRPO consistently achieves higher and more stable rewards.
Table 4: Ablation study of K Agent components on Android- World benchmark.
Configuration
SR ( (%)
No Hierarchy
35.3
No Hicrarchy + SRLR
58.6
SRLR SFT-Low
62.0
SRLR + GRPO-LoW
68.9
K2-Agent (Full)
76.1
We further dissect the training dynamics of the low-level executor by isolating the contribution the two key components in C-GRPO. As shown in 5[), the full C-GRPO framework achieves the highest rewards and the most stable convergence. Ablating Dynamic Demonstration Injection (green curve) leads to the most severe degradation: the policy attains substantially lower rewards with pro-

---

Published as a conference paper at ICLR 2026
1.8
Rewards
1.6
Rewomds
1.0
1.2
Rox
7-0.05
-05
T-0.5
1.0
-07
T-55
10
200
1.5
2000
350
160
150
20.0
2.2
200
351
60
Training Steps
Training Steps
[a] Impact the replay buffer ratio Prom
(b) Impact of the demonstration injection temperature T
Figure 6: Parameter sensitivity of C-GRPO. (a): Varying the conventional pool ratio Seon. (b):
Effect of the injection temperature T in the difficulty- function.
nounced oscillations throughout training. This indicates that expert-prefixed trajectories are crucial for bootstrapping exploration, enabling the agent to reliably discover successful behaviors early and thereby stabilizing subsequent self-generated rollouts. Meanwhile, removing Erwor-ecouppedd Replay Balancing (red curve) results in visibly slower convergence rate and slightly inferior fi- nal performance, suggesting that without balancing experience across error types, the optimizer is biased towards frequent, casier operations and struggles acquire complex skills.
5.4 PARAMETER SENSITIVITY
We analyze the sensitivity of C-GRPO two key hyperparameters: the conventional replay pool ratio Seon and the demonstration injection temperature T. Full grid-search settings for all hyperpa- rameters reported in Appendix B.2.3
Impact of Replay Balancing Ratios. The left panel of Figure shows training dynamics under different Bcons with the remaining probability split equally between Doype and D param- All settings exhibit a clear upward trend and eventually converge, indicating that C-GRPO is robust to replay buffer composition. Among them, Bcon 0.5 strikes the best balance between preserving the natural rollout distribution and emphasizing error-corrective samples, yielding the fastest convergence and highest final reward. contrast, assigming excessive weight the conventional pool (e.g.. Scon 0.7) reduces exposure to hard examples and slightly slows learning.
Impact of Injection Temperature. The right panel Figure exxamines the injection temperature T. which controls the difficulty gating function fgate (d,) = tanh (d: With a large temperature (T = 5), fame = O, leading to very short or absent expert prefixes and effectively reverting C-GRPO to vanilla GRPO; the policy barely improves and fails to converge. In contrast, lower temperatures (T= 0.05, 0.5) activate the curriculum effectively: = 0.05 yields a slightly faster initial improve- ment due to more aggressive intervention, while T 0.5 provides smoother training and slightly better stability and final performance. Overall, C-GRPO remains stable over a reasonable range of hyperparameters, and we adopt Bcon 0.5 and T 0.5 in all main experiments.
CONCLUSION
We propose K2-Agent, hierarchical framework inspired by the cognitive separation of declara- tive ("knowing what") and procedural ("knowing how") knowledge. Our agent synergistically co- evolves these two capabilities distinctly: high-level planner uses SRLR loop distill and self-evolving task knowledge from a single demonstration, while a low-level executor masters pre- cise actions via highly-efficient C-GRPO post-training algorithm. K2-Agent not only achieves SOTA performance on AndroidWorld but, more critically, exhibits powerful and robust dual gener- alization-ttaansfrrrin declarative knowledge across backbones and procedural skills across bench- marks. We believe that this knowledge decoupling and co-evolution framework offers promising new paradigm for building more general, efficient, and adaptable agents.
10

---

Published as a conference paper at ICLR 2026
ACKNOWLEDGEMENT
This work is supported by the National Key Research and Development Plan under Grant No. 2024YFB4505500 & 2024YFB4505503.
REFERENCES
Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Ale- man, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, al. Gpt-4 technical report. arXiv preprint arXiiv2303.08777 2023.
Saaket Agashe, Jiuzhou Han, Shuyu Gan, Jiachen Yang, Ang Li, and Xin Eric Wang. Agent s: An open agentic framework that uses computers like human. arXiv preprint arXiv:2410088164, 2024.
Saaket Agashe, Kyle Wong, Vincent Tu, Jiachen Yang, Ang Li, and Xin Eric Wang. Agent s2: A compositional generalist-specialis framework for computer agents. arXiv preprint arXiv:2504.00006, 2025.
Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAl Pieter Abbeel, and Wojciech Zaremba. Hindsight experience play. Advances in neural information processing systems, 30, 2017.
Anthoopic. Claude's extended thinking, 2025a.
visible weiibbeeeexe wwee-exxteneeeee thi nk in
Anthropic. Claude 3.7 sonnet and claude code, 2025b. http:://ww.athhopplc..oo
Hao Bai, Yifei Zhou, Jiayi Pan, Mert Cemri, Alane Suhr, Sergey Levine, and Aviral Kumar. Digirl: Training in- wild device-control agents with autonomous reinforcement learning. Advances in 2024.
Neural Information Processing Systems, 37:12461-
Shuai Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, Sibo Song, Kai Dang, Peng Wang, Shijie Wang, Jun Tang, al. Qwen2. 5-vl technical report. arXiv preprint arXiv:2502. 13923, 2025.
Kanzhi Cheng. Qiushi Sun, Yougang Chu, Fangzhi Xu, Yantao Li, Jianbing Zhang, and Zhiy- ong Wu. Seeclick: Harnessing gui grounding for advanced visual gui agents. arXiv preprint arXiv:2401.10935. 2024.
Gheorghe Comanici, Eric Bieber, Mike Schaekermann, Ice Pasupat, Noveen Sachdeva, Inderjit Dhillon, Marcel Blistein, Ori Ram, Dan Zhang, Evan Rosen, al. Gemini 2.5: Pushing the frontier with advanced reasoning, multimodality, long context, and next generation agentic capa- bilities. arXiv preprint arXiv:2507.0626/1 2025.
DroidRun. Droidrun: powerful framework for controlling android and ios devices through Ilm agents, 2025. /tttps://ge ttt.t..t.u.u...g/.g com droirrriiooooo cwwrrodduundddo /wwpd/unn/dddduunrrrrrdro
FinalRun. Finalrun ai agent achieves 76 success rate on android world benchmarks, 2025.
httpp::/ffint http//iiaarrnnt app hww.pppbbbhhhaabaaaa.a
Zhangxuan Gu, Zhengwen Zeng, Zhenyu Xu, Xingran Zhou, Shuheng Shen, Yunfei Liu, Beitong Zhou, Changhua Meng, Tianyu Xia, Weizhi Chen, al. Ui-venus technical report: Building high-performance ui agents with rft. arXiv preprint arXiv:2508. 10833, 2025.
Dong Guo, Faming Wu, Feida Zhu, Fuxing Leng, Guang Shi, Haobin Chen, Haoqi Fan, Jian Wang, Jianyu Jiang, Jiawei Wang, al. Seed1. 5-vl technical report. arXiv preprint 2rXiv:2505.0762. 2025.
Wenyi Hong, Weihan Wang, Qingsong Lv, Jiazheng Xu, Wenmeng Yu, Junhui Ji, Yan Wang, Zihan Wang, Yuxiao Dong, Ming Ding, et al. Cogagent: A visual language model for gui agents. In Proceedings of the IEEE/CVF Conference on Computer Vision and Patten Recognition, pp- 14281-14299 2024.
11

---

Published as a conference paper at ICLR 2026
Hanyu Lai, Junjie Gao, Xiao Liu, Yifan Xu, Shudan Zhang, Yuxiao Dong, and Jie Tang. Androidgen: Building an android language agent under data scarcity. arXiv preprint arXiv:2504. 19298, 2025.
Ning Li, Xiangmou Qu Jiamu Zhou, Jun Wang, Muning Wen, Kounianhua Du, Xingyu Lou, Qiuy- ing Peng, and Weinan Zhang. Mobileuse: A gui agent with hierarchical reflection for autonomous mobile operation. arXiv preprint arXiv:2507. 16800,, 2025.
Yuanchun Li, Hao Wen, Weijun Wang, Xiangyu Li, Yizhen Yuan, Guohong Liu, Jiacheng Liu, Wenxing Xu, Xiang Wang, Yi Sun, et al. Personal Ilm agents: Insights and survey about the capability, efficiency and security. arXiv preprint arXiv:2401. 240449549, 2024.
Xiao Liu, Bo Qin, Dongzhu Liang, Guang Dong, Hanyu Lai, Hanchen Zhang, Hanlin Zhao, lat Long long, Jiadai Sun, Jiaqi Wang, et al. Autoglm: Autonomous foundation agents for guis. arXiv preprint arXiv:2411. 1.00200, 2024.
Yuhang Liu, Pengxiang Li, Zishu Wei, Congkai Xie, Xueyu Hu, Xinchen Xu, Shengyu Zhang, Xiaotian Han, Hongxia Yang, and Fei Wu. Infiguiagent: multimodal generalist gui agent with native reasoning and reflection. arXiv preprint w5X.::2501.04555, 2025a.
Yuhang Liu, Pengxiang Li, Congkai Xie, Xavier Hu, Xiaotian Han, Shengyu Zhang, Hongxia Yang, and Fei Wu. Infigui-rl: Advancing multimodal gui agents from reactive actors to deliberative reasoners. arXiv preprint arXiv:2504. 2etee224444.229. 2025b.
Zhengxi Lu, Yuxiang Chai, Yaxuan Guo, Xi Yin, Liang Liu, Hao Wang, Han Xiao, Shuai Ren, Guanjing Xiong, and Hongsheng Li. Ui-rl: Enhancing efficient action prediction of gui agents by reinforcement learning. arXiv preprint arXiv:2503.21620 2025.
Run Luo, Lu Wang, Wanwei He, and Xiaobo Xia. Gui-rl: A generalist rl-style vision-language action model for gui agents. arXiv preprint arXiv:2504. 10458, 2025.
OpenAl. Computer-using agent: Introducing a universal interface for ai to interact with the digital world, 2025. https:// com wwtp./ceco/ooooo/o/ecccee http:///wwwccootttttttesusoo-oos
Jiayi Pan, Yichi Zhang, Nicholas Tomlin, Yifei Zhou, Sergey Levine, and Alane Suhr. Autonomous evaluation and refinement of digital agents. arXiv preprint arXiv:2404.06444, 2024.
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.
Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly reward model. Advances in neural information processing systems, 01153328--374111 2023.
Christopher Rawles, Alice Li, Daniel Rodriguez, Oriana Riva, and Timothy Lillicrap. An- droidinthewild: large-scale dataset for android device control. Advances in Neural Information Processing Systems, 36:59708-59977 2023.
Christopher Rawles, Sarah Clinckemaillie, Yifan Chang, Jonathan Waltz, Gabrielle Lau, Mary- beth Fair, Alice Li, William Bishop, Wei Li, Folawiyo Camphell-Ajala, et al. Androidworld: A dynamic benchmarking environment for autonomous agents. arXiv preprint arXiv:2405.1455 2024.
Zhihong Shao, Peiyi Wang. Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Yang Wu, et al. Deepscekmath: Pushing the limits of mathemati- cal reasoning in open language models. arXiv preprint a333v02402.03300 2024.
Haozhan Shen, Peng Liu, Jingcheng Li, Chunxin Fang, Yibo Ma, Jiajia Liao. Qiaoli Shen, Zilun Zhang, Kangjia Zhao, Qianqian Zhang, Ruochen Xu, and Tiancheng Zhao. Vlm-rl: A stable and generalizable r1 -tyyy large vision- lisiun-language model. arXiv preprint 4xXv:2504.076155 2025.
Larry R Squire. Memory and brain systems: 1969-2009, Journal of Neuroscience, 29(41):1271 12716, 2009.
12

---

Published as a conference paper at ICLR 2026
Larry R Squire and Barbara Knowlton. Memory, hippocampus, and brain systems. 1995.
Guanzhi Wang. Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models. arXiv preprint arXiv: 16291, 2023.
Haoming Wang. Haoyang Zou, Huatong Song, Jiazhan Feng, Junjie Fang, Junting Lu, Longxiang Liu, Qinyu Luo, Shihao Liang, Shijue Huang, et al. Ui-tars-2 technical report: Advancing gui agent with multi-turn reinforcement learning. arXiv preprint arXiv:2509.0240 025444. 2025a.
Junyang Wang, Haiyang Xu, Haitao Jia, Xi Zhang, Ming Yan, Weizhou Shen, Ji Zhang. Fei Huang, and Jitao Sang. Mobile-agent-v2: Mobile device operation assistant with effective navigation via multi-agent collaboration. Advances in Neural Information Processing Systems, 37:2686-2710 2024a.
Junyang Wang, Haiyang Xu, Jiabo Ye, Ming Yan, Weizhou Shen, Ji Zhang, Fei Huang, and Jitao Sang. Mobilc-agent: Autonomous multi-modal mobile device agent with visual perception. arXiv preprint arXiv:2401.16/55 2024b.
Taiyi Wang, Zhihao Wu, Jianheng Liu, Jianye Hao, Jun Wang, and Kun Shao. Distrl: An asyn- chronous distributed reinforcement learning framework for on-device control agents. arXiv preprint arXiv:2410. 14803, 2024c.
Zhenhailong Wang, Haiyang Xu, Junyang Wang. Xi Zhang, Ming Yan, Ji Zhang, Fei Huang, and Heng Ji. Mobile-agent-e: Self-evolving mobile assistant for complex tasks. arXiv preprint arXiv:2501.11333 2025b.
Yuyang Wanyan, Xi Zhang, Haiyang Xu, Haowei Liu, Junyang Wang, Jiabo Ye, Yutong Kou, Ming Yan, Fei Huang, Xiaoshan Yang, et al. Look before you leap: A gui-critic-rl model for pre- operative error diagnosis in gui automation. arXiv preprint arXiv:2556.0440 2025.
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 gener- alist gui agents. arXiv preprint 24
2024.
Tianbao Xie, Jiaqi Deng, Xiaochuan Li, Junlin Yang. Haoyuan Wu, Jixuan Chen, Wenjing Hu, Xinyuan Wang, Yuhui Xu, Zekun Wang, et al. Scaling computer-use grounding via user interface decomposition and synthesis. arXiv preprint arXiv:2505.13227, 2025.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In The eleventh international conference on learning representations. 2022.
Jiabo Ye, Xi Zhang, Haiyang Xu, Haowei Liu, Junyang Wang, Zhaoqing Zhu, Ziwei Zheng, Feiyu Gao, Junjie Cao, Zhengxi Lu, al. Mobile-agent-v3: Foundamental agents for gui automation. arXiv preprini arXiv:2508. 15144, 2025.
Wenwen Yu, Zhibo Yang, Jianqiang Wan, Sibo Song, Jun Tang, Wenqing Cheng, Yuliang Liu, and Xiang Bai. Omniparser v2: ponucturd--poins-offf generality to multimodal large language models. arXiv preprint 250.:25022.16611 2025.
for unified visual text parsing and its
Chi Zhang, Zhao Yang. Jiaxuan Liu, Yanda Li, Yucheng Han, Xin Chen, Zebiao Huang, Bin Fu, and Gang Yu. Appagent: Multimodal agents as smartphone users. In Proceedings of the 2025 CHI Conference on Human Factors in Computing Systems, pp. 1 1-20, 2025.
Zhuosheng Zhang and Aston Zhang. You only look screens: Multimodal chain-of-action agents. arXiv preprint arXiv:2309.1 11436, 2023.
Boyuan Zheng, Boyu Gou, Jihyung Kil, Huan Sun, and Yu Su. Gpt-4v (ision) is a generalist web agent, if grounded. arXiv preprint arXiv:2401.0fr4 006144 2024.
13

---

Published as a conference paper at ICLR 2026
APPENDIX
Statement on LLM Usage. In the preparation of this manuscript, Large Language Models (LLMs) utilized auxiliary tools to enhance language quality and formatting. Specifically, used Gemini 2.5 Pro for grammar checking and polishing the prose. Additionally, GPT-series models were employed to assist with optimizing LaTeX table formatting and query for specific typesetting commands (e.g., for pseudocode presentation and color highlighting). We affirm that all scientific content, core ideas, and experimental results were conceived and articulated entirely by the human authors. LLMs were not used to generate any substantive scientific content. All suggestions and modifications from these models were implemented under the direct supervision and final approval of the authors. All co so-authors are aware of and consent to this usage.
A COGNITIVE SCIENCE FOUNDATIONS OF K2- AGENT
Deciorative Knswledge
Procedural Knowlodge
Declorstive Knowledge
Procedurd Knowledge
Encwing What
Knowing Hos
sef-eevehvng
post-training
Figure 7: Cognitive inspiration for the K²-Agent framework. The design maps the human dis- tinction between declarative ("knowing what") and procedural ("knowing how") knowledge onto hierarchical agent architecture.
Figure 7 illustrates the core cognitive science principle that inspires the design of K²-Agent: the fundamental distinction between declarative ("knowing what") and procedural ( ("knowing how") knowledge. Seminal work in cognitive neuroscience (Squire & Knowlton, 1995) has established these distinct memory systems. Declarative knowledge consists of explicit facts and concepts that can be consciously recalled and articulated, much like how our high-level planner distills and refines its task knowledge base (Kc) from single demonstration. In contrast, procedural knowl- edge encompasses implicit skills acquired through repeated practice, such as riding a bicycle, which performed automatically and difficult verbalize. This mirrors how our low-level executor is trained via C-GRPO to form robust "muscle memory" for precise UI operations. By explicitly modeling this cognitive division, K2-Agent creates a synergistic architecture where planning and execution can be evolved and optimized using distinct, more suitable mechanisms.
B FRAMEWORK AND ALGORITHM DETAILS
B.1 HIGH-LEVEL PLANNER: THE SRLR LOOP IMPLEMENTATION
B.1.1 PSEUDOCODE FOR THE SRLR ITERATION
The iterative self-evolution of the high-level planner is governed by the Summa- mne-Reffect-Locate-Reeeee (SRLR) loop. Algorithm [ provides detailed algorithmic view of this process, outlining how the knowledge base (KG) is initialized from single demonstration and then progressively refined through cycles of execution and feedback-driven revision.
The SRLR loop is guided by two primary hyperparameters that control its termination. 'MAX ITER' sets a hard limit the number of revision cycles to prevent infinite loops, which we set to in our experiments. 'SUCCESS THRESH defines a stopping criterion based on con- sistent performance; the loop terminates if the agent successfully completes the task for this many consecutive episodes. We set this value to 3, indicating that the knowledge base is considered stable and robust after three successful runs in
14

---

Published as a conference paper at ICLR 2026
Algorithm 1: The SRLR Algorithm for Planner Self-Evolution
Input: Demonstration Tá, task goal environment E, VLM backbone 0 Initialize: Evolved knowledge base Kg
Summarize: Distill initial knowledge from single demonstration Kg + Summarize (T :g: 0H)
Iterative Refinement: The main SRLR loop
i <- O, Saucak f- 0
while < MAX ITER and Sstreak < SUCCESS THRESH do
i < i+1
(T success) t- Execute(TH, TL, KG,E)
Execute with current K
success then
Sstreak f Sstreak +
else
Ssteak +
// Reflect: Analyze the root cause of the failure M +- Rellect(TS Ka, 0n)
// Locate: Pinpoint the first point of failure 8a null for t to -
12
if Verifyy af; Ka, 0H) False then t" + t; break
14
15
L- = null then
16
ThllTTrajcttrryAnllysss"""" " Ka; 0H)
// Fallback if loop fails
I/ Revise:
Intelligently update the knowledge base if to + null then
17
A K + GenerateRevision (Messe, (T",t"), 01)
18
Kddaft + Intelligent Kg, A AKa; 01)
19
KG + Apply AtomicEdits/ K Karll AKc)
dralt
20
return Ka
B.1.2 DEMONSTRATION DATA CONSTRUCTION
To initialize the SRLR self-evolution loop for the high-level planner nH, we constructed high- quality human expert demonstration trajectory, Tá, for each task category. This demonstration data was recorded by a human operator in standard Android emulator environment. For each step, the operator was instructed to first articulate their intent as a natural language instruction (e.g.. "Swipe up the screen locate the Audio Recorder app.") while the system precisely recorded the corresponding atomic action, including its type and exact coordinate parameters. We also captured screenshots immediately before and after each action was executed. complete demonstration trajectory thus consists of a sequence of steps, where each step comprises tuple: (pre-operation screenshot, post-operation screenshot, natural language instruction, atomic action). For example, in the "ContactsAddConite first step "Swipe up on the screen locate the Contacts app.", ", and its corresponding atomic action is [swipe, (546, 1806), (546, 800) J.
task, the trajectory contains 10 steps; the natural language instruction for
For the 116 unique task categories in AndroidWorld,, we collected total of 103 expert demonstra- tion trajectories to bootstrap the SRLR process. This number is less than the total task count for two primary reasons. (i) some tasks are inherently difficult even for human experts to complete reliably, and (ii) certain tasks share overlapping high-level knowledge, allowing one trajectory to effectively cover multiple categories. In principle, this set could further reduced by exploiting such knowledge sharing across tasks.
We maintained strict separation between the demonstration data used to bootstrap the SRLR loop and the test data used for evaluation. To ensure this, followed the design of the AndroidWorld
15

---

Published as a conference paper at ICLR 2026
benchmark by setting different random seeds for each task instance dynamically generate its parameters. This mechanism guarantees that even for tasks of the same category, the specific pa- rameters encountered during testing (e.g., contact names, filenames, settings) differ from those in the initial demonstration, thereby enabling a robust evaluation of the model's generalization ability.
B.1.3 IMPLEMENTATION DETAILS OF SRLR MODULES
Each stage of the SRLR loop is implemented distinet prompt- based query to the high-level VLM (TT). The specific prompts used for each module are shown below.
Summarize module prompt
Analyze the demonstration and extract the core operational strategy that an AI agent can use to handle similar tasks.
Task: (task_goall
Step: (instructions) (action_raws)
output Requirements:
L.Lggical Flow: Describe the steps in the exact original order using First, Then, After that....
2.Critical Success Factors: Summarize 3 or 4 essential rules for success 3.UI Interaction Patterns: Highlight the main interaction methods
Notes:
Keep it coneise, emphasize sequence and dependencies.
Generalize the technique rather than focusing on speci fic content.
Reflect module prompt
Compare and analyze the main reason.
Errer Trajectory: perror_trajcctory
Correct Demonstration: (demo_trajectettt
Analysis Requirements:
1.Corpare the sequence step by step against the demonstration to identi-
fy where divergence occurs.
Lecate the failure within the five informatiion-haddling levels:
(1) Source Location
(2) Target Selection
(3) Data Extraction
(4) Data Processing
(5) Answer Output
3.Distinguish between wrong target selection and failure in extraction or processing within the correct target.
4.Provide evidence from the demonstration to show what information was missing, incorrect, or not properly handled.
Output Format:
ERROR CRROR_REASON REASON: State the exact failure point and specify the missing or incerrect information.
EXPLANATION; Provide step-by-step comparison showing where the error tr- ajectory diverged from the demonstration and support it with evidence.
Locate module prompt
Conduct step-by-step process to pinpoint where the error occurred, using error details and demonstration data references.
Inputs:
Error Reason: jerror_reason_72] Demonstration Steps: [demonstration; Prompt with Line Numbers: (prompt_line)
16

---

Published as a conference paper at ICLR 2026
Process:
Step 1 Error Location
Review the stated error reason: [erros_rcason_72b)
Identify the exact 1ine numbers in the prompt linked this error
Highlight the sections of content that contributed to the issuc Step 2 Demonstration Reference
Match the error against relevant demonstration steps Extract the instruction on that address the error cause Specity which part the demonstration resolves the issue
Output Format:
STEPI_ERROR_LOCNTIOO: [Line number of the first failed step and related content in the prompt connected the error] LIODNO_CONTENT_LLGGO
[Relevant demonstration steps (instruction only) that address the error]
Revise module prompt
Modify the prompt based on error analysis and demonstration data.
Inputs
Demonstration Steps: [demonstration)
Prompt Used in Failed Execution: (prompt_line)
Error Location Analysis:
Improvement Process
Step 1 : Direct Prompt Modification
Pmphaasie key attention points and critical adding examples.
rather than
Highlight critical notices using markers such "IMPORTANT:", "CRI- TICAL:", "NOTE:", or "PAY ATTENTION 20:". Use demonstration reasoning to guide attention points without copying specific results.
Treat demonstration data the source of truth; only include functio- nality shown the demonstration.
Step 2 Semantic Aligament Check Review each 1ine of the modified prompt for scmantic consistency with demonstration content.
For each line, identify the corresponding demonstration instruction and ensure it aligns meaning.
Remove any content not supported by demonstration data.
Focus
Precision: Target exact locations and content.
Demonstratton-eaet All modifications must be grounded in demonstrat- icn steps.
Attention Emphasis: Highlight critical points.
Semantic Consistency: Ensure meaning matches demonstration instruction
Functionslity Verification: Only include demonstrated features.
Output Format BOAALL_DDFFIE_EEEE PROMPT: [Complete modi fied prompt after both steps, with
every line supported by demonstration data]
B.1.4 ANALYSIS INDUCED DECLARATIVE KNOWLEDGE REFLECTION ROBUSTNESS
To further understand the behavior and limitations of the SRLR loop, we conducted a comprehen- sive analysis of the induced knowledge bases (Kc) and the corresponding reflection logs. This subsection summarizes our observations, and the next section provides extended case studies and visualizations.
17

---

Published as a conference paper at ICLR 2026
(1) Taxonomy of Induced Declarative Knowledge. Across AndroidWorld tasks, the Summarize stage consistently induces four primary categories of declarative knowledge (distribution shown in Figure 8
Step Ordering:
Core logical dependencies between task steps, such "Open the Audio Recorder app before accessing the file list."
UI Layout & Invariants: Stable visual semantics of UI elements, egg.. "The record button is the white circle at the bottom center."
Parameter Constraints: Format requirements and mandatory input rules, such as "The filename must include the "m4aa extension."
Recovery Strategies: Conditional checks for resolving common execution anomalies, e.g., "If the 'Save' button is disabled, ensure the text field focused."
These types capture task-level logic that is naturally expressible in language and form the planner's declarative backbone.
Parameter Constraints
UI Layout & Invariants
AFter the File. ensure the File extension is explicitly typed anta
Then tap record button with white circle at the bottom center
15%
29%
48%
Recovery Strategies
Step Ordering
If the 'Save' button is grayed out, check if the input field is focused
First, swipe up to open the app drawer... Then tap on the search icon to
Figure 8: Distribution of the induced declarative knowledge
(2) Boundaries Summarizable Knowledge. We also identified knowledge types that are in- herently difficult to verbalize. These limitations highlight the need for the procedural low-level executor:
Ineffable Visual Grounding: Precise spatial relations or pixel-level cues that lack stable lin- guistic descriptions (e.g.. "Tap near the 3 o c'lock position"").
Visual Dynamics: Behaviors that require continuous perceptual feedback, such as iterative swiping until list terminus is reached.
Massive Episodic Content:
Tasks involving retrieval from large historical content, e.g., search- ing through dozens of previously viewed images.
While our framework focuses on evolving task logic rather than maintaining long-range episodic memory, each of these limitations points directions for complementary improvements. First, in- esfable visual grounding could be mitigated by stronger backhone vision encoders or multimodal pretraining that yields more precise spatial understanding. Second, visual dynamics may be ad- dressed by integrating recurrent perceptual modules or short-horizon visual predictors capable of modeling iterative feedback. Third, massive episodic content would require external memory sys- tems retrieval- aaggente- modules, which are orthogonal to the SRLR loop but could complement it in future extensions.
(3) Self-Correction of Incorrect Declarative Knowledge. In some cases, the initial Summarize stage induces overly specific or incorrect rules, especially when a demonstration contains instance- specific details. The SRLR loop naturally corrects such issues: Reflect identifies the state mismatch, Locate isolates the faulty rule, and Revise updates and generalizes it.
For example, in the AudioRecorder task (the next subsection), the initial knowledge incorrectly memorized fixed filename. After an execution failure, the rule was revised to "Type the filename specified in the current instruction," leading to consistent generalization across future episodes.
18

---

Published as a conference paper at ICLR 2026
(4) Scope and Limitations of Root-Cause Analysis. failures that leave clear visual evidence, including:
The reflection process effectively captures
omitted mis-ordered steps,
incorrect UI navigation,
wrong element selection or misclicks,
invalid textual inputs or wrong parameter values.
However, reflection is fundamentally limited by visual observability. Certain execution failures do not manifest in screenshots, such as: OS-level freezes or dropped touch events, network delays preventing UI updates and invisible permission denials or background system interrupts.
These cases yield no visual divergence, and thus no reliable root-cause attribution. To maintain robustness under such conditions, the system employs strict max-retry fallback mechanism (Algo- rithm 1 line (3]) to avoid infinite loops.
B.1.5 EVOLUTION OF THE KNOWLEDGE BASE (Ka)
To concretely illustrate the self-evolution process of the declarative knowledge base (Kc) via the RerkecorreeReorrruuuioooooiooo
SRLR loop, showcase its revision process for the Name' task. The evolution from KG + KG - KG demonstrates a sophisticated learning pattern: begins with literal summary, evolves generalized and logically structured plan, and finally refines into robust strategy that re-introduces critical, grounded details discovered through further interaction.
Initial Knowledge (K2) from Summarize Phase. module, which distills single expert demonstration into an initial, structured knowledge base, K This plan is direct, flat list of actions observed in the demonstration.
The process starts with the Summarize
K Initial Plan from Demonstration
Swipe up the screen to reveal more apps.
Tap on the "Audio Recorder" app icon.
Tap the white circular button at the bottom of the screen start recording.
Tap the white square button at the bottom right of the screen to stop the recording.
Long press the backspace key the keyboard to delete the content in the input field.
Type the text "presentation fGwr.m4a".
Tap the "Save" button.
SRLR Cycle 1: Generalization and Logical Structuring. During execution, the agent fails on new task instance due the hard-coded filename. The SRLR loop triggered.
Reflect:
The agent observes the failure and identifies other potential ambiguities, such as im- plicit preconditions.
The failure's root cause is traced to the specific filename and the plan's lack of explicit logical flow and error-checking.
Locate:
The knowledge updated in two major ways: (1) It's generalized by replacing the hard-coded name with placeholder. (2) It's reformed into more robust, logically structured sequence with explicit steps for verification and safeguards (e.g., "Ensure no other actions are taken...").
Revise:
19

---

Published as a conference paper at ICLR 2026
K Revision (Generalization & Logical Structure)
Swipe up and Tap ef
First, you need locate and open the Audio Recorder app. (Abstracted)
Tap white eireular butten....
To start recording, tap the record button. Ensure no other actions are taken until record- ing begins. (Added safeguard)
Long press the sanekspaae-ke-..... (Removed as potentially over-specific)
"presentation fGwr.m4a"..
Then, navigate to the save options... and enter [FILENAME] ... (Generalized)
Following this, ensure the file type is set to .m.... (New step from failure analysis)
Before confirming..., verify that both the file name and type are correctly entered... (Added verification step)
SRLR Cycle 2: Re-introducing Critical Specificity and Grounding, While Ky is more logical, its abstraction causes new failures. The agent struggles with grounding (e.g., finding the generic "record button") and, critically, fails to clear default text in the input field.
Reflect:
The agent recognizes that filenames consistently corrupted (e.g.. 'Record- ing//FiIEENAEE)mm44 and that sometimes hesitates or clicks the wrong UI element.
Locate: The root causes are identified: (I) the omission of the crucial step to clear the input element descriptions.
field and (2) over-abstraction
Revise: The plan is refined to achieve balance. It re-introduces critical actions as manda- tory preconditions ("you MUST long press...") and restores specific details ("white circular button") for better grounding, while retaining the strong logical flow.
K2 Revision 2 (Robust and Re-grounded Plan)
you locate seen- thapeen-thh-Aee Audio Recorder
First, swipe up the screen... and Then, tap the "Audio Recorder" app icon. (Re- introduced specificity)
Te-start recording tap the recerd button, Ensure..
After opening the app, tap the white circular button...
When you're ready to stop..., tap the white square button... (Restored UI details for grounding)
(Verifieation and file type steps from from Ki
Before typing the filename, to delete any existing content, you MUST long press the backspace key... (Critical step re-introduced mandatory)
Type [FILENAME] into the designated input field...
Tap the "Save" button finalize...
This final knowledge base, K2.- is superior to its predecessors: it is general enough to handle dif- ferent task parameters (like KG) yet specific enough to execute robustly and avoid common pitfalls (like K2)). This demonstrates the effectiveness of the SRLR loop in creating robust, reusable knowledge base from minimal initial data.
B.2
LOW-LEVEL EXECUTOR: C-GRPO IMPLEMENTATION
B.2.1 PSEUDOCODE FOR THE C-GRPO ALGORIITM
The C-GRPO algorithm trains the low-level executor (πT.) by combining curriculum learning strat- egy with the Group Relative Policy Optimization framework. Algorithm 2 provides high-level overview of the training process. It begins by initializing the error-decoupled replay buffers based
20

---

Published as a conference paper at ICLR 2026
Algorithm 2:
Surriculum-Guided Group Relative Policy Optimization (C-GRPO)
Input :
Initial policy Ty (0), Expert demonstration dataset Dexpert
Output Trained policy parameters 0
// Phase 1: Initialize Error- ceroo--ecuupled Replay Buffers
Initialize replay buffers Deon. Dtypes Daaram
foreach sample i = (8;, 0;, TTd in Dexper do
Calculate error rates (t), 7ppramm (i) with the initial policy TL
Assign sample (along with its error rates) to the corresponding buffer based on thresholds
// Phase 2: Main Training Loop for k f- 1 to Kmax do
// Construct a balanced mini-batch
Sample mini-batch B from buffers Denn; Drype; Parram according to ratios {33
// Augment each sample with Dynamic Demonstration Injection
foreach sample i = (8i, ais T.d ?...) in B do dj f Mhyee + 7param 1 - |7,41 1. o (k) gamt (d:) G - GetPrefix ,44 Ds
|/ Calculate sample difficulty
Calculate injected prefix length
10
Form augmented context
// Perform C-GRPO update on the augmented batch
11
Compute loss JC-CRPO (0; {c:3)
// Generate rollouts, compute rewards/advantages
12
0 - 0 V Jc-cRrO)(
13
return 0
on the initial policy's 's performance. then enters a main training loop where balanced mini- biii-bbtchhes are constructed, augmented with dynamic demonstration prefixes, and used for the policy update, effectively guiding the agent towards acquiring robust procedural skills.
B.2.2 TRAINING DATA CONSTRUCTION
The training dataset for the low-level executor, WL, was constructed from the 116 high-quality, multi-step expert demonstration trajectories sourced from the AndroidWorld benchmark. To adapt this data for training a single-step action policy, we performed a meticulous preprocessing pipeline.
Processing Pipeline. First, each trajectory decomposed into sequence of single-step state- action pairs. Second, every pair underwent a manual verification process to ensure its quality and correctness. We filtered out any steps that were ambiguous or erroneous, such as actions that resulted in no observable change on the screen or where the natural language instruction did not precisely match the recorded atomic action. This rigorous cleaning process yielded final dataset of 606 high-quality samples.
Data Distribution. The dataset encompasses a wide variety interactions across the 20 ap- plications in AndroidWorld. Critically, the distribution of action types is naturally imbalanced, with common actions like click appearing far more frequently than less common but equally im- portant actions such as long press and swipe. This imbalance underscores the need for the error-decoupled replay balancing mechanism in our C-GRPO algorithm.
Data Format. Each sample was serialized into a JSON object, paired with its corresponding screenshot. The JSON structure is designed to be compatible with standard VLM training frame- works. An example shown in Figure The keys are defined as follows:
id: A unique identifier for the data sample.
task: The high-level goal of the entire trajectory.
conversatio ions: A list containing the human-like instruction (the sub-goal for the current step) and the ground-truth tool call from the GPT-llike model (the expert action).
21

---

Published as a conference paper at ICLR 2026
image:
The file path to the screenshot taken just before the action.
Figure 9: An example of a single training data sample in JSON format.
Training Sample Example
"id": "action_Mardei htt.o//wwrcrccooootee.eeeeeeee.d
"task": "In Markor, move the note 8zum friendly wewnddlyyeguuuntar from WorkProjects to CodeSnippets." "conversations":
"from": "human",
"value": "<image> \nSwipe up on the screen to locate the Markor app in the app drawer."
"from": "gpt",
"value": "coordinate": [546, 2000],
("action": "swipe",
"coordinate2": [546, 800] }
</tool_call>"
},
i mage": htt.rr/rennrrrto000ooooooorrrrrr MartorMooaNoooe__00000 png"
B.2.3 HYPERPARAMETER SETTINGS
Our experimental setup involves distinct configurations for the high-level planner and the low-level executor. The planner operates training-fres manner, guided by the hyperparameters of the SRLR loop. The executor is trained via our C-GRPO algorithm, which we implemented by adapting the GRPOTrainez framework from VLM-R Shen et al. 2025). All key hyperparameters for each component, along with the training infrastructure details, are consolidated in Table 5
22

---

Published as a conference paper at ICLR 2026
Table 5: Comprehensive list of hyperparameters for K2- K²-Agent.
Component
Hyperparameter
Value
High-Level Planner (Tg
MAXIITER
Max revision cycles per task
10
SUCCESS_ THRESH
Consecutive successes to stop
3
Low-Level Executor (TL)
Base Learning Rate
Learning rate for policy
10 10-6
Epoch Count
Number training epochs
2
Per-GPU Batch Size
Samples per GPU during training
2
Generations per Input (G)
Number of rollouts per sample
8
Gradient Accumulation Steps
Steps accumulate gradients
2
KL Weight (3)
Weight for KL penalty
0.04
Clipping Ratio (c)
GRPO clipping ratio Weights for format/content reward
0.2
Reward Weights (Aimt, Accatem)
{1.0, 1.0}
C-GRPO Curriculum Strategy
Buffer Ratios (3cm,, Stype, Sparm)
Sampling ratios for replay pools
{0.5, 0.25, 0.25)
Injection Temp (T)
Temperature for difficulty gating Total steps for anncaling scheduler
0.5
Max Training Steps (Kmax)
1000
Model and Training Infrastructure
High-Level Model (Ти)
VLM for planner
Owen2.5-VL-72.
Low-Level Model (Tz)
VLM for executor
Qwen2.5-VLL VL-7B
Max Input Tokens
Context length limit
1024
Max Output Tokens
Generation length limit
256
Optimizer Precision
Mixed-precision training type
bfloat
Hardware
GPUs used training
NVIDIA A100 (80GB)
All experiments are carried out on a cluster of eight NVIDIA A100 GPUs with 80 GB memory each, and complete training pass requires about eight hours. The software environment includes flash.atth n 2.8.3, torch 2.8.0, t Transformet 4.49.0, and trl 0.17.0, which together enable efficient use of FlashAttention and smooth integration with the GRPOTrainer workflow.
C EXTENDED DISCUSSION AND COMPARATIVE ANALYSIS
This section elaborates on the distinctions between K2- -Agent and other prominent exploration or hybrid frameworks, specifically discussing the applicability of Hindsight Experience Replay (HER) Andrychowicz et al. (2017) and contrasting our architecture with ReAct Yao et al. (002)) Voyager Wang et al. (2023). and RPA systems.
C.I INAPPLICABILITY OF HINDSIGHT EXPERIENCE REPLAY (HER)
While HER (Andrychowicz et 2017 powerful exploration technique for goal-conditioned RL, it relies on the assumption that any visited state can be re-labeled as a valid alternative goal. This assumption fundamentally conflicts with our vision-based, cnttructionfolllwwiii setting, First, our "goals" are natural language instructions (c.g. "Open Settings")) while states are pixel-level screen- shots; there no trivial mapping to convert arbitrary intermediate screen back into high-level semantic instruction. Second, unlike robotic manipulation where reaching any coordinate is phys- ically valid, many intermediate GUI states (e.g., loading screens or partial lists) do not correspond to meaningful user tasks, making goal re-labeling semantically undefined. Consequently, instead of goal re- re-labeling, we employ Dynamic Demonstration Injection as a domain comain-adapted curriculum to bootstrap exploration in this sparse-reward environment.
C.2 COMPARISON WITH ALTERNATIVE HYBRID ARCHITECTURES
K2- K2-Agent represents distinct evolution from existing "reasoning acting" frameworks. (1) ReAct: Our "No Hierarchy" baseline (Table 4 mirrors a ReAct-style setup where monolithic policy handles both reasoning and acting. The significant performance gap (35.3% vs. 76.1%)
23

---

Published as a conference paper at ICLR 2026
confirms that explicitly decoupling "know-what" from "know-how" is critical for preventing cog- nitive drift in long-horizon GUI tasks. (2) vs. Voyager: While systems like Voyager evolve skills executable code over structured APIs, such stable interfaces unavailable in vision-only mo- bile control. K²-Agent instead evolves skills as parametric neural policies via C-GRPO, enabling operation in pixel-based environments where code generation is inapplicable.
(3) vs. RPA: Un- like Classical Robotic Process Automation (RPA) which relies on brittle, static scripts, K²-Agent data-driven. Its SRLR loop adaptively refines knowledge, and its executor generalizes zero-shot to unseen apps and platforms (as evidenced by AitW and ScreenSpot-v2 results), offering robust alternative to fixed automation pipelines.
D EXPERIMENTAL SETUP AND ADDITIONAL RESULTS
D.1 BENCHIMARK AND EVALUATION DETAILS
D.1.1 ENVIRONMENTS DETAILS
Environment. Our primary evaluation platform is AndroidWorid (Rawles et al., 2024), a stan- dardized benchmark that operates on a live Android emulator. features 116 band-crafted tasks distributed across 20 diverse applications. Crucially, to test for generalization and prevent solution memorization, each task dynamically instantiated with randomized parameters for every episode. The tasks span a wide range of complexities, from easy operations to ble providess a detailed breakdown of the applications and their corresponding task counts.
procedures. Ta-
Observation Space. Our agent interacts with an Android Virtual Device (AVD) configured to em- ulate a Pixel 6 running Android Tiramisu (API Level 33), consistent with the standard setup for the AndroidWorld benchmark. We adopt vision-centric approach where the agent's perception relies solely on raw visual input. The state representation at each step is multimodal input comprising:
Screenshot: An RGB image of the current screen with resolution of 2400 1080 pixels. We do not use any underlying structural information, such as the accessibility tree (A1 (Ally ly tree) or view hierarchy XMI., making the task reliant on the model's visual understanding.
Task Goal: natural language string describing the overall objective, for example, "Record an audio clip using Audio Recorder app and save it."
History: The sequence of past actions taken within the episode. This historical context is provided exclusively to the high-level planner (тH) to support multi-step reasoning and error analysis the SRLR loop. The low-level executor (TT)) operates without this history, focusing only executing the current subgoal based on the present visual state.
Action Space. To facilitate robust and precise interaction with the mobile device environment, define a structured action space for the low-level executor. Inspired by function calling APIs, this de- sign decouples the agent's 's intent into discrete action types and their corresponding parameters. This approach simplifies the learning task for the procedural model, allowing it to focus on grounding high-level subgoals specific, executable operations. Table 7 provides comprehensive summary of each action, its parameters, and its operational description within our framework.
Reward Design. Our reward design distinguishes between the training- free high-level planner and the learning-based low-level executor. The high-level planner, тH, does not optimize its parameters via reward signals; instead, uses the sparse, binary task-completion feedback from the environment solely to trigger its SRLR self-evolution loop.
The training of the low-level executor, TT. is guided by dense, step-wise composite reward signal Rg This signal is designed to provide fine-grained feedback on the quality of the generated actions and is composed of two key components: format reward and a content reward.
Format Reward (rtmt). This reward component ensures that the model's 's output strictly adheres to our predefined tool-calling schema. An action can only be parsed and executed by the environment if it is formatted correctly. We define this binary indicator:
(o,) = 1 for correctly matches the <Iool_call>{ w.t.aaall.....//oooaaaaaaaa |</ttol.caal>>>> schema), where o, is the raw text output generated by the model at step t. A reward is given for a valid format, and 0 otherwise.
24

---

Published as a conference paper at ICLR 2026
Table 6: Overview of the 20 applications and the number of associated tasks in the Android- WawldeRawles et al. 2024). The description for each app highlights its core functionality.
Application
Description
# Tasks
Simple Calendar Pro
A calendar app for creating, deleting, and man- aging events and appointments.
Settings
The Android system settings app for managing device settings such as Bluctooth, Wi-Fi, and brightness.
15
Markor
A note-taking app for creating, editing, deleting, and managing notes and folders.
Broccoli - Recipe App
A recipe management app for adding, deleting, and organizing recipes.
13
Pro Expense
An expense tracking app for adding, deleting, and managing expenses.
9
Simple SMS Messenger
An SMS app for sending, replying to, and re- sending text messages.
7
Tracksacks
A sport tracking app for recording and analyz- ing activities, durations, and distances.
Tasks
A task management app for tracking tasks, due 6 dates, and priorities.
Clock
An app with stopwatch and timer functionality.
4
J
Joplin
A note-taking app.
Retro Music
A music player app.
4
Simple Gallery Pro
An app for viewing images.
4
Camera
An app for taking photos and videos.
Chrome
A web browser app.
3
Contacts
An app for managing contact information.
OsmAnd
A maps and navigation app with support for adding location markers, favorites, and saving tracks.
3
VLC
A media player app for playing media files.
3
Audio Recorder
An app for recording and saving audio clips.
Files
A file manager app for the Android filesystem, used for deleting and moving files.
2
Simple Draw Pro
A drawing app for creating and saving draw- ings.
Content Reward (Fcontent). Given a correctly formatted output, this component evaluates the oper- ational correctness of the action a, by comparing it to the ground-truth expert action â;. The reward assesses both the chosen action type (c.g., click vs. swipe) and the precision of its parameters (e.g., coordinates). The content reward is defined as:
Toontent (a,, 4z) 1 of
type(ar) = type((r) A [[param(aa) - (ā:)l( < }
25

---

Published as a conference paper at ICLR 2026
Table 7: The structured action space of K2-Agent. Each action is defined function call with specific arguments to control the mobile device.
Action
Description
Arguments
click
Performs a standard, short tap on a specific screen location. Used for activating buttons, selecting items, or placing cursor focus.
coordinate
long-press
Executes a sustained press at given coordi- nate. Essential for tasks like selecting text, opening context menus, or revealing hidden options.
coordinate
swipe
Drags from starting point to an ending point. Used for scrolling, navigating pages, adjust- ing sliders.
coordinate, coordinate2
type
Inputs a character sequence into the currently focused text field. This action directly injects text, bypassing the on-screen keyboard.
text
system.button Triggers system-level hardware button com- mand, such as navigating back or returning to the home screen.
button
terminate
Ends the current task episode, reporting the status final outcome. This signals to the high-level planner whether the goal was achieved.
answer
Provides a natural language response. This action is specifically used for information re- trieval tasks where the goal to find and report information rather than manipulate the UI.
response_iext
where type(-) returns the action's type, and param (-) extracts its parameters. For coordinate-based actions, the norm || || is the Euclidean distance (Tz), while for text-based actions, it corresponds to an exact string match. The tolerance threshold is used for coordinate matching.
Total Reward. The final reward for training is weighted combination of the two components:
R₂ Amm (om) + Asontent Feontcnt (az, âz).
In our implementation, we set Amm = 1.0 and Agontent = 1.0. Empirically, this balanced weight- ing enables the 7B executor to achieve favorable trade-off among format compliance, grounding accuracy, and convergence speed.
D.2 EXTENDED QUANTITATIVE ANALYSIS
D.2.1 ANDROIDWORLD LEADERBOARD SNAPSHOT
We provide here an anonymous snapshot of the official AndroidWorld leaderboard as of August 2025. Figure 10 shows the ranking of K2-Agent, which achieves a success rate of 76.7%. placing 1st among all methods that rely solely on raw screenshots and open-source backbones. For fairness and compliance with the double-blind review process, our submission was made through an anonymous GitHub repository and contains no identifying information. Competing systems that leverage additional privileged inputs (e.g., the accessibility tree) or closed-source backbones are also listed for reference.
D.2.2 DETAILED PERFORMANCE STATISTICS
To provide a granular view our agent's performance and facilitate detailed comparisons, Table g presents the success/failure outcome for K2-Agent and several key baselines every of the
26

---

Published as a conference paper at ICLR 2026
Androichorid Leaderboord lbstt updote: 25/09/20261) 8
bell
IIA
Hist
BB
.LA
RIEE
Helease Eate
Rass Source
Model
Opert
Model
Seee
Miib
Becee Rabe
Seslndayy
82000
Lane Eneeel
Diibasee Au sudeee sowe For
E2009
Moyye
Orra
76.1
200500
Dan C014
Khaget ucpnve
30
Cacennal Ally
7501
18
5305
GukDwu33
Comeaha
10
1300
730
6501
18
0309
19
1330
150d
Train comtra
12
16
Aper
Sow atat
565
1322 U13335
12304 Ara-t
Usea
OfT.4 Ade-)
Coserntt
6661
122844
Coil ral
26
OPTi Tukk
ACTy te
5611
Figure 10: Public leaderboard of AndroidWorld of August 2025, showing K2-Agent ranked 1st among all methods using only raw screenshots.
1 116 tasks in the AndroidWorka benchmark. This table also includes the results from declarative knowledge transfer experiments, showing the performance of K²-Agent when its high-level planner replaced with Gemini and GPT--4o backbones using the same evolved knowledge base. This allows for a direct, bask-by-task assessment of where different models excel or fall short.
Table 8: Detailed performance comparison on all 116 tasks in AndroidWorld.
K2-A (R--Aget(Geemin)
K²-A Pr-Agent(Gpt-40n
UI- Hl-Venus-72N 72B
K3-Agent
mobile-use
DroidRun
Task
o
AudioRecorder-Fileemme
BrowserDraw
BrowserMaze
BrowserMultiply
CameraTakcFhoto
CameraTakevidec
clodsstogMaccceeusscter..y
ClockStopWatchhuunning
ClockTimerkntry
ContactsAdcContactt
ContaetssXeeConssettrrttttt
ExpenseeccaMultiiplee
Expenseacc@5ing1e
Expenseoeeleteeuplllcctees
Expganseeelltteebppllctttt
ExpaasseDeleteeMaliipeee
ExpenssDDeletteuuliiipp...
Continued next page
27

---

Published as a conference paper at ICLR 2026
Table 8 continued from previous page
K-AAgnnt
K--Agent(Gpt-tog
UI- Ml-Venus-2BB
K2-Agent
mobile-use
DroidRun
Task
Expenss@DeleteSinglee
FilesDeleteFile
FilesMoveFilc
MarkortoddNotccccaddr
xarkoorchangcllotCCntettt
MarkorCreeateFolderr
MarkorCreatteNote
Markorchreatellcteanddiis
MarkooDDeleecaalNNootes
WarkeotceleteeeVeeesttttteee
MarkorDDeleteNotee
MarkorEdit:Ntte
MarkorMergeeNttes
MarkorMoveNotee
Yarkortraasccribeeeccii
Markortrannerribeiidee
NotesIsTodo
hotesskeettnngateeddeCCCuttt
MeteesRccipeInggeeeeettCoottt
Notes:trodolltemCCcunt
OpanApp//askivvl
OsmAndFavorite
OsmAndMarker
OsmAndTrack
RecippskciMaltiipleeecipsss
Recipetodd-Promiiage
Recipexdd--FromMrrkor
Recipe:kd-FrromMarkkt2
Recripsskd@Singgeeeecciee
Re:ppetlalatte@lplllcsseeeeeesse
Recigebblsccccuppllccteeeeeedeee
Recijpellelett--iiihhhMe111
tecippeleeetttsiinglleeeeeieeeep
Recippelelette--iibhllleiee
RetrooCreetteelayllist
Retro@llayinn@ueeee
RetropPaaylisttDuration
RettroSavePlayllist
SavecopyOOFccccipttaaaaaal
SimpleecalenddarAdddddeeeeent
siapleccalennaar-ttttWWeeee
Simpleecaleeddaa--Tooorrrovv
Siaglleealerraareeeeeteveves
Singl]eechlendaarreeeeetteeeeeer
X
Continued on next page
28

---

Published as a conference paper at ICLR 2026
Table 8 continued from previous page
K--Agent(Geminl
K--Agent(Gpt-bo
UI- VI-Venus722B
K2-Agent
mobile-use
DroidRun
Task
Shinleecallendarrrveetttttttt
SimpleecalenddaaeeeeEEEnnn
Simpleecallrddar-RitttaPrrroo
SimpleSms/Repyy
SimpLeSmssReend
SimpleSmsSend
Siam:/eesnsSeenddeeeeeeedddddess
SportsstrackerrFForeeee
SportssTracker--kctiivtyy
sportt/7aacher/cccaallissaaee
SysticmBBluctcoootttuuuoofff
systremmiilsettoochrrommmm
aystemmmihiettcchhuoooooooeenii fy
systemmBrrightnnsssaaaxxx
Systemaa:rcghhunsssslaaavvrrr
SysteemBBrrigghhttesssss/
systemCCooyTooollpbbaad
Gystemmiiiiuurooff
SystcomMLLLTurrnoffeeefff
Systamm/if:Turrnnn
Systemmiiiffuuurnnnnerrrrfyyy
X
TasksDDueSexxtNeck
TasksDueOnDate
TaskeHlighaFriciityyTaasss
Tasks faakesiincompleeelaakkksmnaa
furnonwiifianddeeneep
VIcCreatePlaylist
X
X
X
VIeCraatee/eelayyiist
X
X
X
Success Rate (%)
76.7
74.1
72.4
65.9
62.9
58.6
E QUALITATIVE ANALYSIS AND CASE STUDIES
E. GENERALIZATION CASE STUDIES
E. DECLARATIVE KNOWLEDGE TRANSFER ACROSS BACKBONES
To validate the model-agnoste nature of the declarative knowledge (Kc), we transferred the final knowledge bases evolved by the 2ren2.5-VL-722 planner to planners using Gemini-2.5-PH and GPT-4o backbones. The transfer was conducted zero-shot setting, with the low-level ex- ecutor held constant. The detailed per-task results are presented in Table 8 The aggregate success
29

---

Published as a conference paper at ICLR 2026
rates- 72.4% for the Gemini-bast based planner and 58.6% for the GPT-4o-based planner-confimm that the declarative knowledge fundamentally generalizable.
Our analysis reveals three further findings. First, the knowledge demonstrates essential portabil- ity; as shown in Figure S(a), the core strategies distilled by SRLR are explicit and robust enough to improve performance across different model families. Second, an adaptation cost is evident in the performance gap between the original and new backbones. This is expected, as the linguis- tic phrasing and strategic details of the knowledge base were co-adapted through interaction with the Qwen model, and new models may incur a performance penalty when interpreting this tai- lored knowledge. Most notably, we observed the emergence of new capabiliitie. On several tasks where the original Qwen planner failed, such as SimpleCalendazlocatt ionOfEvent and Durat on, the planners using Gemini or GPT-4o succeeded with the exact same knowledge base. This highlights powerful synergy where the transferred knowledge provides the correct high-level plan, and the superior intrinsic capabilities of the new backbone model enable it to successfully execute previously intractable steps.
peortsTrackerToe
E.1.2 PROCEDURAL SKILL TRANSFER ACROSS BENCHMARKS
To comprehensively evaluate the generalization of learned procedural skills, we test the low-level executor, trained on AndroidWorld, on two distinet benchmarks in a zero-shot setting. We first use ScreenSpot-v2 to assess its fundamental, single-step grounding capabilities across platforms, and then use Android-in-the- Wild (AitW) to evaluate its applicability in complex, long-horizon tasks.
rigorously assess core GUI grounding capabil- ities, conducted transfer experiment the complete ScreenSpot-v2 benchmark (Wu et al. 2024). ScreenSpot-v2 is reliable standard, containing tasks across three distinct domains: Mobile (IOS/Android) Desktop (Windows/macCSS,, and Web. The crucial aspect of this test is the do- main mismatch: our executor, trained exclusively on AndroidWorld (mobile) data, was evaluated without any fine-tuning. This tests the hypothesis that the learned skills are fundamental enough to transfer not only to unseen mobile apps but also to entirely different operating paradigms.
Fundamental Grounding on ScreenSpot-v2.
As detailed in Table 9 K2-Agent's executor achieves remarkable 91.3% overall accuracy. This strong performance, despite the challenging cross-platform setting, validates our core hypothe- sis. By decoupling and focusing on procedural knowledge, the executor learns a robust, platform- agnostic visual grounding model rather than memorizing platform-specific patterns. This powerful generalization demonstrates that the executor's "muscle memory" fundamentally about under- standing visual language, making it highly transferable component.
Long-Horizon Application on Android-in-the-Wiin Willd. Beyond single-step grounding, we also evaluated whether the learned procedural skills can be effectively chained to solve complex, multi- step tasks. We deployed the same executor, again without any fine-tuning, on the long-horizon tasks of the Android-in-the-Wi
benchmark. For this experiment, the high-level planner was boot- strapped with a single expert demonstration for each task subset to rapidly generate high-level plan.
As shown in Table 2 on AitW-General and 68.3% on Aith-WehShopping. This significantly surpasses prior methods based on SFT, RL, or closed-source models, confirming that the robust procedural skills learned on AndroidWorld serve as a strong foundation for solving complex, unseen tasks.
K2-Agent achieves state-of-the-art performance, with success rates of 86.5%
E.2 TRAJECTORY VISUALIZATIONS
To provide a more intuitive understanding of our agent's behavior, this section presents visual case studies of both successful and failed trajectories.
E.2.1 SUCCESSFUL TRAJECTORY ON A COMPLEX TASK
Figure II illustrates complete steps from successful execution of the complex, multi-app task MarkorCreateNoor ee eAndSms. This trajectory demonstrates the effective synergy between the high-level planner and the low-level executor. At each stage, the planner, guided by its evolved
30

---

Published as a conference paper at ICLR 2026
Table 9: Zero-shot performance of the A2-Atent executor the ScreenSpot-v2 benchmark, com-
pared to other state-of-the-art GUI grounding models. Our executor demonstrates competitive per- formance, highlighting the strong generalization of its learned procedural skills.
Mobile
Desktop
Web
Agent Model
Text
Icon
Text
Icon
Text
Icon
Overall
Operator OpenA) 2025
47.3
41.5
90.2
80.3
92.8
84.3
70.5
Claude 3.7 Sommer (Autifopic
20256
87.6
UI-TARS-1.5 (Qin èt 2025
94.2
Seed-1.3-VL GBo
95.2
SeeClick (Cheng
20A4
78.4
50.7
70.1
29.3
55.2
32,5
55.1
OmniParser-vvZ Yu 2025
95.5
74.6
92.3
60.9
59.6
80.7
Qwen2.55VVL-355
73.5
88.1
58.6
71.4
80.9
UI-TARS-2B (Qin 20.6
95.2
79.1
90.7
68.6
87.2
78.3
84.7
DS-Atlas-Base--11 (WD [Wa 2024
95.2
75.8
90.7
63.6
90.6
77.3
85.1
OS-Atlas-Base-71 eWir et 2024
83.4
69.3
79.8
JEDI-3B Xic et 2025
96.6
81.5
96.9
78.6
88.5
83.7
88.6
Qwen2.5-VV (Bai et 2025
97.6
87.2
90.2
74.2
93.2
81.3
88.8
UI-TARS-72B (Qin el 2025
86.3
91.2
87.9
91.5
87.7
90.3
UI-TARS-7B (Qin
2025
96.9
89.1
95.4
85.0
93.6
K5.2
91.6
JEDI-7B Xie ara.. 2026
96.9
87.2
95.9
87.9
94.4
84.2
91.7
GUI-Owl-7B: (77BB0
a.. 2025
99.0
92.4
96.9
85.0
93.6
85.2
92.8
Yo GUI-Owl-32B
2025
90.0
87.8
86.7
93.2
Me-Veenu-Grountee
af
2025
99.0
90.0
97.0
90.7
96.2
88,7
94.1
Venus Ground -2H (Tu al.
2025
99.7
93.8
95.9
90.0
96.2
92.6
95.3
K Ag-Agt (Executor only)
96.9
80.6
95.9
83.6
95.3
90.6
91.3
knowledge base (Ka), issues a clear and logical sub-goal (knowing what). The C-GRPO-trained ex- ecutor then successfully grounds this sub-goal into precise, low-level action the screen (knowing how), seamlessly navigating between creating a note in one app and sharing its content via another.
E.2.2 ANALYSIS OF GENERALIZATION AND FAILURE MODES
Our framework demonstrates powerful dual- nuulleeneralization capabilities, where both high-level declarative knowledge and low-level procedural skills transfer effectively to unseen tasks.
Declarative Knowledge Generalization. We evaluated the planner's ability to adapt its declara- tive knowledge to novel tasks in the AitW benchmark. For each task type, the SRLR loop was bootstrapped from a single demonstration, allowing the planner to rapidly form a new strategy. Fig- 13 showcases the agent successfully completing distinct, unseen tasks. This demonstrates that the SRLR self-evolution process produces robust, high-level strategies that are not mere scripts but generalizable plans that be effectively applied solve problems in applications.
Procedural Skill Generalization. Figure 14 provides visual testament to the executor's proce- dural generalization. Though trained only on AndroidWorld, executor correctly identifies target UI elements on unseen mobile, desktop, and web interfaces from the ScreenSpot-v2 benchmark. This confirms that C-GRPO training develops fundamental, caaffrr-agnosse visual grounding capability rather than overfitting to specific app UIs.
Failure Analysis. Our analysis of failure cases reveals a consistent pattern: the majority of re- from flaws in K2-Agent's framework (i.e., incorrect high-level plans or
maining errors do imprecise low-level actions), but from the intrinsic limitations of the current backbone VLM. Figure 12 visualizes typical example from the rotreatee wrroreeteelallliee.....eete.aaee task, where the agent cor- rectly identifies all songs but fails to add them in the strictly specified order. Other similar failures, such as those in ExpenseAddMu dipleeF romMa rkor (requiring multi-document reasoning) and Ma rrkorMe reMNotee (requiring long-context text handling), also point to challenges in com- plex instruction following and long-horizon reasoning. These tasks represent current frontier for foundation models, and we anticipate that as backbone models improve, these failures can be overcome without changes to the K2-Agent framework itself.
31

---

Published as a conference paper at ICLR 2026
planer
up
Marker
Type the 2000
Lova luvd evoocher
level coreetor
Teiak derd wnd
Cilar candrore
Erppe
corderani (546 og
High levil pleneer
levid
Haps foed glower
High Mower
Thoe
"Sp Shore lhitee
worls!
ciner.
Hond CrSLLE
Los lcal snatter
Colec' commeiie
Frep
Srep
Step ST
righ Mooee
Hiih levd plewer
Hore pome
Ausringer in sore
42200080000 Hueber Teok
the Rer
non to the phons
giok, 22g
pat seig
Chep
to serd 285,
COMPEETED
18t M813
Figure 11: Successful execution of the complex, multi-app task MarkorCCrateeNotenndG...
32

---

Published as a conference paper at ICLR 2026
Top oe recpede
fovell wer sage
Chemer wesieeal (4% 662g
Dreped diantd (5t6
Dalai (1S0, 2100
legh
poweer
Type tort Banger IXV
Har
oo latten
faid
Phyle
fird
Loe sracter
W
Poed taat 2797
(54) 1809
(140,001
lighh plneer
High lnve
Hrih level slewer
High livel planser
mene
eo the soarch
Typs yor Colden
anng
land Gosone
Lov lo GIGaTt
Lon fand GalLet
leall Gocarte
Coleat candintt
Fowe tust de
Caleit werdest
Shaads
High lead plamer
High lnni
levi Hanner
High Menee
Mells Paveetfee
COUILETES
oventtr
Polile
Nigg
Phinsront meceal
Map
Ligh
COMPLATIO
Error: Failed to follow the specified order when adding songs.
X
Priniaant sscidd
Figure 12: A representative failure case from the RetroCreatePlayliss task.
33

---

Published as a conference paper at ICLR 2026
High plane
livd
Google
Loe esshtr
Loo COCOPe
Loe fend toac
Resa seancannc
Peisk de diane
Crypel "Nunad
Cherta Junnet
stng!
High levi plener
High plawer
High lond plowe
Google
High plawer
Type "upii
you
Hosd arauter
Meiil tataahor
Poler
Prina
Chype' Neothell
Cheriom jurner"
Figure 13: Declarative knowledge generalization on Android-in-the-Will (AitW).
Stop
(20 30g
One Stop
Pall dwdd Vi
Extire Col
De Mg
pal
Figure 14: Zero-shot procedural skill transfer to the ScreenSpot-v2 benchmark.
34


Reviews:
[{"review_id": "aNLEzFS2An", "reviewer": "Reviewer_MQ9r", "summary": "This work proposed a new mobile control agents built on (V)LLMs with a hierarchical design. Specifically, the authors proposed a high-level planner that is capable of reasoning with the task goal, storing knowledge from execution and analysing failure patterns to better solve the problem. A new C-GRPO method is proposed to fine-tune the low-level execution policy for better performance in long horizon tasks.", "questions": "Please see the weakness part.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "This paper is well written and easy to follow.\n\nThe proposed method of C-GRPO is new.\n\nExperimental results on benchmark environment show positive gains.\n\nAblation study shows the effectiveness of some high-level designs proposed in this work.", "weaknesses": "The overall novel in the developed technique is not strong. In the domain of AI planning with LLM/VLM, approaches like task decomposition, building memory and knowledge graph or reflective planning have been widely used in different applications. This work largely follows these patterns as well.\n\nSome technical design lacks sufficient motivations or analysis. It is unclear in some technical sections what the key problem targeted to address is and why the process is designed in the current way. Please see the following several detailed points:\n- Section 4.2.1: it is proposed to summarize the knowledge into rules or checklist, but there is no analysis on how robust this representation is. In general, what type of knowledge can the summarize induce? What are the unknow knowledge or failure cases that the summarize cannot induce? Will the summarizer induce wrong knowledge that harms the following steps?\n- Section 4.2.2 - Task-level: It would be better to illustrate what kind of root-cause of the failure can be captured by the reflection from the episode trajectory, and what cannot. Are there any cases where the VLM fails to identify the reason of the failure? For example, where the failure happens underlying in the operation system that cannot be directly observed from screenshots.\n- Section 4.2.3:\n  - Prepending a variable length expert prefix to the model input is used to gradually improve the training. However, the reason why the policy on original query got improved through training with query and several hints is less well explained. It would be better to show the performance like the reward of the original query with training on query + hints during the curriculum training process. This can improve the understanding of generalizing from query + hints to query alone.\n  - Another existing similar approach in RL to guide exploration is hindsight experience reply. It would be better to have a study on this approach also.\nOverall, the proposed system as whole seems provide gains in training and application, but the developed approach did not provide strong technical insights on why individually proposed component bring improved performance.\n\nFigure 5, there is no standard deviation on the reward in figure b.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "gfmp4eMAUl", "reviewer": "Reviewer_2B17", "summary": "The paper proposes $K^2$-Agent, a hierarchical framework for mobile device control that explicitly decouples declarative “know-what” (a high-level planner distilled via a Summarize–Reflect–Locate–Revise, SRLR, loop) from procedural “know-how” (a low-level executor trained with a curriculum-guided C-GRPO objective). On AndroidWorld (116 tasks across 20 apps), the authors claim state-of-the-art 76.7% success “ranking 1st … among methods using only raw screenshots and open-source backbones” and show transfer to ScreenSpot-v2 and Android-in-the-Wild (AitW) without fine-tuning. The intended scope is screenshot-only agents on Android emulator tasks, plus cross-benchmark skill transfer.", "questions": "* How many seeds were used for Table 1 and Figure 1? Please report mean ± std over ≥3 seeds and add 95% CIs to plots. \n* Right now, it is hard to tell whether the gains come from C-GRPO itself or. from extra compute or curriculum variations. You should compare GRPO vs C-GRPO with everything else identical: model init, data, rollout length, batch size, optimizer, KL/clip settings, and exactly the same number of environment interactions (and similar wall-clock within ±5%). Also please report the learning curves of these runs.\n* Vary the key curriculum knob(s) you introduce (e.g., mixing ratios, scheduling temperature T if applicable) across a small grid (e.g., 3–5 values). For which hyperparameters is your method brittle or robust?", "limitations": "", "rating": 4, "confidence": 2, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "* Clear hierarchical decomposition (SRLR + C-GRPO) with reasonable mathematical formalization (PPO-style clipping; explicit content/format rewards).\n* The paper’s split between a high-level SRLR planner (“knowing what”) and a low-level C-GRPO executor (“knowing how”) isn’t just conceptual; you show the actual SRLR prompts and output formats. This makes the approach inspectable and reuse-friendly.\n* Even with screenshot-only I/O, the result on AndroidWorld is pretty strong as shown in Table 1.\n* The executor’s reward is specified precisely (format + content, Eq. (5) and total reward definition) and the action space is enumerated (Table 6), which helps reproduction and critique.", "weaknesses": "* The authors mention that “Human experts achieve about 80% average success” on AndroidWorld without details (line 373): annotator count, expertise, task sampling, time limits, or inter-rater protocol.\n* The AndroidWorld results do not report of seeds, dispersion, or confidence intervals (CIs). Without multi-seed evaluation, the “SOTA” claim is statistically fragile.\n* The executor is trained on 606 single-step samples derived from 116 demos (Appendix B.2.2). Even with the stated seed-based split controls, the paper doesn’t quantify app- or template-level overlap between training demonstrations and evaluation task distributions; leakage through UI idiosyncrasies remains plausible without stricter controls or OOD app tests.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "mkQIPZPUPQ", "reviewer": "Reviewer_tNhe", "summary": "This work tackles long‑horizon mobile device control and argues that agents should separate two kinds of knowledge for accurate planning and execution: (i) declarative “knowing what” for task planning, and (ii) procedural “knowing how” for precise UI actions. The proposed K²‑Agent is a two‑layer planner–executor:\n\nHigh‑level planner (know‑what): a training‑free VLM that bootstraps from one demonstration per task and maintains a textual task knowledge base (KG) updated by a Summarize Reflect Locate Revise (SRLR) loop. SRLR distills an initial plan from a demo, analyzes failures, identifies the wrong decision points, and applies atomic edits to the knowledge base.\n\nLow‑level executor (know‑how): a trainable VLM optimized with Curriculum‑guided GRPO (C‑GRPO). C‑GRPO (1) builds error‑decoupled replay pools for type vs. parameter errors, and (2) uses dynamic demonstration injection to prepend variable‑length expert prefixes for difficult samples; the policy is updated with GRPO.", "questions": "* What is the motivation of applying the dynamic length prefix? Why does this improve performance?\n* What is the dynamic length expert prefix and how is the length dynamically applied? For example,  if the expert prefix something like 'Be sure to answer in the format of ...', how do you dynamically change the length of this prefix?\n* Regarding the single demonstration provided, is the provided task excluded from the benchmark? Also, if a successful task is provided per category of the AndroidWorld benchmark, it seems not fair to say that this method utilizes less information than other methods that only use screenshots or A11y trees. \n* How is the KG constructed from the high-level planner utilized by the low-level executor? The reverse is clear to me, the demonstrations of the low-level executor fails is provided to the planner.", "limitations": "", "rating": 4, "confidence": 3, "soundness": 3, "presentation": 2, "contribution": 2, "strengths": "* The experimental results are strong. Especially, the KG graph being transferred to different VLMs, and the low-level executor being transferred to AiTW and ScreenSpot-v2 is interesting.\n* Proposing to train the low-level executor with reinforcement learning while refining the planner’s knowledge base through training-free self-evolution (SRLR) offers an efficient division between low-level actions and declarative knowledge planning & refinement.", "weaknesses": "* The overall flow of section 4 itself was easy to understand, but specifically what each component is and how they operate is unclear in several parts. Specifically, (1) what 'atomic' edits are and how they are applied to the KG was unclear until looking at the appendix. (2) In dynamic demonstration injection, what 'variable length expert prefix' is unclear. (3) What the single demonstration that is provided is, and whether this is identical or different from the AndroidWorld benchmark is unclear\n* If the benchmark provides single expert demonstrations per task category, this may be providing more information than other results", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "cY4uksTusg", "reviewer": "Reviewer_UG52", "summary": "The paper **“K²-Agent: Co-Evolving Know-What and Know-How for Hierarchical Mobile Device Control”** introduces a cognitively inspired hierarchical agent that explicitly separates declarative (“know-what”) and procedural (“know-how”) knowledge to improve performance on mobile device control tasks. The system combines a **symbolic planner** that refines task knowledge through the **SRLR (Summarize–Reflect–Locate–Revise)** self-evolution loop, and a **reinforcement learning executor** trained with **C-GRPO (Curriculum-Guided Group Relative Policy Optimization)**. This dual-loop architecture enables co-evolution: the planner learns better strategies from execution feedback, while the executor gains structured guidance from the planner’s task decomposition. Experiments on the AndroidWorld benchmark demonstrate that K²-Agent achieves a **76.7% success rate**, surpassing prior open-source baselines while requiring minimal supervision (one demonstration per task). The work bridges symbolic reasoning and embodied learning in a cognitively grounded way, suggesting potential for broader applications in generalist AI systems.", "questions": "1. How scalable is the SRLR loop when applied to tasks requiring multiple interdependent app contexts (e.g., cross-app workflows)?  \n2. Could C-GRPO be adapted for domains beyond visual mobile control—such as web navigation or embodied robotics—and if so, what adjustments would be required?  \n3. Does the declarative knowledge base support compositional reuse, allowing the agent to combine skills learned in separate tasks into new ones?  \n4. How sensitive is the system to the initial demonstration quality—can it recover from a poorly demonstrated “seed” trajectory?  \n5. How are symbolic edits validated to prevent catastrophic forgetting or the accumulation of contradictory task rules over long SRLR iterations?", "limitations": "", "rating": 6, "confidence": 1, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "- **Novel cognitive framework:** The clear distinction and co-evolution of declarative and procedural knowledge mirror human learning mechanisms, offering both conceptual clarity and practical benefits.  \n- **Methodological innovation:** The SRLR loop provides a systematic mechanism for reflective reasoning and self-correction, while C-GRPO elegantly handles data imbalance and sparse rewards through curriculum design.  \n- **Strong empirical results:** The system achieves state-of-the-art performance on AndroidWorld with extremely low data requirements, showing both efficiency and robustness.  \n- **Interpretable learning process:** The explicit task knowledge base and revision history improve transparency and allow fine-grained analysis of reasoning and execution errors.  \n- **Broader relevance:** The cognitive analogy to human dual-memory systems and the hierarchical design are relevant to multiple domains beyond mobile control, such as robotics and multimodal planning.", "weaknesses": "- **Limited evaluation diversity:** The experiments focus primarily on AndroidWorld; results on other benchmarks (e.g., WebArena, mobile navigation, or real-device tasks) would strengthen claims of generalization.  \n- **Scalability concerns:** The SRLR loop may involve significant overhead as task complexity grows, especially if symbolic reasoning steps become large or interdependent.  \n- **Ambiguity in error localization:** The “Locate” phase of SRLR appears manually defined or heuristic-based; it is unclear how reliably the system identifies and generalizes error points without human intervention.  \n- **Comparative analysis:** The work could benefit from deeper comparisons with alternative hybrid systems that combine reasoning and RL (e.g., ReAct, Voyager, or RPA-style architectures).  \n- **Reproducibility limitations:** Key implementation details—such as how knowledge base edits are represented or parameterized—are under-specified, making replication challenging for other researchers.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)