- Rating
- 3
- Confidence
- 2
- Informativeness
- 3
- Presentation
- 3
- Soundness
- 3
Read review
Paper summary
GUIFlow accelerates GUI agents through historical KV reuse, selective visual and language-state updates, and speculative decoding from previous actions. Across AITW, Mind2Web, and OSWorld, it reports approximately 3.3–3.5× FLOPs reductions and 1.9–2.6× processing-latency speedups, with performance generally close to dense inference.
Critical strengths
-
The method offers a novel and coherent integration of incremental computation across visual encoding, prefill, and decoding. Source-aware tracking and representation-guided refresh address the challenge of reusing states under evolving contexts without additional training.
-
The approach is effective across multiple backbones and both offline and closed-loop evaluations. Reported processing-latency speedups of approximately 1.9–2.6× demonstrate practical benefits beyond FLOPs reductions.
-
The paper is well written and clearly organized. It explains the problem and motivation effectively, making the sources of temporal redundancy and the rationale for each component easy to follow.
Critical weaknesses
-
All three components of the method have close precedents: historical KV integration resembles CacheBlend (EuroSys 2025) in reusing cached states beyond unchanged prefixes; current-observation refinement resembles VLA-Cache (NeurIPS 2025) in selectively refreshing visual-token KV across successive observations; and trajectory-guided decoding follows the retrieval-based draft-and-verify principle of REST (NAACL 2024), using previous actions instead of an external datastore. While their integration and adaptation to GUI interaction are valuable, the paper could more clearly distinguish the new mechanisms from established techniques and isolate their benefits through targeted comparisons.
-
CodecSight (https://arxiv.org/pdf/2604.06036) uses codec metadata to guide visual computation reduction and selective KV refresh. Could motion vectors or residual signals provide cheaper or more informative change detection than pixel differences in GUIFlow, particularly during scrolling or window movement? A discussion of applicability and trade-offs would be useful.
Questions for authors
-
What are the main technical advances beyond CacheBlend’s non-prefix KV reuse, VLA-Cache’s cross-frame selective refresh, and REST’s retrieval-based speculative decoding? Could targeted comparisons isolate the benefits of GUIFlow’s new mechanisms from those of their integration?
-
CodecSight uses codec metadata to guide visual computation reduction and selective KV refresh. Could motion vectors or residual signals offer cheaper or more informative change detection than pixel differences, especially during scrolling or window movement?
-
Tables 2–3 report 70.85 T FLOPs and 1.50 s per step, whereas Table 5 reports 224.76 T and 3.57 s at the default . Please clarify which components are enabled in the sensitivity study; the shared parameter settings alone do not explain this discrepancy.
-
In Table 4, adding speculative decoding increases strict success from 24.65% to 26.87%. Under identical inputs, prefill states, and numerical decisions, the greedy verification procedure should preserve ordinary decoding outputs. Please explain whether this difference comes from environment variability, numerical effects, or other experimental changes.
-
Table A3 describes measurements as paired by “common task-step keys,” but the same step index can correspond to different observations after trajectories diverge. Please clarify whether these comparisons use identical replayed inputs or merely matching task and step indices.
-
The abstract reports up to 3.49× speedup without explicitly identifying it as a FLOPs ratio. Since measured processing-latency speedups are 1.94–2.55×, the abstract should distinguish computational savings from wall-clock acceleration.
I will consider raise my score if questions are addressed.
5 comments
W2 / Q2: Applicability of motion-vector and residual signals
We thank the reviewer for the suggestion. Inspired by CodecSight, we replace pixel-difference detection in GUIFlow's current-frame visual updates with motion-vector and residual signals, keeping the other components unchanged, and conduct additional experiments with Qwen3-VL-8B-Instruct on OSWorld. This experiment adapts its change-detection idea, with results shown below.
| Method | Strict task success rate | VLM FLOPs (T/request; speedup) | Total processing latency (ms/request; speedup) | Detection time (ms) | Vision patch recomputation ratio |
|---|---|---|---|---|---|
| Dense | 23.55% | 247.007 (1.00×) | 3764.47 (1.00×) | — | — |
| GUIFlow | 26.87% | 70.846 (3.49×) | 1502.69 (2.51×) | 0.44 | 53.04% |
| CodecSight-inspired adaptation | 24.38% | 85.385 (2.89×) | 1832.50 (2.05×) | 123.84 | 78.92% |
1. Motion-vector and residual detection incurs higher overhead without delivering greater computational savings.
Detection time increases from 0.44 ms to 123.84 ms, while the vision patch recomputation ratio increases from 53.04% to 78.92%. Total processing latency consequently increases by approximately 21.9%, reducing the latency speedup from 2.51× to 2.05×; strict task success also decreases by 2.49 percentage points.
2. The value of these signals depends on the input source and task characteristics.
CodecSight targets compressed video streams and uses motion vectors and residuals available during decoding to guide computation. GUIFlow receives raw screenshots, so obtaining and processing these signals introduces additional overhead. Codec-block motion information must also be mapped to the model's patch-update requirements; small motion does not imply unchanged button states or text. In our GUI setting, pixel differences achieve a better quality–efficiency balance at a lower detection cost. We will discuss CodecSight in the related work and explain its differences from GUIFlow in input format and change-detection mechanisms.
Q3: Computational-cost differences between Tables 2–3 and Table 5
We thank the reviewer for pointing this out. Tables 2–3 evaluate full GUIFlow, whereas Table 5 is a single-component sensitivity study with only TokenLease enabled. The original caption did not explicitly list the component settings, creating ambiguity. We will clarify this in the full version.
The configurations are compared below:
| Component or metric | Tables 2–3: Full GUIFlow | Table 5: TokenLease sensitivity study |
|---|---|---|
| Historical screenshot KV reuse | Enabled | Disabled; historical context is recomputed |
| Sparse current-frame vision computation | Enabled | Disabled; full vision computation is performed |
| Current-frame LLM TokenLease | Enabled | Enabled |
| Trajectory-guided speculative decoding | Enabled | Disabled |
| FLOPs / step | 70.85 T | 224.76 T |
| Latency / step | 1.50 s | 3.57 s |
Table 5 disables the other acceleration components to isolate the effects of TokenLease's probe depth and reuse limit on task quality and computational cost. Thus, the shared values of and indicate identical TokenLease parameters, not identical configurations of the entire inference pipeline. Tables 2–3 additionally benefit from historical KV reuse, sparse vision computation, and speculative decoding, explaining their lower FLOPs and latency. We will make these settings explicit in Table 5's caption and the experimental description.
Q4: Speculative decoding and improved closed-loop task success
We thank the reviewer for pointing this out. Given identical inputs, prefill states, and numerical decisions, greedy draft verification preserves ordinary greedy decoding outputs. Table 4 reports task success from actual closed-loop interactions, where the improvement must be understood in the context of interaction timing and state reuse.
1. Faster inference provides denser feedback from intermediate states, improving action prediction.
The Qwen evaluation configuration captures the next screenshot directly after action execution, without an additional wait for the interface to stabilize, while application responses and interface updates in OSWorld take time. For example, when an action enters five words, the next screenshot can capture the interface when only three words have appeared. We directly observed that accelerated interaction captured more such intermediate states, giving the model finer-grained information about task progress. This feedback enabled more timely and accurate subsequent actions and improved closed-loop task success. Thus, decoding equivalence on fixed inputs is consistent with the improved task performance observed in this experiment.
2. Lightweight computation and stable-state reuse can support both efficiency and output quality.
GUIFlow retains stable representations while recomputing changed regions, maintaining continuity across interaction steps with characteristics similar to temporal filtering. Prior work also shows that pruning can improve generalization through regularization [1], while EAZY reduces erroneous outputs by removing a small set of hallucination-inducing visual tokens [2]. These findings show that reducing redundant representations can both lower computational cost and suppress interference, providing a mechanistic explanation for maintaining or improving task performance under acceleration.
We will add the interaction timing, observed behavior, and related discussion to the full version, clarifying how reduced decision latency and denser environment feedback improve task performance in this closed-loop setting.
References
[1] Jin et al. Pruning's Effect on Generalization Through the Lens of Training and Regularization. NeurIPS, 2022.
[2] Che et al. Hallucinatory Image Tokens: A Training-free EAZY Approach to Detecting and Mitigating Object Hallucinations in LVLMs. ICCV, 2025.
Q5: Comparison protocol in Table A3
We thank the reviewer for pointing this out. We run Dense and GUIFlow independently on the same task set and measure model computation and latency along their actual closed-loop trajectories. We do not replay a fixed trajectory or perform step-by-step comparisons on identical inputs. The action and observation sequences can differ, so these results report model processing efficiency along actual closed-loop trajectories.
The lease acceptance and image-token reuse rates in Table A3 are computed directly from the internal records of each run. FLOPs reductions and latency speedups compare the actual execution costs on the corresponding tasks. We will revise the caption in the full version to explicitly describe this as an independent closed-loop comparison on the same tasks, avoiding the implication that "paired" denotes step-by-step timing on identical inputs.
Q6: Explicit identification of the speedup metric in the abstract
We thank the reviewer for pointing this out. The headline 3.49× in the abstract refers to a FLOPs speedup. Table 3 already reports FLOPs and measured latency speedups separately; the measured processing-latency speedups are 1.94–2.55×, excluding environment execution.
We will explicitly label the FLOPs speedup and report the measured latency gains in the abstract and main text of the full version, clearly distinguishing computational savings, model-side latency speedups, and end-to-end runtime speedups. We also provide the timing boundaries and a complete runtime breakdown in our response to Reviewer 2's W2.
We thank the reviewer for the careful reading and constructive feedback.
W1 / Q1: Contributions beyond prior work and the value of coordinated pipeline acceleration
We thank the reviewer for the suggestions. We address targeted experiments, specific mechanism differences, and coordinated pipeline design below.
1. Targeted mechanism ablations validate the contributions of cache-source tracking and adaptive refresh.
We add two controls: one compares current representations only with the previous step instead of their actual cache sources; the other replaces residual-budget-driven adaptive refresh with a fixed refresh ratio.
Full GUIFlow achieves the highest success rate among these configurations, outperforming the two controls by 8.89 and 7.78 percentage points, respectively. These results demonstrate the value of tracking each token's actual cache source during successive reuse and adapting the refresh set to representation deviations. They isolate the contributions of specific mechanisms and complement the component ablation in Table 4.
2. We will distinguish established principles from GUIFlow's specific designs.
GUIFlow builds on non-prefix cache reuse, selective cross-frame updates, and draft verification. Its contributions address the specific challenges of applying these mechanisms to multi-image, sequential GUI interaction.
3. Coordinated acceleration across the full pipeline is itself a substantive challenge.
A module that works effectively in isolation does not guarantee that task quality will be preserved when multiple modules are combined. From the perspective of information preservation and distortion control, approximations to visual representations and historical KV states affect downstream computation, and their errors can propagate through closed-loop interaction. Therefore, the most aggressive configurations selected independently for each module do not necessarily form the best overall configuration.
This challenge also motivates prior joint-optimization research: APQ jointly optimizes architecture, pruning, and quantization [1]; PRANCE jointly optimizes tokens and channels [2]; EfficientVLA and ElegantVLA accelerate VLA models through multi-module compression and dynamic compute scheduling, respectively [3] [4]. For multi-image GUI interaction, GUIFlow coordinates reuse across visual encoding, prefill, and decoding without additional training, controlling approximation errors across stages and interaction steps to expand the overall acceleration achievable while preserving task quality. We will include these contribution comparisons, mechanism ablations, and discussions in the full version.
References
[1] Wang et al. APQ: Joint Search for Network Architecture, Pruning and Quantization Policy. CVPR, 2020.
[2] Li et al. PRANCE: Joint Token-Optimization and Structural Channel-Pruning for Adaptive ViT Inference. IEEE TPAMI, 48(1): 283–298, 2026 (published online in 2025).
[3] Yang et al. EfficientVLA: Training-Free Acceleration and Compression for Vision-Language-Action Models. NeurIPS, 2025.
[4] Li et al. ElegantVLA: Learning When to Think for Efficient Vision-Language-Action Models. arXiv:2605.29438, 2026.