VLA-Cache: Efficient Vision-Language-Action Manipulation via Adaptive Token Caching
Authors: Siyu Xu
Yunke Wang
Chenghao Xia
Dihao Zhu
Tao Huang
Chang Xu
Venue: NeurIPS 2025 poster ()
Keywords: Vision-Language-Action Model
Efficient Inference
Robotics
Primary area: reinforcement_learning

Abstract: Vision-Language-Action (VLA) models have demonstrated strong multi-modal reasoning capabilities, enabling direct action generation from visual perception and language instructions in an end-to-end manner. However, their substantial computational cost poses a challenge for real-time robotic control, where rapid decision-making is essential. This paper introduces VLA-Cache, a training-free inference acceleration method that reduces computational overhead by adaptively caching and reusing static visual tokens across frames. Exploiting the temporal continuity in robotic manipulation, VLA-Cache identifies minimally changed tokens between adjacent frames and reuses their cached key-value representations, thereby circumventing redundant computations. Additionally, to maintain action precision, VLA-Cache selectively re-computes task-relevant tokens that are environmentally sensitive, ensuring the fidelity of critical visual information. To further optimize efficiency, we introduce a layer adaptive token reusing strategy that dynamically adjusts the reuse ratio based on attention concentration across decoder layers, prioritizing critical tokens for recomputation. Extensive experiments on two simulation platforms (LIBERO and SIMPLER) and a real-world robotic system demonstrate that VLA-Cache achieves up to 1.7× speedup in CUDA latency and a 15\% increase in control frequency, with negligible loss on task success rate. The code and videos can be found at our project page: https://vla-cache.github.io.

