- Rating
- 3(+1)
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper introduces MemCache, a learnable token-caching framework for efficient Vision-Language-Action inference. It combines query-based token selection with a recurrent visual memory that refines caching decisions using historical context. A memory-consistency objective and warm-up schedule support joint optimization. Experiments on LIBERO and SIMPLER evaluate the framework across OpenVLA, OpenVLA-OFT, and CogACT, reporting reduced inference latency while maintaining or improving task success rates.
Critical strengths
The paper addresses a practically relevant problem by exploiting temporal redundancy to reduce VLA inference costs. The framework learns caching decisions under the action objective, and its recurrent memory provides a plausible mechanism for incorporating historical context. Evaluation covers three VLA architectures and two simulation benchmarks. The single-GPU latency measurements provide useful evidence of practical acceleration.
Critical weaknesses
W1. Insufficient evidence for the central contribution of long-term memory. The ablation results do not convincingly establish the benefit of long-term temporal context. In Appendix Table 7, adding memory increases average success rates only from 76.3% to 76.5% for OpenVLA and from 97.3% to 97.6% for OpenVLA-OFT. On the OpenVLA Long suite, performance decreases from 56.8% to 56.2%. Although the full framework performs better after introducing the training strategy, these results do not isolate the contribution of long-term memory. Comparisons involving memory resets, different history lengths, and simpler temporal aggregation mechanisms are missing. W2. The efficiency comparison with token-pruning methods is incomplete. Table 2 compares pruning and caching ratios, but these quantities are not directly equivalent measures of computational savings. Caching retains the full KV context, whereas pruning shortens the token sequence. A higher caching ratio therefore does not necessarily imply lower FLOPs or latency than a lower pruning ratio. Without measured latency and FLOPs for these baselines, the table does not sufficiently substantiate the claimed superiority in the performance–efficiency trade-off. W3. Limited validation under real-world conditions and cache-failure scenarios. All experiments are conducted in simulation, including those on SIMPLER. The evaluation does not systematically examine viewpoint changes, occlusions, abrupt scene changes, or prolonged reuse of stale cached states. These conditions are particularly relevant to a method that relies on temporal redundancy and historical KV reuse. Consequently, the robustness of the caching mechanism under practical deployment conditions remains insufficiently established.
Questions for authors
Q1 Can you isolate the benefit of long-term memory by comparing the full method with periodic memory resets, different history lengths, and simple alternatives such as exponential moving averages or short-window feature aggregation? Does the recurrent memory provide consistent improvements when caching budgets and training schedules are matched? Q2 Can you report measured inference latency and FLOPs for the pruning baselines in Table 2 under the same hardware and timing protocol? Do the claimed advantages remain when methods are compared at matched latency or computational budgets rather than token ratios? Q3 How does MemCache behave under viewpoint changes, temporary occlusions, abrupt object displacement, and extended cache reuse? Is there a mechanism to detect or refresh stale cached states, and can its effectiveness be evaluated through controlled perturbation experiments or real-robot trials?
8 comments
W2&Q2: Efficiency comparison with token-pruning methods
We have added comparisons of FLOPs and latency speedup against token-pruning baselines. Since IAprune [5] is not open-sourced, we take its latency results directly from its paper. We measure latency for the remaining open-source baselines (VLA-ADP [6] and SpecPrune-VLA [7]) using their official repositories, and for our method, under the same evaluation protocol. All evaluations run on the same GPU type (NVIDIA A100) as IAprune, so that the results are directly comparable.
| Method | Spatial | Object | Goal | Long | Avg. | Ratio↑ | FLOPs (T)↓ | Latency (ms)↑ |
|---|---|---|---|---|---|---|---|---|
| OpenVLA-OFT | 97.8 | 97.6 | 97.6 | 94.2 | 96.8 | 0.0 | 4.013 | 112.35 |
| VLA-ADP | 99.4 | 98.0 | 96.4 | 91.2 | 96.3 | 0.50 | 3.215 | 96.03 |
| VLA-ADP | 97.6 | 98.4 | 97.4 | 84.2 | 94.4 | 0.70 | 2.925 | 92.14 |
| SpecPrune-VLA | 97.4 | 95.8 | 97.7 | 93.4 | 96.1 | – | 1.726 | 105.91 |
| EfficientVLA | 96.5 | 91.1 | 96.0 | 72.1 | 88.9 | 0.70 | – | – |
| IAprune | 97.3 | 99.1 | 98.2 | 95.2 | 97.5 | 0.50 | – | 89.93 (Paper) |
| IAprune | 96.6 | 98.8 | 98.0 | 94.8 | 97.1 | 0.70 | – | 80.00 (Paper) |
| Ours | 99.2 | 98.8 | 98.0 | 96.2 | 98.1 | 0.75 | 1.660 | 83.16 |
The new results show that our method still achieves a favorable performance–efficiency trade-off. Specifically, on LIBERO with OpenVLA-OFT, our method surpasses IAprune by an average of 0.6% in success rate at a 1.1× speedup, and by 1.0% in success rate at comparable latency (83.16 ms vs. 80.0 ms). We also achieve a 2.0% higher success rate with a 1.27× speedup over SpecPrune-VLA. This is because its dynamic operations, including multi-stage token selection and explicit attention-map computation, introduce additional computation, data movement, and synchronization overhead, which offset the latency savings from FLOPs reduction.
Moreover, to enable a more direct and controlled comparison between caching and pruning, we conduct an additional experiment in which we replace our caching operation with pruning at inference time while keeping all other components and settings unchanged. At the same computational ratio of 0.25, caching incurs only 3% higher latency and 1% more FLOPs than pruning.
We have incorporated the new results into the revised manuscript (Table 4 and Section 4.3).
W3&Q3: Limited validation under real-world conditions and cache-failure scenarios
Mechanism to detect or refresh stale cached states
We learn a memory update module that adopts a preserve gate to refresh stale memory states. Formally, the module reads the previous memory state together with the current observation and predicts a per-entry gate and a candidate update (Sec. 3.3.1 "Recurrent State Update", lines 238–247 of P5 in our manuscript):
Since and act element-wise, sets the retention strength of each memory entry independently: larger values preserve historical entries, smaller ones replace them with the candidate state derived from the current observation. Since the gate is conditioned jointly on and , the update is both content-dependent and per-entry. Staleness is thus handled implicitly by the learned gate rather than by a hand-designed detector: entries that the current observation no longer supports are overwritten, with no explicit staleness signal required.
Limited validation under real-world conditions
We extend our evaluation to a physical Realman manipulator across four manipulation tasks to assess performance under real-world conditions. We conduct experiments on PickCube, KnockBottle, PickBox, and PutCup, collecting 150–200 trajectories per task to fine-tune OpenVLA-OFT with LoRA and validating on 25 trials per task. As detailed in the table, our method outperforms the baseline in both task performance and inference efficiency, improving the average success rate by 2.0% over the base OpenVLA-OFT, while reducing FLOPs by 49.8% and attaining a 1.53× inference speedup on an NVIDIA RTX 4090, demonstrating our benefits in real-world deployment.
| Method | PickCube | KnockBottle | PickBox | PutCup | Average ↑ | FLOPs (T) ↓ | Latency (ms) ↓ |
|---|---|---|---|---|---|---|---|
| OpenVLA-OFT | 88% | 72% | 92% | 80% | 83% | 3.960 | 76.16 |
| Ours | 92% | 76% | 96% | 76% | 85% | 1.986 | 49.71 |
To further assess the robustness of our method, we test both the base OpenVLA-OFT model and our method on the LIBERO-Plus benchmark [8], which builds on LIBERO to evaluate VLA robustness under seven types of perturbations: camera viewpoints, robot initial states, language instructions, lighting, background textures, sensor noise, and object layouts. We evaluate on the Long suite, and the results are summarized in the table: our method achieves a 0.6% higher success rate with 55.7% fewer FLOPs, demonstrating robustness to these perturbations.
| Method | Camera | Robot | Language | Light | Background | Noise | Layout | Average ↑ | FLOPs (T) ↓ |
|---|---|---|---|---|---|---|---|---|---|
| OpenVLA-OFT | 92.8% | 30.3% | 85.8% | 94.9% | 93.9% | 89.3% | 77.6% | 79.5% | 4.194 |
| Ours | 93.3% | 30.5% | 86.3% | 95.3% | 94.2% | 88.9% | 77.9% | 80.1% | 1.857 |
Moreover, to evaluate performance under temporary occlusions, we test both the base OpenVLA-OFT model and our method on the LIBERO-Occ benchmark [9], a variant that injects occlusions into the Spatial, Object, Goal, and Long suites and measures how reliably policies complete tasks when visual information is partially obstructed. As shown in the table, our method achieves an average of a 0.5% higher success rate with 60.3% fewer FLOPs, demonstrating its robustness to occlusions.
| Method | Spatial | Object | Goal | Long | Average ↑ | FLOPs (T) ↓ |
|---|---|---|---|---|---|---|
| OpenVLA-OFT | 95.0% | 97.8% | 88.6% | 60.6% | 85.5% | 4.013 |
| Ours | 94.8% | 98.6% | 88.2% | 62.4% | 86.0% | 1.593 |
[1] Timothy P Lillicrap, et al. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
[2] Bo Liu, et al. LIBERO: Benchmarking knowledge transfer for lifelong robot learning. Advances in Neural Information Processing Systems, 36, 2024a.
[3] Moo Jin Kim, et al. OpenVLA: An open-source vision-language-action model. In Conference on Robot Learning, pp. 2679–2713, 2024.
[4] Moo Jin Kim, Chelsea Finn, and Percy Liang. Fine-tuning vision-language-action models: Optimizing speed and success. arXiv preprint arXiv:2502.19645, 2025.
[6] Xiaohuan Pei, et al. Action-aware dynamic pruning for efficient vision-language-action manipulation. arXiv preprint arXiv:2509.22093, 2025.
[8] Hanzhen Wang, et al. Specprune-vla: Accelerating vision-language-action models via action-aware self-speculative pruning. arXiv preprint arXiv:2509.05614, 2025a.
[9] Taishan Li, et al. LIBERO-Occ: Evaluating and Improving Vision-Language-Action Models under Scene-Induced Occlusion via Viewpoint Imagination. arXiv preprint arXiv:2606.10862. 2026.
[10] Senyu Fei, et al. Libero-plus: In-depth robustness analysis of vision-language-action models. arXiv preprint arXiv:2510.13626, 2025.
[5] Jintao Cheng, et al. Training-free interaction-aligned visual token pruning for efficient embodied manipulation. arXiv preprint arXiv:2603.22991, 2026.
We thank the reviewer for the insightful and constructive comments. As suggested, we have: (1) Compared our method against memory-reset variants over a range of history lengths and against a simpler temporal aggregation mechanism (EMA), demonstrating the importance of long-term memory for caching decisions and our method's ability to retain it (Contribution of long-term memory, W1&Q1);
(2) Added comparisons of FLOPs and latency speedup against token-pruning baselines to validate our superior performance–efficiency trade-offs (Efficiency comparison with token-pruning methods, W2&Q2);
(3) Conducted real-robot experiments to demonstrate the effectiveness of our method in real-world applications, and conducted experiments on the extended LIBERO benchmarks, including LIBERO-Occ and LIBERO-Plus, to validate our effectiveness in robustness under temporary occlusions and different types of perturbations (Real-robot & Robustness experiments, W3&Q3).
W1&Q1: Insufficient evidence for the central contribution of long-term memory
To validate the long-term contribution of our memory mechanism, we compare our method with memory-reset variants across different history lengths. To further verify the effectiveness of our memory update mechanism, we compare it with a simpler temporal aggregation mechanism, the exponential moving average (EMA) [1].
We evaluate on two LIBERO benchmark suites [2], Spatial and Long: the former includes an average of 104 steps per episode, whereas the latter has averaging 280 steps per episode, enabling us to assess performance under both short- and long-horizon regimes.
We evaluate both OpenVLA [3], in which each frame prefill yields a single action step, and OpenVLA-OFT [4], which uses action chunking to produce eight steps per frame prefill. All comparisons are conducted with identical training schedules and caching budgets, except for the base models, which are not cached.
*For OpenVLA-OFT (action chunk size 8), 32 frames yield 256 steps, exceeding the horizon of LIBERO-Spatial.
As shown in the table, resetting every two frames restricts our memory state to only adjacent frames. Consequently, its success rate is comparable (0.2%–0.4% higher) to that of query-based methods (no memory). Resetting every 8 frames improves the success rate by 0.4%–0.8%, while resetting every 32 frames endows our caching decisions with longer-term memory, further improving the success rate by 0.9%–1.4% over the query-based variant. Our method without reset achieves the best success rate (0.6%–2.2% over the query-based variant), demonstrating both the importance of long-term memory for caching decisions and our method's ability to retain it effectively.
Furthermore, compared with EMA, which mixes historical memory and the current observation in a proportional manner (new memory = α × history + (1 − α) × current) and therefore depends on the choice of α, our method consistently achieves higher success rates under the same caching ratio. This verifies the effectiveness of our memory updating mechanism, which learns end-to-end to refresh the memory state, aiming to accumulate useful historical context and enable better caching decisions.