VLA-Cache: Efficient Vision-Language-Action Manipulation via Adaptive Token Caching
Siyu Xu', Yunke Wang', Chenghao Xia', Dihao Zhu', Tao Huang", Chang Xu! 'Scoool of Computer Science, University of Sydney, Australia
JJhhn Hopcropt Center for Computer Science, Shanghai Jiao Tong University, China (a. xu, yunke. wang, c. xuydsydney edu au,[cxia0515 dzhu0968) &uni. syddeyy wydney.ddeeee edu. au,
t. huangua edu.
Abstract
Vision Lasion-Lngguage-cctinn (VLA) models have demonstrated strong multi-modal reasoning capabilities, enabling direct action generation from visual perception and language instructions in end-to-end manner. However, their substantial computational cost poses a challenge for real-time robotic control, where rapid makiing is essential. This paper introduces VLA-Cache, training-free inference acceleration method that reduces computational overhead by adaptively caching and reusing static visual tokens across frames. Exploiting the temporal con- tinuity in robotic manipulation, VLA-Cache identifies minimally changed tokens between adjacent frames and reuses their cached key-value representations, thereby circumventing redundant computations. Additionally, to maintain action precision, VLA-Cache selectively re-computes task-relevant tokens that are environmentally sensitive, ensuring the fidelity of critical visual information. To further optimize efficiency, we introduce a layer adaptive token reusing strategy that dynamically adjusts the reuse ratio based on attention concentration across decoder layers, prior- itizing critical tokens for recomputation. Extensive experiments on two simulation platforms (LIBERO and SIMPLER) and real-world robotic system demonstrate that VLA-Cache achieves up 1.7x speedup in CUDA latency and 15% in- crease in control frequency, with negligible loss on task success rate. The code and videos can be found at our project page: httpt::t////t //vla- cache. github.
Introduction
Learning a robust and generalizable policy for robotic manipulation through policy learning has long been challenging problem [1] with traditional reinforcement learning approaches [2] 3 often suffering from poor robustness and limited generalization. Recently, the rapid advancement of foundational Vision-Language Models (VLMs) 44] 5 has demonstrated remarkable capabilities in multimodal understanding and generalization. Leveraging large-scale real-world robotic datasets 6. pioneering works [I] have introduced Lisiun-Language-. Action (VLA) models, which integrate vision and language modalities to directly generate robotic actions an end-to-end manner. This emerging paradigm holds great promise for enhancing the adaptability and generalization of robotic control systems, but leaves a large computational demand.
To mitigate the extensive cost of VIAA models, existing works often adopt generic acceleration techniques, such as model lightweighting [12, quantization [33, and early-exit [14). While effective to some extent, these methods often require architectural modifications retraining, and more importantly, they lack spec-fc design tailored to the intrinsic characteristics of VLA tasks. As
"Corresponding author.
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

result, they struggle to achieve an optimal balance between inference speed and action accuracy. In this paper, we step into the nature of VLA robotic manipulation that intrinsically different from the VLM models. Specifically, VLA tasks involve sequentially processing stream of temporally adjacent visual observations, where the environment often exhibits high spatial redundancy across time. As shown in Figure [T] large portions of the visual scene, especially background regions, remain static and semantically irrelevant to action decisions, yet are processed repeatedly at each time step. These static tokens contribute significantly to computational overhead while providing limited utility for downstream control. This motivates our proposed token caching mechanism, which explicitly exploits temporal redundancy in visual inputs reduce redundant computation without compromising decision quality.
To address the inefficiency introduced by repeatedly processing static visual information, we present VLAA-ache, training-free inference acceleration method that exploits temporal continu- ity robotic perception. Rather than recomputing all vision tokens at every timestep. VLA-Cache identifies tokens that exhibit minimal change between ad- jacent frames and reuses their cached key- value (KV) representations to bypass re- dundant computation. However, we ob- serve that not all visually static tokens can be safely reused. Some tokens, such as those near the gripper or target ob- ject, may appear visually unchanged but remain semantically active and crucial for accurate action generation. Naively reusing all static tokens results in sig- nificant performance drop as shown in Table T To mitigate this, VLA-Cache incorporates lightweight filtering mechanism based on decoder attention scores to exclude task- relevant tokens from reuse, ensuring that semantically critical regions are always recomputed with up-to-date features. Moreover, we observe that attention patterns vary across decoder layers, with deeper layers exhibiting more concentrated focus. To further optimize reuse, VLA-Cache employs layer-adaptive caching strategy that dynamically adjusts the reuse ratio per layer based on at- tention entropy, prioritizing precise updates in sensitive regions. These two mechanisms together enable substantial reduction in decoding overhead, especially in large-scale scale language decoders (e.g.. LLaMA [[5). Gemma [16)), which typically dominate the compute cost in VLA systems.
Pick the gray bowl.
Pick the gray bowl.
Previous Step (T-3)
Tokenise
Tolennie
LLM Decoder
LLM Decoder
Stalk
Oprares
Dysomi
Coche
Asi [1-3)
Uyddtt Caders
Fwitt Deating
Action
Figure 1: During the inference of the VLA model, static tokens of the input image remain largely consistent across steps. This consistency allows for caching the computa- tions of these tokens from the previous step.
The resulting method VLA-Cache offers training- free and soug-and-play solution for acceler- ating VLA models without sacrificing action performance. We evaluate -L---chhe on robotic manipulation tasks across two simulated environments (LIBERO [17] and SIMPLER (18) and three state-of-the- VLA models (Open [T., CogAct 19. and OpenVLA-OFF consistently delivers over 1.7x acceleration with only minor drops in task success rate. Furthermore, we demonstrate its real-world applicability by deploying it on Kinova Jaco2 robot arm, achieving practical speedup under real-time control scenarios.
(0)). VLA-Cache
2
Related Work
Vision- Aaabon-Lannuge-Acttion Models. Large-scale vision-language models (VLMs) have significantly advanced multimodal learning by integrating image understanding and language reasoning [5] 21 Extending these capabilities, VLA models 8 22 incorporate an action modality, enabling end-to-end visuomotor control. These models typically adopt large VLM backbones [[5] and fine-tune them on
robot data (6), with approaches varying from discretizing actions as language-like tokens [1] 23 to incorporating specialized diffusion policy heads (24). Despite their effectiveness in tasks like object
retrieval and assembly (25] 26), VIA models demand substantial computation, making real-time
deployment challenging, particularly in resource-constrainee environments.

---

Acceleration for Vision-Language Models. Inference acceleration has been extensively explored in vision-language models (VLMs) through quantization 227] pruning (28], and token-level techniques
such as FastV [29]. VL. [0), ToMe [1. PuMer 32 and MADTP K3 These intra-frame
strategies reduce redundancy within single image but disregard the temporal and spatial structure essential for robotic tasks under closed-loop control. In the VLA domain, efficiency has been addressed through architectural modifications (e.g., RoboMamba [3],, Tiny VLA (12)). quantization- aware training (QAIL (13), and dynamic depth control (DecR-VLA [4]. While effective, these methods require re-training and lack generalizability. Recent high-frequency frameworks such as wo- FAST [351, HiRT [36], and Open [20] achieve higher control frequency via action chunking or asynchronous decoding. However, they continue to suffer from the language model decoding bottleneck, which dominates inference time. VLA-Cache addresses this gap by introducing cross- frame token reuse strategy that accelerates inference without modifying the model or requiring additional training. Furthermore, it complements existing high-frequency VLA architectures by directly accelerating the language decoder bottleneck, offering a lightweight, plug-and-play solution for real-time robotic inference.
Methodology
In robotic action prediction, most visual tokens remain static across frames except for key regions like the manipulator or target object. While this temporal redundancy enables token reuse, reusing all static tokens can harm accuracy when task-relevant regions subtly change. To address this, we propose method that identifies visually static tokens and filters out semantically important ones based on attention scores from the VL.A decoder. By avoiding redundant computation of unchanged static tokens between adjacent frames, our approach directly alleviates the computation bottleneck of language decoder in VLA models while preserving the accuracy of action prediction.
3.1 KV Cache for VLA Token Reusing
Key-Value (KV) caching is widely adopted technique in large-scale autoregressive models to reduce both computation and memory footprint during decoding. Initially proposed in the Transformer architecture (37], KV caching enables the model reuse previously computed key (K) and value (V) vectors for each token, thereby avoiding redundant computation across decoding steps. Concretely, given a sequence of input tokens X, the self-attention mechanism computes:
Q XWQ.
K K=WWK
V= =XWV,
(1)
QK Vd
Attn( Q, K, V) Softmax
V.
(2)
During decoding, each new token's 's knew and Vnew are appended to the i-th cache:
K, CCoooat knew),
V C.CCoonnt Vi-1, Vnew).
(3)
While KV caching is effective for language decoding within single query in vision-language models, this technique does not address redundancy in the visual stream, especially in Vision-Language-Acuio (VLA) models. In robotic manipulation, consecutive visual inputs often share large overlapping content, yet VLA models typically discard visual encodings after each step and recompute them from scratch. This is both wasteful and suboptimal for real-time control.
This inefficiency motivates a key question: can we selectively reuse static visual tokens across time with temporal KV Caching in VLA models? This idea forms the basis of our proposed VLA-Cache. In the following sections, we introduce its core mechanisms: static token selection, task-relevance filtering, and layer-adaptive reuse accelerate VLA inference while preserving action accuracy.
3.2 Temporal Redundancy in Robotic Perception
In closed-loop robotic manipulation, consecutive visual frames often share large portions of static content. As illustrated in Figure 2 background regions and stationary objects typically exhibit negligible changes between adjacent frames. However, most existing Vision-Language-Actinn (VLA)
3

---

Poich Similarit
Timestop
Timestep
black
Next
up
m
Selection
Task-Reeevant Tokens
%*%
VLA Layer?
VLA Layer?
VLA Doodder
Vroure
Static Pool
Updatee
Attention
4*%
Manris
Ala-aant
Past
Dynamic Pool
Select
Updar
Tisk-relevant Scare
(a) Dynumic Token Selection
(b) Adaptive Token Cuching
Figure 2: VLA-Cache accelerates the VLA's language decoding process across timesteps via the following two steps: (a) Dynamic Token Selection reuses static tokens across frames while preserving
task-relevant ones; (b) Adaptive Token Caching dynamically adjusts reuse ratios per decoder layer based on attention patterns.
models discard visual representations after each timestep and recompute all visual tokens from scratch, resulting in substantial redundancy and increased inference latency.
To address this inefficiency, propose selectively reusing visual tokens that remain static across timesteps. Specifically, we identify and cache the representations of image regions with minimal visual change, allowing their Key-Value (KV) representations be reused in the next frame. This strategy significantly reduces redundant computation in the VL.A visual stream while preserving model performance.
Static Token Selection. Given an image / E #x x3, we divide it into N x non-overlapping patches size x p. yielding a set raw pixel patches P. = {P."). For each patch P in the current frame and its corresponding patch P in the previous frame, we compute cosine similarity:
P.
P
Sim (P (PP))
|P
PP2
221
patch is considered visually static if its similarity exceeds threshold т. We further apply a Top-k filter to retain the most stable tokens:
P Pstatic Top-k (P (Pi P 12)22)
This simple yet effective approach accurately selects truly static tokens across consecutive frames, significantly reducing redundant computations and accelerating inference without compromising overall performance.
3.3 Retaining Task-Relevant Information
Table Comparison of VLA-Cache's core token selection strategies on Open using the LIBERO Spatial benchmark.
While visual similarity offers a practical signal for reusing static regions, not all visually static tokens are safe to reuse. In robotic control tasks, certain regions, such the gripper target object, though visually unchanged, are semantically dynamic and critical for precise action generation. Directly reusing all visu- ally static tokens, without considering their semantic role, can lead to serious performance degradation. As shown in Table naive static token reuse lowers the success rate from the VLA baseline of 84.4% just 74.2%.
Method
SR (%) Latency (ms) |
OpenVLA
84.4
51.56
Static Token
74.2
31.03
Evict Tesk-Relevant
82,6
31.03
Layer Adaptive
83.8
32.22
This degradation occurs because task-relevant tokens, though minimally changed at the pixel level, exhibit greater feature sensitivity subtle environmental changes. Unlike vision- languae models

---

Algorithm Dynamic Token Selection
Algorithm 2 Adaptive Token Caching
1: Input: Frames
{1) thresholds T,
1: Input: Token indices Phnal. previous KV
Tuskk hyperparameter
cache (KŞ-1, Vt-1). representations H;
2: Output: Reusable token indices Pfiall
2: Output: Updated KV cache {K) V:
3:
b Static Token Selection
3: Compute entropy R reuse ratio a sub-
4: Patchify both frames 1 and compute
set Preuse C Pinall
Sim(P, Pt-1) among related patches
4: for each layer / and token do
5: Select Pataii where similarity 2
5: if E Preuse then
6: Apply top-k filtering to refine static token selection
6:
Reuse cached values:
Ki(i) = (i), V. = (1-1()
7:
> Evict Mesk-Relevant Tokens
7:
else
8: Compute text-to-vision attention scores
8:
Recompute:
releraaae
(i W W
H. (1)
9: Select Pusk-relevant where attention 2 Tusk
Vi(ii ) W H
10: Compute reusable tokens: Pinal = PPstatic
9: end if
P relevnte
10: end for
11: return Prinal
11: return (K). V
(VLMs), VLA models must track object states and interactions over time, making them more dependent on accurate visual encoding. Therefore, to ensure alignment with the latest environment state, rask-relevant regions must be recomputed each step.
To avoid reusing semantically critical but visually static tokens, we propose lightweight filtering mechanism using cross-attention scores from the language decoder. For each decoder layer I, we extract the text-to-vision attention matrix A Vi-text from the full attention tensor A E IR Nucus x Natess Nuken
Evicting Task-Relevant Tokens.
as:
(6) where Ustart, Uend and Estarts fand are the indices of the vision and text tokens, respectively. To aggregate the attention scores across multiple heads, we compute the mean attention for each vision token A Mcanheads (ix))))) For task relevance across multiple layers L, the final task relevance scores are obtained by averaging the scores across the selected layers as Stusk-relevance Mcan ). Using these scores, rank the vision tokens based their task relevance and apply a threshold Tissk to select the most task-relevant tokens:
vis-test A' Il. Ustart Uend: 1start lend],
Pusk-relevaml (P S relevvaee [ 2 Tusk
Finally, we combine the set of static tokens Petatic selected in the first step with the relevatlevant tokens. Tokens that are both static and highly task-relevar are removed from the reusable token set to ensure they are recomputed in the current step:
Preuse
Patatic
Prssk-rolevant
(8)
By filtering out semantically significant tokens from the static reuse set, our method restores the degraded success rate from 74.2% 82.6%. while maintaining the computational gains in FLOPs and latency. This balance between task fidelity and efficiency illustrates the value of cross-modal attention as lightweight signal for safe token reuse in VLA models.
3.4 Layer Adaptive Token Reusing
While static token selection and task-relevance filtering climinate a large portion of redundant computation, we observe that attention distributions within the VLA decoder vary significantly across different layers. This finding is consistent with observations reported by prior work FastV [29], indicating that both VLA and VLM decoders exhibit similar patterns of attention flow: early layers display dispersed attention, followed by fluctuations in intermediate layers, and eventually a partial rebound near the final layers.
To account for these differences, we propose a layer-adaptive strategy that adjusts the fraction of reused tokens based on each layer's attention concentration. Specifically, we quantify the attention
5

---

distribution at layer I via an entropy measure, following the same mean- meea-attention computation described in Eq. Let El denote the resulting entropy. We then define an entropy ratio R (E--1 --'-))(76 / which captures how much more concentrated the attention is in layer compared to layer 1
A positive Ht' indicates that the attention distribution at layer / is more focused than that of layer - 1. We accumulate these ratios across layers to obtain cumulative score, which in turn determines the proportion a' of static tokens (from Pfinal) that are reused at layer I. Formally,
a'
min Σ ne rr',1) 1). j=1
where k is hyperparameter that governs the impact of attention concentration. Layers with larger cumulative entropy reduction are allowed to reuse higher fraction of tokens, reflecting the insight that as attention becomes more focused, fewer tokens are likely to require recomputation.
In practice, this layer-adaptive mechanism dynamically adjusts token reuse based on the evolving attention patterns in the VLA decoder, effectively balancing computational efficiency with task accuracy. By selectively retaining only the most relevant tokens at each layer, our method significantly reduces redundant computations while maintaining reliable action prediction.
4 Implementations
4.1 Cross-Frame Visual Token Caching
During inference, VLA-Cache accelerates robotic action prediction by reusing previously computed key-value (KV) representations of visual tokens across time. Instead of recomputing all visual tokens in each time step, the model identifies subset of static tokens, those that exhibit minimal change across frames, and reuses their cached representations from the previous time step. In contrast, dynamic tokens, which undergo sigmificant visual change or are task task-relevant, are freshly computed to maintain accurate action generation.
At each timestep given the visual token sequence H,, the model identifies subset Premse of tokens that remain unchanged from the previous frame and reuses their cached representations:
K,-101 (t), E Preuse (t),
[V- (1), I Preuse WW H.)). otherwise
(i)
Vi(i)
(10)
otherwise"
This design avoids redundant computation for static tokens while ensuring dynamic or task-relevant inputs are freshly computed. Most existing approaches reduce computation by pruning or merging tokens within a single frame 33 In contrast, VLA-Cache exploits temporal redundancy by caching and reusing visual tokens across frames, making it better aligned with the closed-loop nature of robotic control. Notably, it is compatible with high-frequency architectures and directly alleviates the decoding bottleneck. Since it requires no model modification or retraining, VLA-Cache serves as a plug-and annd-lay optimization for efficient robotic inference. An overview of the inference procedure is shown in Algorithm [| and Algorithm 2 detailing token selection and adaptive caching. Additional implementation details are provided in Appendix D
4.2 Theoretical Analysis of Computational Complexity
Overhead of Token Selection. The cost of static token identification is approximately ((H2) due patch similarity checks, while task-relevance filtering introduces a cross-modal attention aggregation cost of OL,,,, D). The entropy-based layer-adaptive strategy incurs an additional OL)'D) complexity, which remains significantly lower than the baseline per-layer cost.
Computational Cost Reduction. In standard VLA inference, each Transformer layer processes tokens, with total FLOP cost per layer:
FLOPs 4LD² + 21-
(11)
VL-A-Cach reduces effective token count per layer to I., = a x Panal, leading to theoretical savings:
AFLOPs 4L, + 2L + DMM
(12)

---

LIBERO Benchmark
RealWorld
Spatial
Object
Goal
Long
PickPot
SIMPLER Environment
PutSausage
WipeTable
PickCan
MoveNear
Drawer
DrawerApple
Figure Tasks on LIBERO Benchmark, the SIMPLER Environment and Real World.
Total Complexity Reduction. Bringing all components together, the theoretical overall FLOP reduction per layer is:
AFLOPS (AL +1L,D +2L, - (H² -()))-(22---0 L
(13)
Please refer Appendix for detailed derivations, including static token selection costs, attention filtering complexity, and layer-adaptive entropy calculations.
5
Experiment
To validate the effectiveness of VLA-Cache, we evaluate our method in both simulation and real- world settings. In simulation, evaluate VLA-Cache three open-source VLA models: Ope [.], Open OLenVLA-OFT (0 and CogAct [19), using the LIBERO benchmark [17] and SIMPLER environ- ment 18 respectively. All experiments are conducted NVIDIA RTX 4090 GPU.
5.1 Experiment Setup
We leverage the architectural similarity between VLA and VLM models, which allows direct application of existing VLM acceleration methods VLA inference. Specifically, we adopt two state-of-the-art token-level acceleration techniques SLarseVLM (30] and Fast 29 on OpenVLA as compared methods in the LIBERO benchmark.
Compared Methods.
Evaluation Metrics. We evaluate VLA-Cache using four metrics: success rate, control frequency, FLOPs, and CUDA latency. Success rate and control frequency respectively assess task performance and the responsiveness of action prediction in closed-loop control. FLOOPs measure theoretical computation, while CUDA latency captures actual GPU runtime. These two efficiency metrics widely adopted in VLM/VLA acceleration methods.
5.2 Evaluation Benchmark
LIBERO. The LIBERO Benchmark 17 covers four task suites: Spatial, Object, Goal, and Long, each testing a different aspect of manipulation generalization. We follow the standard setup from VLA (IT) and OpenVLA-OFT 20). using official weights and machines for consistency. Each suite includes ten subtasks evaluated over multiple episodes.
SIMPLER. The SIMPLER simulator 18 offers two settings, Visual Matching and Variant Aggrega- tion, designed to bridge simulation -t-ationtt--rellty gaps. Following CogAct's setup [99, we evaluate both settings Google robot across four manipulation tasks. CogAct, which integrates Diffusion Policy for continuous control, serves as our baseline. These evaluations demonstrate the generality of VLA-Cache under different action heads and simulation variations.
Real Robot Evaluation. We deploy VI-A-Cache on Kinova Jaco2 manipulator equipped with front-facing camera. The robot is evaluated on four tasks: PickPot, PlaceCube, PutSausage, and

---

Table 2: Comparison of different VLA acceleration methods on the LIBERO benchmark.
Success Rate 1
FLOPs (T)
Latency (ms)
Control Freq.
Method
(Hz))
Spatial
Object
Goal
Long
Average
Ope
84.4%
86.6%
75.6%
53.2%
75.0%
1.864
51.91
4.23
+ VL.aseVLM
79.8%
67.0%
72.6%
39.4%
64.7%
1.407
83.39
3.72
FastV
83.4%
84.0%
74.2%
51.6%
73.3%
1.864
53.28
4.19
VLA-Cache
83.8%
85.8 %
76.4%
52.8%
74.7% %
1.355
31.83
4.59
OpenVLA-OFT
97.8%
6%
97.6% 98.3%
94.2%
96.8%
4.013 3.097
79.05
65,10
VVLA-Cache
98.3%
97.5%
95.4%
97.4%
62.59
78.98
Table 3: Comparison of VLA-Cache within the CogACT model in the SIMPLER environment.
Success Rate 1
FLOPss (T)
Latency
Control Freq. (H2)
SIMPLER
Method
PickCan
MoveNear
Drawer
DrawerApple
Average
(ms)
CogACT
91.3%
85.0%
71.8%
74.8%
12.42
Matching
VLA-Cache
92.0%
83.3%
70.5%
51.6%
74.4%
1.496
39.63
14,66
Aggregation
CogACT
89 6%
80.8%
28. 3%
46.6%
61.3%
1.807
53.54
12.36
VVLA-Cache
91.7%
79.3%
32.5%
45.8%
62.3%
1.493
39.11
14.48
WibeTable, with the last task including diverse distractor objects to test robustness. Demonstrations are collected via teleoperation 10 Hz using an Xbox controller, resulting 150-200 trajectories per task. We fine-tune Open VLA with LoRA [88] and evaluate on the same tasks. using the LIBERO tuning setup for consistency. More details about real-world experiments are available in the AppendixI.4
5.3 Results on Simulation Environment
Main Results on LIBERO. Table 2 summarizes results across the four LIBERO task suites. VLA- Cache reduces FLOPs by 27.31 % and improves latency by 1.63x over standard Open with only a 0.3% drop in success rate. It performs robustly across tasks and exceeds the baseline on goal-oriented manipulation. When applied to OpenVLA-OFF, a faster variant with action chunking, VLA-Cache further boosts control frequency by nearly 14 Hz, showing strong compatibility with high-frequency architectures and delivering additive gains even on optimized VLA models. In contrast, FastV and SparseVL.N fail improve inference speed and often degrade task performance. Their token pruning and merging strategies operate within a single frame and disrupt spatial fidelity, which is critical for precise manipulation. Moreover, these methods target long output sequences, whereas VLA models generate short action outputs (e.g., 7 tokens), rendering the speedups marginal.
As illustrated in Figure VLA-Cache effec- tively reduces visual computation redundancy dur- ing robotic manipulation by precisely identify- ing static tokens and filtering out task-relevant regions real time. Notably, OpenVLA-OFT takes both fixed third-person and dynamic wrist- camera views as inputs. Its strong performance demonstrates that VLA-Cache not only enhances control frequency but also maintains robustness under dynamic viewpoints and camera shifts.
Table 4: Ablation on token pruning/reuse in LIBERO-Spatin using VLe (256 vision tokens). Best values are in bold.
#Tokens
Methods
SK %
PLOPS |
Latency (mn))
Baseline
84.4
1,888
SparseVL.M
79.8
1,388
88.08
50
FustV
$1.6
L.888
53.10
1.611
Sparse VLM
74,6
1,97
61.01
100
Fast
83.4
45.72
Ours
83.8
1.295
31.29
blation on Token Reusing/Pruning Rate. Ta- ble 4 presents ablation study varying the num- ber of reused/pruned tokens. For all methods, ag- gressive token reduction harms success rate, underscoring the need to preserve informative content. VLA-Cache maintains stable performance at moderate reuse rates (i.e., 100 tokens), while FastV and SparseVLM suffer larger drops due to loss of critical visual details. By directly updating KV entries, VLA-Cache remains more efficient and robust under different token reuse configurations.
SparseVLM
44,4
0.735
$7.42
1.888
Ours
68.3
0.823
30.29
Token Selection Strategies. As shown in Table directly reusing all static tokens leads to notable drop success rate 74.2%, indicating that visual similarity alone is insufficient for reliable reuse in robotic control. By filtering out task-relevant tokens based on decoder attention, method recovers
8

---

LIBERO
Pick the black bowl between plate place an the plate.
OpenVLA
AGrip)
(4)
Real-world (Dynamic Scene)
up the orange pot.
OpenVLL
[áx, 48, &Grip)
(b)
Primary Camera
Pick up the black bowl between the plate and the ramakin and place the
OpenNLA-OFT
[Ax, AGrip)
Figure 4: Visualization of VLA-Cache token reuse across settings. (a) LIBERO simulation with VLen (b) Real-world task under dynamic background. (c) and (d) Main and wrist camera views from OpenVLA-OFT, Blue: static tokens, Yellow: task-relevant, Red: overlapping. VLA-Cache reduces redundant computation and preserves accuracy under varying conditions.
performance to 82.6%. Introducing a layer-adaptive strategy further improves accuracy to 83.8%, with minimal increase in CUDA latency.
Main Results on SIMPLER Table indicates that VLA-Cache exhibits success rates comparable to the CogACT baseline in the SIMPLER environment while substantially reducing computational overhead.
The efficiency gains are evident in the FLOPs and inference time measurements. VLA-Cache achieves roughly 20% fewer FLOPs than the baseline, coupled with 1.37x reduction in inference latency. Notably, these results highlight the portability of VLA-Cache across different action heads, establishing as general acceleration strategy for VLA.
Table Comparison of success rate on real robot tasks.
Success Rate
FLOPs (T)
Latency (ms)
Control Freq. (lzz)
Method
PickPot
PlaceCube
PutSausage
WipeTable
Average
OpenVLA
95.0%
83.3% 90.0%
80.0% 85.0%
70.0% 73.3%
82.1% 84.6%
1.814 1,303
64.16
4.02
+ VLA-Cache
90.0%
51.85
4.21
5.4
Results on Real Robot
Table illustraaes the performance of VLA "LLA-aache in real-world robotic tasks. Among the four tasks, PickPot shows slightly lower success rate than the baseline, whereas VLA-Cache exceeds baseline on other three tasks. The method also achieves considerable reductions FLOPs and inference time. Overall, VI.A-Cach improves the average success rate by 2.4%, likely due to reduced interference from redundant visual tokens and enhanced decision robustness. With improved robustness foundation, VLA-Cache ability to prune reuse redundant tokens may further enhance the model's 's resilience, thus yielding higher success rates.
Performance under Dynamic Background. To assess robustness, we introduced background motion (e.g., human hands and moving objects) in the PickPor task. As shown in Table success rate of baseline dropped from 95% to 80% under noise. With VLA-Cache, the same success rate was maintained while reducing FLOPs by 42% and latency by 35%. These results highlight VLA-Cache's ability to filter out transient or irrelevant tokens, preserving both efficiency and stability in dynamic real-world settings. Figure visualizes this effect, showing robust token selection despite background disturbances.

---

Conclusion
In this paper, we introduce VLA-Cache, a training-free method for VLA that selectively reuses static tokens while filtering out task-relevant ones, reducing redundant computation without sacrificing accuracy. Additionally, our layer-adaptive token reuse strategy improves model success rates by adjusting token reuse based on attention concentration. Extensive experiments on three VLA mod- els, OpenVLA, CogAct and OpenVLA-OFT, across two simulation environments, LIBERO and SIMPLER, demonstrate that VLA-Cacha achieves a 1.7x speedup while maintaining performance. Furthermore, we demonstrate real-world applicability by deploying on a Kinova Jaco2 robot arm, and VIAA-Cahhe achieves practical speedup under real-time control scenarios.
Acknowledgments
This work was supported in part by the Australian Research Council under Projects DP240101 848 and 00549, We would also like to thank the anonymous reviewers and area chair for their constructive feedback, which helped improve the clarity and quality of this paper.
References
[1] Kuno Kim, Yihong Gu, Jiaming Song, Shengjia Zhao, and Stefano Ermon. Domain adaptive imitation learning. In International Conference on Machine Learning, pages 5286-5295. PMLR, 2020.
[2] Sungho Choi, Seungyul Han, Woojun Kim, Jongseong Chae, Whiyoung Jung, and Youngehul Sung. Domain adaptive imitation learning with visual observation. Advances in Neural Information Processing Systems, 36, 2024.
[3] Ioana Bica, Daniel Jarrett, and Mihaela van der Schaar. Invariant causal imitation learning for generalizable policies. Advances in Neural Information Processing Systems, 34:3952-3964, 2021.
[4] Anas Awadalla, Irena Gao, Josh Gardner, Jack Hessel, Yusuf Hanafy, Wanrong Zhu, Kalyani Marathe, Yonatan Bitton, Samir Gadre, Shiori Sagawa, Jenia Jitsev, Simon Kornblith, Pang Wei Koh, Gabriel Ilharco, Mitchell Wortsman, and Ludwig Schmidt. Openflamingo: An open- source framework for training large autoregressive vision-language models. arXiv preprint arXiv:2308.01 2023.
[5] Haotian Liu, Chunyuan Li, Qingyang Wu, and Yong Jae Lee. Visual instruction tuning. Advances in neural information processing systems, 36, 2024.
[6] Abby O'Neill, Abdul Rehman, Abhiram Maddukuri, Abhishek Gupta, Abhishek Padalkar, Abraham Lee, Acorn Pooley, Agrim Gupta, Ajay Mandlekar, Ajinkya Jain, al. Open embodiment: Robotic learning datasets and rt-x models: Open x-embodiment collaboration 0. In 2024 IEEE International Conference on Robotics and Automation (ICRA), pages 1892-6903. IEEE, 2024.
[7] Hao-Shu Fang, Hongjie Fang, Zhenyu Tang. Jirong Liu, Chenxi Wang, Junbo Wang, Haoyi Zhu, and Cewu Lu. Rh20t: A comprehensive robotic dataset for learning diverse skills in one-shot. In 2024 IEEE International Conference on Robotics and Automation (ICRA), pages 653-660. IEEE, 2024.
[8] Brianna Zitkovich, Tianhe Yu, Sichun Xu, Peng Xu, Ted Xiao, Fei Xia, Jialin Wu, Paul Wohlhart, Stefan Welker, Ayzaan Wahid, et al. Rt-2: Vision-language-ee models transfer web knowledge to robotic control. In Conference on Robot Learning, pages 2165-2183 PMIR, 2023.
[9] Octo Model Team, Dibya Ghosh, Homer Walke, Karl Pertsch, Kevin Black, Oier Mees. Sudeep Dasari, Joey Hejna, Charles Xu, Jianlan Luo, Tobias Kreiman, You Liang Tan, Lawrence Yun- liang Chen, Pannag Sanketi, Quan Vuong, Ted Xiao, Dorsa Sadigh, Chelsea Finn, and Sergey Levine. Octo: An open-source generalist robot policy. In Proceedings of Robotics: Science and Systems, Delft, Netherlands, 2024.
10

---

[10] Dantong Niu, Yuvan Sharma, Giscard Biamby, Jerome Quenum, Yutong Bai, Baifeng Shi, Trevor Darrell, and Roei Herzig. Llarva: Vision-action instruction tuning enhances robot learning. arXiv preprint arXiv:2406.1 1815, 2024.
[11] Moo Jin Kim, Karl Pertsch, Siddharth Karamcheti, Ted Xiao, Ashwin Balakrishna, Suraj Nair, Rafael Rafailov, Ethan Foster. Grace Lam, Pannag Sanketi, Quan Vuong, Thomas Kollar, Benjamin Burchfiel, Russ Tedrake, Dorsa Sadigh, Sergey Levine, Percy Liang, and Chelsea Finn. Openvla: An open-source vision-language-action model. arXiv preprint arXiv:2406.0922 2024.
[12] Junjie Wen, Yichen Zhu, Jinming Li, Minjie Zhu, Kun Wu, Zhiyuan Xu, Ning Liu, Ran Cheng, Chaomin Shen, Yaxin Peng, et al. Tinyvla: Towards fast, data- suta-efficient vision- caaion-lnguage-cttin models for robotic manipulation. arXiv preprint arXiv:2409. 24, 2024.
[13] Seongmin Park, Hyungmin Kim, Wonseok Jeon, Juyoung Yang, Byeongwook Jeon, Yoonseon Oh, and Jungwook Choi Quantization-awee imitation-learming for resource-efffcient robotic control. arXiv preprint arXiv:2412.01034, 2024.
[14] Yang Yue, Yulin Wang, Bingyi Kang, Yizeng Han, Shenzhi Wang, Shiji Song, Jiashi Feng, and Gao Huang. Deer-vla: Dynamic inference of multimodal large language models for efficient robot execution. In The Thirty-eightt Annual Conference on Neural Information Processing Systems, 2024.
[15] Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint S.XV::2307.09288, 2023.
[16] Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhupatiraju, Léonard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ramé, et al. Gemma 2: Improving open language models at a practical size. arXiv preprint arXiv:2408.000 18,18, 2024.
[17] Bo Liu, Yifeng Zhu, Chongkai Gao, Yihao Feng, Qiang Liu, Yuke Zhu, and Peter Stone, Libero: Benchmarking knowledge transfer for lifelong robot learning. Advances in Neural Information Processing Systems, 36, 2024.
[18] Xuanlin Li, Kyle Hsu, Jiayuan Gu, Karl Pertsch, Oier Mees, Homer Rich Walke, Chuyuan Fu, Ishikaa Lunawat, Isabel Sieh, Sean Kirmani, al. Evaluating real-world robot manipulation policies in simulation. arXiv preprint UrXiv:2405.05944 2024.
[19] Qixiu Li, Yaobo Liang, Zeyu Wang, Lin Luo, Xi Chen, Mozheng Liao, Fangyun Wei, Yu Deng, Sicheng Xu, Yizhong Zhang, et al. Cogact: A foundational vision-language- language--acttionn model for synergizing cognition and action in robotic manipulation. arXiv preprint arXiv:2411. 1.1224111116600 2024.
[20] Moo Jin Kim, Chelsea Finn, and Percy Liang. Fine-tuning vision- caaiion-anguage-actii models: Optimizing speed and success. arXiv preprint arXiv:2502.1964: 2025.
[21] Jinze Bai, Shuai Bai. Shusheng Yang, Shijic Wang, Sinan Tan, Peng Wang. Junyang Lin, Chang Zhou, and Jingren Zhou Qwen-vl: A frontier large vision-language model with versatile abilities. arXiv preprint arXiv:2308. /2966, 2023.
[22] Xinghang Li, Minghuan Liu, Hanbo Zhang, Cunjun Yu, Jie Xu, Hongtao Wu, Chilam Cheang, Ya Jing, Weinan Zhang, Huaping Liu, et al. languae foundation models as effective robot imitators. arXiv preprint 2.100723,,.01378, 2023.
[23] Cheng Chi, Zhenjia Xu, Siyuan Feng, Eric Cousineau, Yilun Du, Benjamin Burchfiel, Russ Tedrake, and Shuran Song. Diffusion policy: Visuomotor policy learning via action diffusion. The International Journal of Robotics Research, page 02783649241273666 2023.
[24] Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, et no: A lasion-language-action flow model for general robot control. arXiv preprint arXiv:2410.2411 2024.
11

---

[25] Wenlong Huang, Chen Wang, Yunzhu Li, Ruohan Zhang, and Li Fei-Fei. Rekep: Spatio- temporal reasoning of relational keypoint constraints for robotic manipulation. arXiv preprint arXiv:2409.01652 2024.
[26] Tony Z Zhao, Vikash Kumar, Sergey Levine, and Chelsea Finn. Learning fine-grained bimanual manipulation with low-cost hardware. arXiv preprint arXiv:2304. 13705, 2023.
[27] JingJing Xie, Yuxin Zhang, Mingbao Lin, Liujuan Cao, and Rongrong Ji. Advancing multi- modal large language models with quantization-awar scale learning for efficient adaptation. In Proceedings of the 32nd ACM International Conference on Multimedia, MM '24, page 10582-10591, New York, NY, USA, 2024. Association for Computing Machinery.
[28] Haokun Lin, Haoli Bai, Zhili Liu, Lu Hou, Muyi Sun, Linqi Song, Ying Wei, and Zhenan Sun. Mope-clip: Structured pruning for efficient vasion-language models with module-wis wise pruning error metric. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 27370-21 27380, 2024.
[29] Liang Chen, Haozhe Zhao, Tianyu Liu, Shuai Bai, Junyang Lin, Chang Zhou, and Baobao Chang. An image is worth 1/2 tokens after layer 2: Plug-and-play inference acceleration for large vasion-language models. In European Conference Computer Vision, pages 19-35. Springer, 2025.
[30] Yuan Zhang, Chun-Kai Fan, Junpeng Ma, Wenzhao Zheng, Tao Huang, Kuan Cheng, Denis Gudovskiy, Tomoyuki Okuno, Yohei Nakata, Kurt Keutzer, al. Sparsevim: Visual token sparsification for efficient vision-language model inference. arXiv preprint arXiv:2410.04417, 2024.
[31] Daniel Bolya, Cheng-Yang Fu, Xiaoliang Dai, Peizhao Zhang, Christoph Feichtenhofer, and Judy Hoffman. Token merging: Your vit but faster. arXiv preprint arXiv:2210.094:0 2022.
[32] Qingqing Cao, Bhargavi Paranjape, and Hannaneh Hajishirzi. Pumer: Pruning and merging tokens for efficient vision language models. arXiv preprint arXiv:2305. 17530, 2023.
[33] Jianjian Cao, Peng Ye, Shengze Li, Chong Yu, Yansong Tang. Jiwen Lu, and Tao Chen. Madtp: Multimodal alignment-guidees dynamic token pruning for accelerating vision- -sioonlanguage transformer. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 15710- 2024.
[34] Jiaming Liu, Mengzhen Liu, Zhenyu Wang, Lily Lee, Kaichen Zhou, Pengju An, Senqiao Yang, Renrui Zhang, Yandong Guo, and Shanghang Zhang. Robomamba: Multimodal state space model for efficient robot reasoning and manipulation. arXiv preprint arXiv:2406. 04339, 2024.
[35] Karl Pertsch, Kyle Stachowicz, Brian Ichter, Danny Driess, Suraj Nair, Quan Vuong, Oier Mees, Chelsea Finn, and Sergey Levine. Fast: Efficient action tokenization for vision-language-action models. arXiv preprint arXiv:2501.097: 2025.
[36] Jianke Zhang, Yanjiang Guo, Xiaoyu Chen, Yen-Jen Wang, Yucheng Hu, Chengming Shi, and Jianyu Chen. Hirt: Enhaneing robotic control with hierarchical robot transformers. arXiv preprint arXiv:2410.05273, 2024.
[37] A Vaswani. Attention is all you need. Advances in Neural Information Processing Systems,
2017.
[38] Edward Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li. Shean Wang. Lu Wang, and Weizhu Chen. Lora: Low-rank adaptation of large language models. arXiv preprint 1xXiv22006009888 2021.
[39] Xiaoyu Xiang Lemeng Wu Chenchen Zhu Zechun Liu Saksham Suri Balakrishnan Varadara- jan Ramya Akula Forrest landola Raghuraman Krishnamoorthi Bilge Soran Vikas Chandra Yunyang Xiong, Chong Zhou. Efficient track anything. preprint 2111:22411.18933, 2024.
12

---

NeurIPS Paper Checklist
1. Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification:
The paper proposes VLA-Cache, a training-free, plug-and-play method for
accelerating inference in Vision- Aision-angguageAAee (VLA) models. The claims in the abstract and introduction are well-aligned with the paper's scope, demonstrating generalizability across state-of- the-art VLA systems, real-world applicability, and robustness to dynamic environments.
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings. It is fine to include aspirational goals as motivation long it is clear that these goals are not attained by the paper.
2. Limitations
Question: Does the paper discuss the limitations the work performed by the authors?
Answer: [Yes]
Justification:
We include the limitations our work in Appendix A
Guidelines:
The answer NA means that the paper has limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g.. independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested few datasets or with few runs. In general, empirical results often depend on implicit assumptions, which should articulated.
The authors should reflect on the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or speech-to-text system might not be used reliably provide closed captions for online lectures because it fails handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairesss.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, worse outcome might be that reviewers discover limitations that aren't acknowledged
the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play impor- tant role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and proofs
13

---

Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
Answer: [Yes]
Justification:
We provide theoretical analysis of computational complexity in Section 4.2
Guidelines:
The answer NA means that the paper does not include theoretical results. All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated referenced in the statement of any theorems.
The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide short proof sketch provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix supplemental material.
Theorems and Lemmas that the proof relies upon should be properly referenced.
4. Experimental result reproducibility
Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided not)?
Question:
Answer: [Yes]
Justification: All details provided in See 5 and Appendix.
Guidelines:
The answer NA means that the paper does not include experiments.
If the paper includes experiments, No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution a specific model and empirical evaluation, may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g.. in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
While NeurlPS does not require releasing code, the conference does require all submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.
(b) If the contribution is primarily new model architecture, the paper should describe the architecture clearly and fully.
(c) If the contribution is a new model (e.g., a large language model), then there should either be way access this model for reproducing the results or way to reproduce the model (e.g., with an open- open-source dataset or instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, in which authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers have some path reproducing or verifying the results.
14

---

reproducible, they 5. Open access to data and code
Question: Does the paper provide open access to the data and code, with sufficient instruc- tions faithfully reproduce the main experimental results, described in supplemental material?
Answer: [Yes]
Justification:
Github link offered.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurlPS code and data submission guidelines (https://nips.. cc/
public/guides/
for more details.
While encourage the release of code and data, we understand that this might not be possible, so "No" an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines (https
7/nips cc/ wtc/publicc/ /usee/uudddee/eeeubbiiiii
Codeeubmiiiie iastuubbiisssiii ssisssiicccyyyii for more details.
The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only subset of experiments should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
Providing as much information as possible in supplemental material (appended the paper) is recommended, but including URLs to data and code is permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification:
We provided detals in Sec. 5 and Appendix
D
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented in the core of the paper level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, as supplemental material.
7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Answer: [No]
Justification: Performing multiple repetitive experiments in order to compute error bars Glabor-intensive and has significant overhead for the large VLA models.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by error bars, confi- dence intervals, or statistical significance tests, least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall with given experimental conditions).
15

---

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g.. Normally distributed errors).
should be clear whether the error bar is the standard deviation or the standard error of the mean.
It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables figures symmetric error bars that would yield results that are out of range (c.g. negative emror rates).
If error bars reported in tables plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed reproduce the experiments?
Question:
Answer: [Yes]
Justification:
We provided in Appendix D
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, cloud provider, including relevant memory and storage.
The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't 't make it into the paper).
9. Code ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics
Answer: [Yes]
Justification: Our research follows the NeurlPS Code of Ethics.
Guidelines:
The answer NA means that the authors have reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special cireumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (e.g., if there is special consid- eration due to laws or regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification:
We fully discuss the potential social impacts Appendix B
Guidelines:
The answer NA means that there is no societal impact of the work performed.
If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
16

---

The conference expects that many papers will be foundational research and not tied particular applications, let alone deployments. However, if there is direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition attacks, mechanisms for monitoring misuse, mechanisms to monitor how system learns from feedback over time, improving the efficiency and accessibility ML).
11. Safeguards
Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, scraped datasets)?
Question:
Answer: [NA]
Justification: This paper poses no such risks.
Guidelines:
The answer NA means that the paper poses no such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make best faith effort.
12. Licenses for existing assets
Question: Are the creators or original owners of assets (e.g.. code, data, models), used in the paper. properly credited and are the license and terms of use explicitly mentioned and properly respected?
Answer: [Yes]
Justification: All datasets used are from publicly available sources. They are released under open-access research licenses, which respected and cited in paper.
Guidelines:
The answer NA means that the paper does not use existing assets.
The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset is used and, if possible, include URL.
The name of the license (c.g., CC-BY 4.0) should be included for each asset.
For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.
If assets are released, the license, copyright information, and terms of use in the Datasets.papersstt
package should be provided. For popular datasets, paperswi thcode. cow/ datasets has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.
17

---

If this information is not available online, the authors are encouraged to reach out to the asset's 's creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [Yes]
Justification:
We provide the relevant documentation in the Appendix.
Guidelines:
The answer NA means that the paper does release new assets.
Researchers should communicate the details of the dataset/codeemmodll as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent was obtained from people whose asset used.
At submission time, remember anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well details about compensation (if any)?
Answer: [NA]
Justification: This paper does not involve any crowdsourcing or research with human subjects.
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Including this information the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then as much detail as possible should be included the main paper.
According to the NeurIPS Code Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals or equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Answer: [NA]
Justification: This paper does not involve any crowdsourcing or research with human subjects.
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurlPS Code of Ethics and the guidelines for their institution.
For initial submissions, not include any information that would break anonymity (if applicable), such the institution conducting the review.
18

---

16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology. scientific rigorousness, originality of the research, declaration is not required.
Answer: [NA]
Justification: LLM is used only for writing language embellishment and grammar checking.
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, non-standard components.
Please refer to L.LM policy (https: for what should or should not be described.
19

---

A Limitations
In this section, we discuss the potential limitations the proposed VLA-Cache: (i) In dynamic environments with substantial background object motion, the number of non-reusable tokens increases, reducing acceleration gains. As visualized in Figure dynamic regions (highlighted in yellow) require full recomputation. (ii) Our experiments focus on three state-of-the-art open-source VLA architectures (OpenVIL VLA M. Cot [19], PLAOVL (20)) based on LLaMA2 [T5] decoders. The applicability of VLA-Cache to emerging VLA systems with different backbones (e.g.. Gemma2 [6] in To (24)
or more complex VLA systems remains an open direction for future work.
B Impact Statement
While VLA-Cache demonstrates robust performance even under dynamic conditions, we emphasize the importance of careful deployment and continuous monitoring to ensure safe, interpretable, and reliable behavior in real-world robotic systems.
C Complexity Analysis Details
Static Token Selection. We compute patch-wise similarity for visual tokens:
PaaPSsttii-ssim .22 patch
D patch H
(14)
Since patch H/p, this cost remains small relative to Transformer computations.
Task-Relevance Filtering. The attention-base filtering step computes cross-modal importance scores:
FLOPSust-ilter R L.
(15)
sorting operation of OLL log L) follows for threshold selection. Layer-Adaptive Entropy Computation. The entropy-based reuse strategy involves:
FLOPs Scutrop s D.
(16)
The per-layer reuse ratio is then computed
a'
min k Σ R2 R2,
(17)
1=1
These overheads remain modest compared to the full forward pass cost, enabling efficient token
reuse. Final FLOP Reduction. The total FLOP savings across all layers follow:
AFLOPS Stotal
Σ
AFLOPS Slayer-
(18)
1=1
This confirms that dynamic token reuse significantly reduces computation without sacrificing model performance.
D Inference Detail of VLA-Cache
Inference Procedure. VLA-Cache accelerates robotic action prediction by reusing static visual tokens across frames during inference. At each timestep t, current visual tokens H, are compared with those from the previous frame to identify unchanged regions. Tokens that are both visually static and task-irreeevant are reused via cached key-value (KV) entries, while task-relevant or dynamic tokens are recomputed. This selective reuse substantially reduces visual processing cost without altering model architecture training.
20

---

Token Reuse Mechanism. Our implementation modifies the VLA decoder's forward pass as follows:
Position and Attention Masking. We maintain a cache_ baahee_ositioo array to mark tokens requiring recomputation. Static tokens retain their previous position encodings, allowing attention masks to be pruned to match the reduced token set.
Rotary Embedding. For recomputed tokens, rotary embeddings applied to introduce positional information. Tokens that are skipped retain their previous encoded states.
Dynamic Cache Updates. Newly computed tokens update their respective (K} V!} entries, while reused tokens inherit values from the previous frame's cache {KL_1; V V Due the permutation invariance of Transformers, this partial update yields valid attention results.
This strategy is fully compatible with standard KV caching in autoregressive decoding. The largest computational gain occurs when generating the first action token each timestep; subsequent tokens are decoded autoregressively without additional cost.
Experimental Settings. All experiments are conducted using OpenVLA with 256 visual tokens. Unless specified otherwise, we use a static token similarity threshold T = 0.996, top-k 100 for retained static tokens, and a task-relevance threshold Tisk 0.5. These parameters are applied consistently across all simulated and real-world Jaco2 experiments, we slightly reduce the similarity threshold r 0.85 to accommodate environmental noise. Training on the real robot used LoRA-based fine-tuning for 50,000 steps, and all evaluations were performed on an NVIDIA RTX 4090 GPU.
settings, including SIMPLER with CogAct. For
E
More Experiment Results
E.1 Simulation Experiment
LIBERO Task Definitions. Similarly, we also utilize all task suites provided in LIBERO for our evaluations. The Robosuite-based robot setup includes the following tasks: 1) "place bowl on plate with spatial variation" (c.g., drawer positions), 2) "pick object" (c.g., ketchup, bowl, apple), 3) "(open / close) target drawer; action object" (e.g.. "open top drawer; place apple into drawer"), and 4) "achieve goal using shared objects" (c.g., rearranging spatial relationships or altering object states).
SIMPLER Task Detinitions. We utilize all task variants provided in SIMPLER for our evaluations,
which include the Google robot setup with the following tasks: 1) "pick Coke can". ; 2) "move objl near obj2". 3) "(open / close) (top / middle/ / bottom) drawer", and 4) "open top drawer; place apple into top drawer". Evaluations for the Google robot setup are provided for both Visual Matching (VM) and Variant Aggregations (VA).
Implementation Details. Simulated evaluations for CogACT and SIMPLER are conducted on single NVIDIA RTX 4090 GPU in BF16 precision. During inference, with 10 steps and a classifier-free guidance (CFG) coefficient of 1.5. Similarly, for Open VLA and LIBERO. inference performed on single NVIDIA RTX 4090 GPU in BF16 precision.
DDIM sampling
E.2
Additional Simulation Results
Result of Subtask on LIBERO Spatial Task Suit. Table|6 detailed results on each subtask the LIBERO-Spatia suite. We observe that VLA-Cache, along with methods like Sparse and V,stV, occasionally surpasses the baseline's 's success rate on individual subtasks. This suggests that certain redundant tokens may distract the baseline model, and pruning or reusing tokens can fact enhance its robustness.
Visualization Results. Figure 5 present evaluation examples of each tasks executed by OLe with VLA-Cache in LIBERO. More visualized results are available in the supplementary materials.
21

---

Table 6: Comparison of success rates across different tasks in the SAREERO-Spatial benchmark.
Success Rate %
Method
FLOPs
CUDA Time (ms)
2
6
9
10
Avg
Baseline VLA)
90
90
84
96
70
90
96
76
82
70
84.4
1.888
52.37
SLM
88
60
90
90
60
82
90
92
72
74
79.8
1.367
88.08
FastV
92
90
90
58
92
90
80
78
70
83.4
1.888
54.00
VLA-Cache
84
76
72
1.382
32.22
Table 7: Real-world PickPot task under dynamic background (human/object motion).
Method
Success (%) t FLOPPs
Latency (ms) +
Baseline (OpenVLA)
95
1.800
68.03
+ Noise
80
1.807
68.22
+ Noise, VLA-Cache
80
1.275
50.59
Pick up the black bowl between the plate and the ramekin and place it on the plate
Pick up the alphabet soup and place it in the basket
Open the middle drawer of the cabinet
Put both the alphabet soup and the tomato sauce in the basket
Figure 5: VLA-Cache test results and attention heat map in simulated environment
E.3
Additional Ablations and Comparisons
Attention vs. object-mask proxies for task relevance. To validate whether attention score is reliable proxy for task relevance, compared our default attention-based filtering with object-
22

---

mask alternative using Efficient Track Anything 33]
On LIBERO LIBERO-Spatin Spatial with iitention-based proxy yields both higher success rate and lower latency than the mask variant:
Method
SR (%)
FLOPs(T) 1
Latency (ms) 4
Freq. (Hz)
OPENVLA-OFT
97.8
3.99
78.35
65.44
+ VLA-Cache (Attention)
98.3
3,04
61.12
81.67
+ VLA-Cache (Object Mask)
87.4
3.15
87.49
64.78
Table 8: Attention vs. object-mask proxies for task relevance on L.BEERO-SPATIAL.
While object masks provide spatial localization, they miss fineggriined contextual signals essential for manipulation, especially with background clutter or small, relevant parts. In contrast, attention scores dynamically produced and tightly coupled with the model's internal reasoning. providing lightweight, task-adaptive proxy for relevance.
Sensitivity to static-token budget & and relevance threshold т. We further analyze the trade-off between accuracy and efficiency by varying the number of static tokens k (with ==0.5 fixed) and the lask-relevance threshold 7 (with 1-100 fixed) on LIBERO-Spatial using Open VLA-OF.. Results indicate robustness across wide range; our default (k=100, ==0.5) offers strong balance.
Method
SR (%)
FLOPs (T) L
Lateney (ms)
Freq. (Hz)
OLENVLA-OFT
97.8
3.995
78.35
65.44
+ VLA-Cache (0=
97.6
3.332
66.82
77.23
VLA-Cache (k=80)
97.8
3,226
66.55
78.66
VLA-Cache (1=100))
98.2
3.156
64.88
79.88
VLA-Cache (2=120)
98.0
3.109
62.99
80.56
VLA-Cache (k-150)
97.4
3.043
61.12
81.67
VLA-Cache (k=
96.6
2.936
60.46
82.51
Table 9: Varying the static-token budget k (with T=0.)).
Method
SR (%) 1
FLOPs (T) +
Latency (ms) |
Freq. (Hz) f
OPENVLA- OFT
97.8
3,995
78.35
65.44
+ VLA-Cache (r=0.2)
95.6
3.384
66.93
76.74
+ VL.A-ache (r=0.3)
96.2
3.283
67.03
79.31
+ VLA-Cache (r=0.4)
98.0
3.204
66.38
79.79
+ VLA-Cache (7=0.5)
98.2
3.156
64.88
79.88
+ VLA-Cache (T=0.6)
98.6
3.131
64.27
81.98
+ VLA-Cache (7=0.7)
98.4
3.068
63.12
82.96
Table Varying the relevance threshold 7 (with k==00)..
Overall, efficiency (FLOPs and latency) improves monotonically with larger & and r, while success rate remains consistently high, corroborating the stability of VLA-Cacht across sensitivity settings. Our default (k=100, 0-0.5) is used for all main results unless stated otherwise.
Applicability to diffusion- based and alternative VLA architectures. VLA-Cace is designed to accelerate the language-decoder stage of VLAS and therefore not directly applicable models without a vision- -aiguage backbone, such as standalone diffusion policies. However, for hybrid architectures that combine VLM with diffusion-baar based policy head (e.g.. CogACT (19), our method remains fully compatible and has shown consistent efficiency gains and stable task performance in the SIMPLER environment, as shown Table Since VLA-Cache operates by reusing temporally static visual tokens before action generation, it can be integrated with diffusion-based or transformer-style models (e.g., RDT, DiT) that exhibit inter-frame redundancy, offering promising direction for future generalization.
23

---

E.4 Real Robot Experiment
Robot Setup. The setup of the Franka Robot is shown in Figure 6 In this example, a Kinova Jaco robot arm with 6 degrees of freedom is rigidly fixed to the frame. We use Sony AX53 camera, which is placed opposite the robot arm. The camera is facing the operating table and transmits the video in real time.
Kinova Jaco
Sony
Figure 6: Kinova Jaco Robot Setup
Data Collection. Our data collection work is based on the CLVR_Jace Jayo__Play dataset. We employed PyBullet as an inverse kinematics (IK) controller. The system receives incremental Cartesian displacement inputs (Az, Ay, A=) from an Xbox controller, which are processed to generate joint velocity commands. These commands are transmitted to the robotic arm's velocity controller at 10Hz control frequency for real-time exccution. We record four types of observations: Third- person camera observations (front cam nam_ob). End-effector Cartesian pose (ee cartesian pos pbs_ob), End-effector Cartesian velocity (ee vve_crtesian vel ob), Jaco arm joint positions (joint pos__opp ob).
Data Preprocessing. The preprocessing procedure was conducted as follows. Initially, the recorded frames underwent center cropping, reducing the resolution from 1280 720 to 912 720, followed by resizing to 224x224 Subsequently, episodes were manually selected based on a visual inspection of the video sequences generated from the recorded frames. To minimize potential biases associated with excessively long episodes, those exceeding 250 steps were excluded from the dataset. Furthermore, steps in which all recorded action values integrity.
removed ensure data relevance and
Task Definitions and Success Criteria. We design four inglleinsttruction tasks for the real- world robot setting to evaluate manipulation performance across diverse object types and interaction modes. The task definitions are follows:
1. Pick Up Orange Pot (PickPot): The robot's goal is to grasp the orange pot and lift it completely off the table. trial successful if the pot is grasped and raised with visible clearance from the surface. We collected 218 valid demonstrations for the training dataset, with slight random adjustments to the initial positions of the pot and the robotic arm each episode. During evaluation, each trial is recorded success (1) or failure (0); there is no partial credit.
2. Place Blue Cube in Box (PlaceCube): The robot's goal is to place the held blue cube into the target container. A trial is successful if the cube is fully inside the container at the terminal step without contact-induced ejection. We collected 212 valid demonstrations for the training dataset, with randomized container positions and robotic arm initial configurations in each episode. During evaluation, each trial is recorded as a success (1) or failure (0); there is no partial credit.
3. Put Sausage in Blue Pan (PutSausage): The robot's goal is to stably place the held sausage into the blue pan. Success requires the sausage to rest inside the pan boundary the terminal step. We collected 219 valid demonstrations for the training dataset, with randomized pan
24

---

coordinates and robotic amm joint angles across trials. During evaluation, each trial is recorded success (1) or failure (0); there is no partial credit.
4. Wipe Table (WipeTable): The robotic arm's goal is sweep scattered items into fixed- position dustpan using a broom. Success requires all designated items to be inside the dustpan at termination. For the training dataset, collected 187 valid demonstrations featuring randomized placements of simulated items (c.g.. fries/cheese) on the table and varied initial joint configurations of the robotic arm, while the dustpan location remained fixed. This task explicitly incorporates dynamic environmental variations to rigorously test generalization capabilities. During evaluation, each trial is recorded as success (1) or failure (0); there is partial credit.
Trial Protocol and Randomization. We run 20 trials for PickPot and PutSausage, and 30 trials for PlaceC Cube and WipeTable. for total of 100 trials per method. For each trial we randomize the initial robot configuration and the object placement within bounded region the workspace. Trials are single-attempt with fixed horizon; there is no human intervention or reset within a trial. Outcomes are recorded binary success failure per the criteria above.
OPENVLA
OPENVLA VLA-CACHE
Task
Success
Failure
SR (%)
Success
Failure
SR (%)
PickPot (20)
19
95.0
18
90.0
PlaceCube (30)
25
83.3
27
90.0
PutSausage (20)
16
4
80.0
17
85.0
WapeTable (30)
21
70.0
22
73.3
Total (100)
81
19
82.1
84
16
84.6
Table 11: Real-world results with trial counts and success rates.
reports per-task successes and failures, along with the corresponding success rate. Average success is computed across all 100 trials.
Results with Counts and Rates. Table 11
Visualization Results. Figure present evaluation examples of each tasks executed by Open VLA with VLA-Cache on the Kinova Jaco Robot Arm. More visualized results are available in the supplementary materials.
present
25

---

Baseline
Our
Pick up the orange pot
Baseline
Our
Pick up the blue cube and place it on the plate
Baseline
Our
Put the sausage blue pan
Baseline
Our
Wipe the table
Figure Comparison between baseline (OpenVLA) and VLA-Cache in real environment.
26


Reviews:
[{"review_id": "KSQ9FlU2zJ", "reviewer": "Reviewer_4fFX", "summary": "This paper considers a lazy strategy for computing K-V values in transformers, specifically for the usage of robotic VLA. The proposed algorithm finds the static tokens and filters those task-relevant. Experimental results show that the VLA-Cache technique accelerate existing VLA algorithms. Overall, I think the motivation of the paper is good.", "questions": "Please see my comments above.", "limitations": "yes", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 3, "originality": 3, "strengths_and_weaknesses": "1. I didn't find the opensourcing code of this paper. As is known to all, the code implementation matters a lot when computational efficiency is concerned. Will the authors opensource the code? \n\n2. The proposed algorithm may not work if the robot sensing data is not 2D images, nor if the sensor is mounted on the robot rather than a third-view perspective. If the sensing data is point cloud, then the proposed algorithm is also inapplicable, because the data is unordered. \n\n3. I think the proposed algorithm should also work on other kind of VLA modules, such as DP and RDT. Please consider add them.", "was_revised": false, "final_justification": "", "rebuttal": "We sincerely thank you for your effort in reviewing our paper. Your insightful and helpful comments helped us for refining our paper better. Below, we address your comments and questions in detail.\n\n---\n\n**Q1. Code release**\n\n**R1:** Thank you for raising this important point. To this end, we have included the full implementation of VLA-Cache in the **supplementary material** for verification.\n\nWe are fully committed to open-sourcing the complete codebase upon paper acceptance, including scripts for reproducing all benchmarks and real robot deployment. We hope this will support further research and practical deployment.\n\n---\n\n**Q2.1. Applicability to Point Cloud or Non-2D Inputs**\n\n**R2.1:** \nThanks for this insightful question. Our current work focuses on vision-language-action (VLA) models that process 2D image inputs, which remain the dominant form across recent models (e.g., OpenVLA, OpenVLA-OFT, $\\pi_0$) and large-scale datasets like Open X-Embodiment.\n\nWe acknowledge that the proposed VLA-Cache is designed and evaluated in this 2D visual context. However, the core idea of **selective token reuse based on temporal visual redundancy is not inherently tied to 2D images**. For multi-modal VLA models (e.g., PointVLA [1]) that integrate point cloud data, VLA-Cache can still operate on the image branch. Moreover, similar principles such as identifying static or low-saliency subsets of unordered point cloud tokens, can also be extended to non-2D domains with appropriate adaptation. While evaluating this on point cloud inputs is beyond the current scope, we believe our method offers general insights into computation-efficient inference and is compatible with broader extensions in future work.\n\n**Reference:**\n\n[1] Li, C., et al. (2025). Pointvla: Injecting the 3d world into vision-language-action models. arXiv preprint arXiv:2503.07511.\n\n---\n**Q2.2. Applicability to Robot-Mounted Cameras (e.g., Wrist Cameras)**\n\n**R2.2:** We validated VLA-Cache on OpenVLA-OFT, which includes inputs from both third-person and wrist-mounted (egocentric) cameras. As shown in Figure 4c/d and Table 2, the method maintains robustness under dynamic viewpoints and is able to reuse a significant portion of tokens even with egocentric inputs.\n\n---\n**Q3. Applicability to Other VLA Architectures (e.g., DP or RDT)**\n\n**R3:** \nThank you for this valuable suggestion. VLA-Cache is designed to accelerate the language decoder stage, and is therefore not directly applicable to VLA models without a VLM backbone, such as standalone DP-based architectures.\nHowever, for **hybrid architectures**, where a VLM encoder/decoder is combined with a diffusion policy head (e.g., CogACT [2]), VLA-Cache remains fully applicable. In fact, we have already validated our method on CogACT, achieving both efficiency and performance gains (please see Table 3).\n\nBeyond this, transformer-based models such as RDT or DiT also exhibit inter-frame redundancy, and our token-reuse strategy can be adapted to these settings as well. We consider this an exciting direction for future generalization.\n\n**Reference:**\n\n[2] Li, Q., et al. (2024). *Cogact: A foundational vision-language-action model for synergizing cognition and action in robotic manipulation*. arXiv:2411.19650\n\n---\n\n**We sincerely appreciate your valuable suggestions and hope our rebuttal can address your concerns. We are happy to answer any remaining questions during the discussion phase.**"}, {"review_id": "1anRTWydbQ", "reviewer": "Reviewer_bXk4", "summary": "This paper proposes VLA-Cache, an inference-time acceleration method designed to improve the efficiency of Vision-Language-Action (VLA) models. The core idea leverages the spatial redundancy of static regions across visual frames, reusing representations of static tokens via a key-value (KV) caching mechanism to reduce redundant computation. The authors also introduce an attention-based filtering strategy and a layer-adaptive reuse policy to maintain semantic accuracy of key tokens.", "questions": "Add at least one real-world robotic experiment, even on a low-cost platform, to demonstrate practical applicability and robustness.\n\nExtend validation to a wider range of VLA backbones, such as Gemma, Qwen-VL, or CogAct, to assess generality and compatibility.\n\nAnalyze the limitations of using attention scores as a proxy for semantic relevance. Consider introducing alternative signals such as object masks or affordance maps.\n\nExplore combinations with other token optimization strategies, such as token merging or patch dropout, to enhance performance further.", "limitations": "yes", "rating": 4, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "# Strengths\nClear innovation: Proposes a plug-and-play token reuse strategy that requires no retraining, making it lightweight and practical.\nWell-designed method: Clever integration of visual staticness and semantic importance avoids performance degradation due to over-caching.\n\nComprehensive evaluation metrics: Includes analysis on FLOPs, CUDA latency, control frequency, and task success rate.\n\nStrong baselines and comparisons: Systematic comparison with multiple token-level acceleration baselines such as FastV and SparseVLM.\n# Major Weaknesses\n- No real-world robotic experiments: The method is only validated in simulation environments, with no deployment or testing on real robots, raising concerns about its real-world feasibility and robustness.\n- Limited validation scope: The method is only tested on a single visual backbone (e.g., LLaMA2), lacking generalization experiments on other architectures (e.g., Gemma, Qwen-VL, CogVideo).\n- Reliance on attention as a proxy for task relevance is heuristic in nature, and no alternatives or robustness analyses are provided.\n- Contribution is local rather than fundamental: While practical, the method is more of an engineering optimization and offers limited insight into the learning mechanisms of VLA models.", "was_revised": true, "final_justification": "Sorry for the late response to the final justification, as had a serious cold in recent days. As I claimed in the review and the rebuttal, I had raised my final rating to 4, as the author solved most of my concerns.", "rebuttal": "We sincerely appreciate your constructive and detailed feedback. Below, we address each concern point-by-point.\n\n---\n\n**Q1&W1. Lack of Real-World Robot Experiments**\n\n**R1:** \nThank you for the suggestion. We would like to clarify that **VLA-Cache has already been deployed and evaluated on a real robotic platform**, the **Kinova Jaco2** arm. The real-world results are thoroughly reported in Section 5.2, Section 5.4, and Appendix E.3, with quantitative performance summarized in Table 5, and qualitative outcomes illustrated in Figure 3 (right) and Figure 4b. Across four real-world manipulation tasks, VLA-Cache improved **success rate** by **2.4%**  on average, reduced **FLOPs** by **28.2%**, and lowered **latency** by **19.2%** compared to the OpenVLA baseline.\n\nIn addition, we conducted experiments under **dynamic real-world disturbances** such as human motion and background clutter to further assess robustness, as detailed in **Section 5.4** and **Table 7**. The method maintained a high success rate while significantly reducing FLOPs and latency.\n\nFurthermore, demonstration videos of the real-robot execution has been provided via **anonymous link in the abstract**, showcasing the method’s practical applicability in real-world settings.\n\n\n---\n\n**Q2&W2. Limited Backbone Generalization**\n\n**R2:** \nThanks for the nice question. We would like to clarify that besides OpenVLA, we have already evaluated VLA-Cache across more diverse and representative VLA architectures (i.e., **CogACT** and OpenVLA-OFT). Notably, CogACT is a diffusion-based VLA model, which differs structurally from standard autoregressive LLM decoders, and our results on it are reported in **Table 3**. On the Visual Aggregation task, VLA-Cache improved success rate by **+1.0%**, reduced FLOPs by **17.4%**, latency by **27.0%**, and increased control frequency by **+2.12 Hz**.\n\nMoreover, most recent state-of-the-art VLA systems (e.g., OpenVLA, CogACT, OpenVLA-OFT, UniVLA) are all built upon **LLaMA2** as the language decoder. Since our current evaluation already covers this dominant backbone family across multiple variants (autoregressive, diffusion-based, and OFT-based), we believe the generalization ability of VLA-Cache is well demonstrated.\n\n\n---\n\n**Q3&W3. Limitations of Using Attention scores as Task-Relevance Proxies**\n\n**R3:** \nThank you for the constructive suggestion. We acknowledge that attention scores may not perfectly align with human-understood semantics.\nTo assess the reliability of attention scores as a proxy for semantic relevance, we conducted a direct comparison between our **attention-based** token filtering and an **object-mask-based** approach using **Efficient Track Anything** [1,2] on the LIBERO Spatial benchmark. The results are shown in the following table.\n\n| Method                              | SR (%) | FLOPs ↓ | Latency (ms) ↓ | Freq. (Hz) ↑ |\n|-------------------------------------|--------|----------|----------------|---------------|\n| OpenVLA-OFT                         | 97.8   | 3.995    | 78.35          | 65.44         |\n| + VLA-Cache (attention score)       | **98.3**   | **3.043**    | **61.12**          | **81.67**         |\n| + VLA-Cache (object mask)     | 87.4   | 3.157    | 87.49          | 64.78         |\n\nWe observe that attention-based filtering not only improves accuracy (more than 10%) but also reduces latency and computational cost, compared to the object-mask variant. While object masks provide spatial localization, they often miss fine-grained or contextual signals essential for manipulation tasks, especially when background clutter or small, relevant parts might be involved. In contrast, attention scores are dynamically generated and tightly coupled with the model’s internal reasoning, providing a lightweight, task-adaptive proxy for relevance.\n\nDue to this year’s rebuttal policy, we cannot include visualizations, but we will incorporate illustrative examples in the final version to better explain this behavior.\n\n**Reference:**\n\n[1] Xiong, Y., et al. (2024). *Efficient Track Anything*. arXiv:2411.18933  \n[2] Xiong, Y., et al. (2024). *EfficientSAM: Leveraged Masked Image Pretraining for Efficient Segment Anything*. CVPR 2024\n\n---\n\n**Q4. Compatibility with Token Merging and Pruning Strategies**\n\n**R4:** \nThanks for the insightful comment. To validate this compatibility, we implemented and evaluated VLA-Cache in combination with token merging (SparseVLM [3]) and token pruning (FastV [4]) methods. The results are summarized below:\n\n| Method                              | SR (%) | FLOPs ↓ | Latency (ms) ↓ | Freq. (Hz) ↑ |\n|-------------------------------------|--------|----------|----------------|---------------|\n| OpenVLA-OFT                         | 97.8   | 3.995    | 78.35          | 65.44         |\n| + VLA-Cache                         | **98.3**   | **3.043**    | **61.12**          | **81.67**         |\n| + Token Merging                     | 83.6   | 3.187    | 89.51          | 63.53         |\n| + Token Pruning                     | 93.4   | 3.128    | 63.74          | 82.43         |\n\nAs VLA models are highly sensitive to subtle visual cues, both *token merging* and *pruning* tend to disrupt spatial consistency, an essential requirement for robotic manipulation. Our results in Table 4 of the main paper further confirm that applying these methods leads to a noticeable drop in success rate and inconsistent efficiency improvements.\n\nIn contrast, our **reuse-based caching strategy** is explicitly designed to preserve spatial integrity by avoiding token alteration and instead reusing computation only for static regions. While technically compatible, combining VLA-Cache with merging or pruning introduces instability and harms performance. Therefore, we recommend using our reuse strategy independently to maintain both accuracy and efficiency.\n\n**Reference:**\n\n[3] Zhang, Y., et al. (2024). Sparsevlm: Visual token sparsification for efficient vision-language model inference. ICML 2025  \n[4] Chen, L.,  et al. (2024). An image is worth 1/2 tokens after layer 2: Plug-and-play inference acceleration for large vision-language models. ECCV 2024\n\n**W4. Contribution is local rather than fundamental**\n\n**R5:** \nWe respectfully clarify that our contribution extends beyond engineering optimization. Our work addresses a critical and underexplored challenge in the field: the inference inefficiency of billion-scale VLA models in real-time robotics, which currently limits their practical deployment.\n\nRather than implementing a software-level tweak, VLA-Cache is a modular, architecture-agnostic algorithm carefully designed to exploit intrinsic structural properties of VLA models. It integrates three steps including static token detection, task-relevance filtering, and layer-adaptive reuse. Importantly, our method is plug-and-play: it requires no retraining or fine-tuning, and generalizes across diverse VLA architectures. \n\nBeyond practical acceleration, VLA-Cache also offers insight into the learning and information flow of VLA models. It reveals that token-level redundancy and temporal locality are prominent, exploitable features. Selective reuse of stable representations preserves performance while substantially reducing computational cost. These findings open new directions for building efficient and deployable VLA systems.\n\n---\n\n**We sincerely appreciate your valuable suggestions and hope our rebuttal can address your concerns. We are happy to answer any remaining questions during the discussion phase.**"}, {"review_id": "weRHFzoZO6", "reviewer": "Reviewer_B8wU", "summary": "This paper introduces VLA-Cache, a training-free inference acceleration method for Vision-Language-Action (VLA) models. \nThe key contributions are: 1) Static Token Selection. 2) Evicting Task-Relevant Tokens. 3) Layer Adaptive Token Reusing.\nThe method is evaluated on two simulation platforms (LIBERO and SIMPLER) and a real-world robotic setting. \nResults demonstrate that VLA-Cache achieves a speedup of up to 1.7× in CUDA latency and a 15% increase in control frequency, with negligible loss in task success rate. The paper also shows the real-world applicability of VLA-Cache by deploying it on a Kinova Jaco2 robot arm.", "questions": "See above.", "limitations": "YES", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 2, "significance": 2, "originality": 2, "strengths_and_weaknesses": "Strengths:\n\n1. The paper is well-organized and features a clear and comprehensible writing style. The author presents the motivation for the proposed method clearly and understandably. Subsequently, each component of the method, together with the experimental settings and results, is elaborated in detail.\n\n2. This paper introduces a novel training-free inference acceleration method, comprising three key components: Static Token Selection, Evicting Task-Relevant Tokens, and Layer-Adaptive Token Reusing.\n\n3. The paper establishes and conducts extensive experiments across three benchmarks: LIBERO, SIMPLER, and real-robot. These experiments serve to demonstrate the effectiveness of the proposed method.\n\n\nWeaknesses:\n\n1. The thresholds and k in Equations (5),(7),(9) need to be set carefully to better retain stable tokens. Otherwise, important visual areas may be misclassified as static regions, or static regions may be wrongly regarded as task-relevant ones for action prediction.\n\n2. Calculating the attention matrix for Evicting Task-Relevant Tokens involves computing K, Q, V. It is unclear whether KV-cache is used here. If it is used, this might lead to inaccuracies in calculating the attention matrix. If not, this would increase the computational load for KV.\n\n3. It is not clear whether this method is applicable to diffusion-based VLA models.\n\n4. While the method reduces FLOPs, Latency, and improves Control Frequency while maintaining task success rates across LIBERO, SIMPLER, and real-robot experiments, the overall performance improvement appears to be limited. For instance, in the real-robot experiment, the success rate for the PickPot task decreased from 95% to 90%, while the Control Frequency increased only slightly from 4.02 to 4.21.", "was_revised": true, "final_justification": "Thank you to the authors for their detailed rebuttal. Your responses have satisfactorily addressed most of my concerns, and as a result, I have raised my score to a 4.", "rebuttal": "The authors sincerely than you for your insightful comments and constructive feedback. Below, we address your comments and questions in detail.\n\n---\n\n**Q1. Sensitivity of Thresholds (k) and ($\\tau$)**\n\n**R1:** The parameters \\(k\\) (for static token selection) and \\($\\tau$\\) (for task relevance thresholding) can influence the trade-off between accuracy and efficiency. To further examine the sensitivity of these parameters, we conducted additional experiments on the LIBERO Spatial benchmark using the OpenVLA-OFT model. The results are summarized below.\n\n*Table 1. Varying \\(k\\) values (with $\\tau$ = 0.5):*\n\n| Method                     | SR (%) | FLOPs ↓ | Latency (ms) ↓ | Freq. (Hz) ↑ |\n|----------------------------|--------|----------|----------------|---------------|\n| OpenVLA-OFT                | 97.8   | 3.995    | 78.35          | 65.44         |\n| + VLA-Cache (k=50)         | 97.6   | 3.332    | 66.82          | 77.23         |\n| + VLA-Cache (k=80)         | 97.8   | 3.226    | 66.55          | 78.66         |\n| + VLA-Cache **(k=100)**        | 98.2   | 3.156    | 64.88          | 79.88         |\n| + VLA-Cache (k=120)        | 98.0   | 3.109    | 62.99          | 80.56         |\n| + VLA-Cache (k=150)        | 97.4   | 3.043    | 61.12          | 81.67         |\n| + VLA-Cache (k=180)        | 96.6   | 2.936    | 60.46          | 82.51         |\n\n\n*Table 2. Varying $\\tau$ values (with k = 100):*\n\n| Method                     | SR (%) | FLOPs ↓ | Latency (ms) ↓ | Freq. (Hz) ↑ |\n|----------------------------|--------|----------|----------------|---------------|\n| OpenVLA-OFT                | 97.8   | 3.995    | 78.35          | 65.44         |\n| + VLA-Cache (τ=0.2)        | 95.6   | 3.384    | 66.93          | 76.74         |\n| + VLA-Cache (τ=0.3)        | 96.2   | 3.283    | 67.03          | 79.31         |\n| + VLA-Cache (τ=0.4)        | 98.0   | 3.204    | 66.38          | 79.79         |\n| + VLA-Cache **(τ=0.5)**        | 98.2   | 3.156    | 64.88          | 79.88         |\n| + VLA-Cache (τ=0.6)        | 98.6   | 3.131    | 64.27          | 81.98         |\n| + VLA-Cache (τ=0.7)        | 98.4   | 3.068    | 63.12          | 82.96         |\n\nThese results show that VLA-Cache is generally robust to changes in \\(k\\) and \\($\\tau$\\). While efficiency (FLOPs and latency) improves with higher values, task success rate remains consistently high across settings. Our default configuration (k = 100, τ = 0.5) offers a strong trade-off between performance and efficiency.\n\n---\n\n**Q2. Whether Task Relevance Computation Uses KV-Cache**\n\n**R2:** \nThanks for the question. We do not recompute $Q$, $K$ and $V$ values during inference for task-relevant token selection. Instead, we reuse the attention scores from the decoder at the previous timestep (t−1). These attention scores were already computed for action prediction and reflect semantically meaningful task-driven importance. \n\nTo validate this choice, we conducted an ablation comparing: \n\n* _Current Implementation_: Using full decoder attention from the previous timestep $t−1$; \n\n* _A baseline variant_ that recomputes $Q$, $K$ and $V$ for the first two decoder layers at timestep $t$, and uses their attention scores.\n\n| Method  | SR (%) | FLOPs ↓ | Latency (ms) ↓ | Freq. (Hz) ↑ |\n|-----|------|----|------|----|\n| OpenVLA-OFT  | 97.8 | 3.995 | 78.35 | 65.44 |\n| + VLA-Cache (Current implementation)| **98.4** | **3.043** | **61.12** | **81.67** |\n| + VLA-Cache (Variant)  | 96.6 | 3.371 | 68.39 | 76.64 |\n\nThe results show that our method achieves both better efficiency and higher task success. Recomputing shallow attention at the current timestep leads to worse SR and latency, likely due to insufficient task-level semantics in early decoder layers. This supports our design choice of reusing full attention from the prior timestep.\n\n---\n\n**Q3. Applicability to Diffusion-Based VLA Models**\n\n**R3:** \nWe would like to clarify that **our paper already includes experiments on CogACT [1], a representative diffusion-based VLA model**. Specifically, Table 3 in our main paper reports the performance of VLA-Cache applied to CogACT in the SIMPLER environment. These results demonstrate that our method is compatible with diffusion-based VLA models and remains effective in this setting.\n\nVLA-Cache operates at the VLM decoder level by identifying and reusing static visual tokens across time. This design is agnostic to the decoder architecture and naturally integrates with diffusion-based policies like CogACT. Since token caching occurs before action generation, it does not interfere with the diffusion process.\n\nAs shown in our results, applying VLA-Cache to CogACT improves inference efficiency (e.g., lower FLOPs and latency) without compromising task success, confirming both compatibility and benefit.\n\n*Table3: Comparison of VLA-Cache with CogACT in SIMPLER Environment*\n\n| SIMPLER      | Method              | PickCan | MoveNear | Drawer | DrawerApple | Avg.  | FLOPs (T) ↓ | Latency (ms) ↓ | Freq. (Hz) ↑ |\n|--------------|---------------------|---------|----------|--------|--------------|-------|--------------|----------------|----------------|\n| Matching     | CogACT              | 91.3%   | **85.0%**| **71.8%** | 50.9%        | **74.8%** | 1.847        | 54.29          | 12.42          |\n|              | + **VLA-Cache**     | **92.0%** | 83.3%    | 70.5%  | **51.6%**     | 74.4%  | **1.496**    | **39.63**      | **14.66**      |\n| Aggregation  | CogACT              | 89.6%   | 80.8%    | 28.3%  | **46.6%**     | 61.3%  | 1.807        | 53.54          | 12.36          |\n|              | + **VLA-Cache**     | **91.7%** | **79.3%**| **32.5%** | 45.8%        | **62.3%** | **1.493**    | **39.11**      | **14.48**      |\n\n\n**Reference:**\n\n[1] Li, Q., et al. (2024). *Cogact: A foundational vision-language-action model for synergizing cognition and action in robotic manipulation*. arXiv:2411.19650\n\n---\n\n**Q4. Performance Drop in PickPot and Limited Control Frequency Improvement**\n\n**R4:** \nThanks for the nice concern. We acknowledge that the PickPot task shows a 5% drop in real-robot success rate. However, this change is within the expected statistical variance, given only 20 trials per task. Other real-world tasks such as PlaceCube show significant improvements (e.g., +7.3%), indicating no systematic degradation from applying VLA-Cache. Importantly, VLA-Cache is designed to improve computational efficiency while maintaining performance. Across all evaluated domains (LIBERO, SIMPLER, real-robot), task success rates remain stable or improve, confirming that caching does not harm control quality.\n\nRegarding the improvement in control frequency, we note that our method accelerates the language decoder, which accounts for most of the VLA model’s computation. The end-to-end gain scales with decoder usage: high-frequency models like OpenVLA-OFT see substantial improvements (+13.88 Hz), while low-frequency pipelines (e.g., OpenVLA real-robot) are also constrained by external system bottlenecks such as sensor and actuator delays. Thus, the modest frequency gain in PickPot reflects platform-level limits rather than algorithmic shortcomings.\n\n---\n\n**We sincerely appreciate your valuable suggestions and hope our rebuttal can address your concerns. We are happy to answer any remaining questions during the discussion phase.**"}, {"review_id": "587JTi966q", "reviewer": "Reviewer_zsdX", "summary": "The paper proposes VLA-Cache, which is a training-free inference acceleration method that can help speedup for robotic control. VLA-Cache selects visually static tokens and task-relevant tokens to construct reusable tokens, and reuse KV-cache for better computational efficiency.  Additional techniques like layer adaptive reusing is also added to improve the performance. The authors evaluate the method on several benchmarks to demonstrate the improvement on the inference speed.", "questions": "1.\tFor calculating the task-relevant tokens, what visual tokens are you used to calculate the attention matrix? It seems that we need visual tokens at different layers to do this, which is the target for reduction. Do you use the raw image tokens just like OpenVLA or do you use the attention score from the last step? \n\n2.\tI think the main idea is try to reuse the tokens that won’t cast too much influence on the final tokens. It would be interesting to see the performance of a variant which doesn’t calculate visually static and re-use all tokens that belong to Full set – task relevant tokens.\n\n3.\tFor wrist camera used in OpenVLA-OFT (L284), can you explain how to handle it? How many tokens can be reused? It seems like most tokens will not be visually static anymore.\n\n4.\tFor control frequency result in Table 2/3/5, most of the improvements seem to be not prominent (+0.36Hz / 0.2Hz for OpenVLA, +2.2Hz for CogACT). How many tokens are reused? Why is the case?", "limitations": "N/A", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 2, "significance": 2, "originality": 2, "strengths_and_weaknesses": "Strengths:\n\n-\tIn general, the paper is clear and easy to follow\n\n-\tThe idea of adaptively reusing the KV cache of certain regions is interesting and seems to be novel.\n\nWeaknesses:\n\n-\tAlthough the method can improve theoretical FLOPs and CUDA latency, the improvement on actual control frequency seems to be limited.\n\n-\tSee questions below.", "was_revised": true, "final_justification": "The method tries to accelerate the inference and the method seems to be novel. Though the performance gain seems limited to certain scenarios, I think the method itself seems to be novel.", "rebuttal": "We sincerely thank you for your insightful comments and constructive feedback. Below, we address your comments and questions in detail.\n\n---\n\n**Q1. Which visual tokens are used to compute attention?**\n\n**R1:** Thanks for the question. We compute task relevance scores using the decoder self-attention weights from the previous timestep (t−1). We do not access or recompute visual tokens from multiple encoder layers, nor do we require raw image tokens as in OpenVLA. Instead, we **reuse existing attention weights that were already computed during action prediction at the previous timestep**.\n\n---\n\n**Q2. Experiment: Reusing only task-relevant tokens (no static filtering)**\n\n**R2:** Our method is designed to reuse static tokens, those unlikely to influence final predictions, to reduce redundant computation without harming performance. Following your suggestion, we conducted an experiment on the LIBERO Spatial benchmark where only task-relevant tokens were reused, and all static tokens were recomputed. The results are shown below:\n\n| Method                     | SR (%) | FLOPs ↓ | Latency (ms) ↓ | Freq. (Hz) ↑ | Ratio (Primary) | Ratio (Wrist) |\n|-----|-------|--------|-------|-------|--------|---|\n| OpenVLA-OFT                | 97.8   | 3.995    | 78.35          | 65.44         | -                | -               |\n| + VLA-Cache                | 98.4   | 3.043    | 61.12          | 81.67         | 31.62            | 35.47           |\n| + VLA-Cache (task-only)    | 0.0    | 2.912    | 59.49          | 84.78         | 37.67            | 36.58           |\n\nAs expected, reusing all task-relevant tokens leads to complete performance failure (SR = 0%), confirming that these tokens are essential for accurate action prediction and should not be reused. In contrast, VLA-Cache reuses only static tokens and preserves task-relevant computations, thus maintaining high success rates while improving efficiency.\n\n---\n\n**Q3. Token reuse for wrist camera input**\n\n**R3:** \nThank you for the thoughtful question. The wrist camera input is processed identically to the third-person camera in our system. While it is true that wrist-view observations contain more motion (due to hand-object interaction and egocentric perspective shifts), not all tokens are equally dynamic. Our top-$k$ similarity-based selection captures local temporal consistency. For example, background areas, parts of the robot arm, or regions with limited motion—still exhibit high similarity across frames. These static regions enable effective token reuse.\n\nAs shown in Q2-R2, the token reuse ratios are surprisingly similar between third-person view (31.62%) and wrist view (35.47%). This indicates that, despite the higher motion, the wrist camera input still contains substantial redundancy that VLA-Cache can exploit for acceleration without hurting performance.\n\n---\n\n**Q4. Control Frequency Improvement**\n\n**R4:** \nThanks for the nice question. Across OpenVLA, OpenVLA-OFT, and CogACT, we apply the same configuration. Token reuse ratios are consistently around 35% as reported above (Q2-R2).\n\nVLA-Cache primarily accelerates the language decoder, which accounts for over 90% of total compute in VLA models (based on FLOPs profiling). As such, control frequency improvements scale with how often the decoder is called. In low-frequency models like OpenVLA (≈4Hz), which predict one action per timestep, the performance gain is naturally limited, even a large reduction in decoder latency translates to only ~0.2–0.4Hz gain, due to other system bottlenecks like policy update frequency or observation preprocessing. In contrast, high-frequency models like OpenVLA-OFT (≈65Hz), which use action chunking to predict multiple actions per step, benefit much more. For example, we observe a +13.88Hz gain in Table 2.\n\n---\n\n**We sincerely appreciate your valuable suggestions and hope our rebuttal can address your concerns. We are happy to answer any remaining questions during the discussion phase.**"}]

Author rebuttal:

Meta-review: This paper proposes VLA-Cache, a training-free inference acceleration method for Vision-Language-Action (VLA) models. It reduces redundant computation by reusing static visual tokens across frames, while selectively recomputing task-relevant tokens and applying layer-adaptive reuse. The paper is clearly written and well motivated. Experiments on LIBERO, SIMPLER, and a real robot report up to 1.7× CUDA speedup and 15% higher control frequency with minimal loss in success rate.

**Strengths**:
- Clear writing and strong motivation.
- Novel training-free acceleration method with three complementary components.
- Extensive experiments across simulation and real-world platforms.

**Weaknesses**:
- Real-world reporting needs clarification. The rebuttal states 20 trials for PickPot, but the PlaceCube success rate (e.g., 83.3%) implies a different number of trials。

**Rebuttal**:
The authors clarified applicability to wrist-camera settings (reuse ratio comparable to third-person), added ablations using attention scores as task-relevance proxies, and clarified comparisons with diffusion-based VLA methods. 

**Suggestions for Improvement**:
- Include additional ablations and comparisons (e.g., attention-based proxies, diffusion-based VLAs) in the final version or appendix.
- Clarify real-world experimental details (trial counts, protocols, and success criteria).
- Correct Figure 4’s top-left label (should be LIBERO, not SIMPLER).
Decision: Accept (poster)