acceptodds
Withdrawn from ICLR 2027

DriveVLA-Cache: Training-Free Acceleration of Vision-Language-Action Models for Autonomous Driving

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Reasoning vision-language-action (VLA) models show strong performance in autonomous driving, but inference latency makes real-time deployment challenging. The cost spans four stages: visual encoding repeatedly processes overlapping camera frames; multimodal prefill recomputes shared context; autoregressive decoding often regenerates identical reasoning text; and trajectory generation repeatedly evaluates the action network over successive integration steps. Reasoning decoding contributes the largest share in our profiling, but accelerating it alone leaves substantial computation in the remaining stages. We propose DRIVEVLA-CACHE, a training-free framework that integrates Reasoning Recontextualization with visual feature, prompt K/V, and velocity-field caching to accelerate the full VLA inference pipeline. Visual feature caching avoids re-encoding overlapping frames, while selective prompt key-value (K/V) reuse reduces repeated context computation. For reasoning, the central challenge is that reusable text has cached K/V states tied to earlier observations. Our Reasoning Recontextualization periodically re-encodes retained reasoning text under the current observations in one forward pass, updating the states used for action generation without repeating autoregressive decoding. Finally, velocity-field caching reuses or extrapolates recent fields between selected action-network evaluations, reducing computation while preserving all integration updates. Together, these mechanisms accelerate the pipeline while producing a new trajectory every planning cycle. On Alpamayo 1.5-10B across 913 closed-loop ALPASIM scenes, DRIVEVLA-CACHE achieves the highest mean driving score and lowest latency among evaluated methods. It delivers 3.5× driver-inference and 2.4× end-to-end speedups over the full-computation baseline, while increasing mean AlpaSim Score from 70.8 to 73.4.

Primary area:
applications to robotics, autonomy, planning
Keywords:
autonomous driving, vision-language-action models

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_grW2OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents DRIVEVLA‑CACHE, a training‑free full‑pipeline inference acceleration framework for reasoning‑based autonomous‑driving VLA models. The core insight is the Reasoning Content‑State Distinction: reasoning tokens (Chain‑of‑Causation, CoC) can be reused across planning cycles, but their cached K/V contextual states become stale under new observations. To address this, the authors propose Reasoning Recontextualization, which refreshes K/V states by re‑encoding retained CoC tokens in a single forward pass without expensive autoregressive redecoding. Combined with visual‑feature caching and sparse velocity‑field caching inside flow‑matching action generation, the system produces a fresh trajectory in every planning cycle. Closed‑loop evaluations show 3.5× driver‑inference speedup and 2.4× end‑to‑end speedup.

Critical strengths
  1. The proposed Reasoning Recontextualization offers a practical workaround without retraining or fine‑tuning the original VLA weights.

  2. Most prior caching works only optimize one module (vision prefill or diffusion‑style action generation). This paper covers visual encoding, multimodal prefill, autoregressive reasoning decoding, and flow‑matching trajectory generation together, which matches the real latency bottleneck of full‑stack driving VLA deployment.

  3. This work conducts large‑scale closed‑loop simulation evaluation on 913 diverse scenes. Counter‑intuitively, the proposed method improves overall driving score alongside speed‑up, with reduced inter‑step plan deviation.

  4. The whole framework is training‑free, requiring no model modification. All heavy additional computation is only introduced at inference time, which lowers the barrier for existing driving‑VLA adopters.

Critical weaknesses
  1. All experiments run inside ALPASIM simulation. Latency numbers are measured on A100 GPUs. There is no test on embedded automotive hardware, where memory bandwidth and compute constraints are drastically different. Real‑world domain transfer of caching‑induced trajectory errors remains unstudied.

  2. The proposed method requires re-encoding retained CoC tokens while maintaining multiple cached feature buffers and trajectory histories, which may introduce substantial GPU memory overhead. However, the paper does not report the additional memory consumption or compare the memory footprint against the full-computation baseline. Since memory is an important constraint for practical deployment, latency improvements alone do not provide a complete picture of the system-level efficiency.

  3. The reported results suggest that FULL CoC requires approximately 650 ms, while BAC and TeaCache still spend 611–641 ms on CoC, since they leave visual encoding, multimodal prefill, and CoC decoding on the inference path. In contrast, DriveVLA-Cache reduces this cost to approximately 62 ms. VLA-Cache achieves only a 0.8× speedup due to FlashAttention incompatibility. Importantly, the more direct system-level baseline—simply skipping CoC without recontextualization—appears only in Table 2 rather than Table 1. This makes the comparison in Table 1 difficult to interpret, since the competing methods may incur substantially different computational components and system overheads. Are all caching methods compared under the same inference pipeline and computational budget, and how does the proposed method compare against the simplest baseline of skipping CoC without recontextualization?

  4. Although the proposed method substantially reduces inference latency, the reported latency remains relatively high for real-time autonomous driving. The driver-level latency is approximately 526 ms, while the end-to-end latency, including simulation and rendering, is approximately 860 ms, corresponding to only about 1.9 Hz and 1.2 Hz, respectively. Moreover, the FULL model requires approximately 1.8–2.1 s per inference, which is also far from real-time operation. Thus, the paper should clarify whether the achieved acceleration is sufficient for practical closed-loop driving and how the reported latency relates to the control frequency required by the target driving system.

Questions for authors
  1. Does the caching strategy remain effective on real-world, embedded automotive hardware rather than server-class A100 GPUs?
  2. What is the complete latency–memory–accuracy trade-off introduced by caching?
  3. Are the reported speedups measured against properly matched system-level baselines with comparable computational components?
  4. Is the achieved inference frequency actually sufficient for closed-loop autonomous driving, rather than merely demonstrating relative acceleration over an already slow baseline?
6 comments
AuthorsOpenReview ↗

RESPONSE TO REVIEWER grW2 (1/3)

Thank you for your thoughtful review and constructive suggestions. We also sincerely invite you to view the demo video in our supplementary material, which shows Alpamayo 1.5 and DriveVLA-Cache driving the same scene side by side in closed loop. We address your comments below.

W1 / Q1: Embedded hardware and real-world data. Thank you for these suggestions.

Q: "All experiments run inside ALPASIM simulation."

AlpaSim is built from real drives. Its 913 scenes are neural reconstructions of real drives from the NVIDIA Physical AI Autonomous Vehicles dataset: 1,700 hours of real driving recorded in 25 countries, the dataset used for the public evaluation of Alpamayo. Following your suggestion, we additionally ran the two experiments below outside the simulator, on real recorded drives.

Q: "Latency numbers are measured on A100 GPUs. There is no test on embedded automotive hardware, where memory bandwidth and compute constraints are drastically different." / "Does the caching strategy remain effective on real-world, embedded automotive hardware rather than server-class A100 GPUs?"

We benchmarked DriveVLA-Cache on a Jetson AGX Orin, an RTX 4090 and an RTX 6000 Ada. Driver latency (ms), with the peak speedup over FULL in parentheses:

MethodJetson AGX OrinRTX 4090RTX 6000 Ada
Alpamayo 1.5 (FULL)722712932082
DriveVLA-Cache1855 (3.9x)286 (4.5x)316 (6.6x)

DriveVLA-Cache remains effective beyond the A100, including on embedded hardware: up to 3.9x speedup on the Jetson AGX Orin, 4.5x on the RTX 4090 and 6.6x on the RTX 6000 Ada.

Q: "Real-world domain transfer of caching-induced trajectory errors remains unstudied."

Thank you for raising this important point. We studied it at both levels.

In closed loop: because the scenes of AlpaSim are real drives, the closed-loop results in Table 1 already measure how caching-induced trajectory errors behave on real-world sensor data, including how they accumulate over time, and driving quality is preserved.

On the raw recordings, with no simulator involved: 50 recordings drawn at random, before any run, from the 306,151 clips of this dataset (800 planning cycles). The trajectories of DriveVLA-Cache stay as close to the real driving as those of the full model: the average displacement error over 6.4 s is 1.85 m vs. 1.86 m, a paired difference of -0.01 m (95% CI [-0.07, +0.07]).

W2 / Q2: Memory overhead and the latency-memory-accuracy trade-off. Thank you for this suggestion.

Q: "... which may introduce substantial GPU memory overhead."

The overhead is small and fixed. The cached buffers take about 0.5 GiB in total and do not grow with driving time; the retained CoC states, which you ask about, take only 4 MiB.

Q: "However, the paper does not report the additional memory consumption or compare the memory footprint against the full-computation baseline."

You are right, and we apologize for this omission. Following your suggestion, we measured it against FULL (see the table below): the peak GPU memory increases by 5.75%.

Q: "What is the complete latency-memory-accuracy trade-off introduced by caching?"

FULLDriveVLA-Cache
Driver latency (RTX 4090)1293 ms286 ms (up to 4.5x lower)
Peak GPU memory (RTX 4090)21.60 GiB22.84 GiB (+5.75%)
Trajectory error on 50 real recordings (6.4 s)1.86 m1.85 m
Closed-loop driving score (913 scenes)70.873.4

For 5.75% more memory, DriveVLA-Cache is up to 4.5x faster with the same accuracy: the trajectory error on real recordings is unchanged, and the closed-loop driving quality is preserved.

AuthorsOpenReview ↗

RESPONSE TO REVIEWER grW2 (2/3)

W3 / Q3: Matched baselines, and the baseline of skipping CoC without recontextualization. Thank you for this careful reading of our stage-level results.

Q: "Are all caching methods compared under the same inference pipeline and computational budget?" / "Are the reported speedups measured against properly matched system-level baselines with comparable computational components?"

Yes. Every method runs in the same inference pipeline, runtime and GPU, on the same 913 scenes, and Table 6 reports each of them stage by stage. The baselines are slower for one reason: BAC and TeaCache accelerate action generation and VLA-Cache accelerates prompt prefill, so each of them leaves most of the pipeline untouched.

Driver latency per stage (ms), from Table 6, with two hypothetical rows added:

MethodVisionPrefillCoCActionOtherTotalSpeedup
Alpamayo 1.5 (FULL)14727465046225217851.0x
BAC14727763215125614641.2x
TeaCache14627664121025415271.2x
VLA-Cache14771861145424921790.8x
Fastest stage of every method above (hypothetical)14627461115124914311.25x
The same, with its CoC cost removed (hypothetical)14627401512498202.2x
DriveVLA-Cache3717962160614993.6x

The comparison is generous to the baselines. A hypothetical method that takes the fastest stage from every baseline would reach only 1.25x. Even if we additionally remove its entire CoC cost for free, it reaches 2.2x. DriveVLA-Cache reaches 3.6x, because it is the only method that reduces every stage.

Q: "How does the proposed method compare against the simplest baseline of skipping CoC without recontextualization?"

CoC reasoning is the component that makes the model robust in safety-critical long-tail scenarios. In the Alpamayo paper (arXiv:2511.00088), skipping it is the trajectory-only baseline: compared with it, CoC reasoning improves planning accuracy by up to 12% on challenging cases and lowers the close-encounter rate by 35% in closed loop. Skipping CoC would therefore buy speed at the cost of safety. DriveVLA-Cache keeps the CoC and still removes 90% of its cost (650 to 62 ms), by reusing the retained CoC and recontextualizing it. The baseline you suggest, reusing the CoC without recontextualization, is reported in the "+ Context / CoC reuse" row of Table 2 (71.5 at 863 ms), directly above the full method (73.2 at 928 ms).

AuthorsOpenReview ↗

RESPONSE TO REVIEWER grW2 (3/3)

W4 / Q4: Planning frequency and control frequency. Thank you for asking us to clarify this.

Q: "... how the reported latency relates to the control frequency required by the target driving system."

The model is a planner: each query returns a 6.4 s trajectory, which a low-level controller tracks at the control frequency. The latency of the model therefore sets how often the plan is refreshed, not how often the vehicle is controlled. This is standard practice: on Bench2Drive, for example, "a PID controller tracks the planned trajectory at 20 Hz" while the planners run at several hundred milliseconds (Guo et al., arXiv:2505.15111). In our evaluation the plan is refreshed every 100 ms of simulation time, as in the Alpamayo paper; the 860 ms end-to-end figure additionally includes simulation and neural rendering, which are not part of on-vehicle inference.

Q: "Is the achieved inference frequency actually sufficient for closed-loop autonomous driving, rather than merely demonstrating relative acceleration over an already slow baseline?"

Thank you for this question. Alpamayo is the state-of-the-art reasoning VLA for driving, and DriveVLA-Cache moves it substantially closer to real-time deployment without any training. We agree that whether a given frequency is sufficient on a specific vehicle is an important question; it depends on the whole system and is beyond the scope of this paper. In absolute terms, the planning frequency is:

ModelA100RTX 4090RTX 6000 Ada
Alpamayo 1.5 (FULL)0.5 Hz0.8 Hz0.5 Hz
DriveVLA-Cache1.9 Hz3.5 Hz3.2 Hz
VAD, on Bench2Drive (arXiv:2505.15111)-2.8 Hz-
UniAD, on Bench2Drive (arXiv:2505.15111)-1.8 Hz-

On an RTX 4090, DriveVLA-Cache raises the planning frequency from 0.8 Hz to 3.5 Hz, above the planners evaluated in closed loop on Bench2Drive (VAD 2.8 Hz, UniAD 1.8 Hz; arXiv:2505.15111, Table 2).

We hope these responses address your concerns. If so, we would be grateful if you would consider raising your score. Please let us know if anything remains unclear.

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

This paper presents DriveVLA-Cache, a training-free framework designed to mitigate inference latency in reasoning Vision-Language-Action (VLA) models for autonomous driving. The framework jointly accelerates the full pipeline through: (1) visual feature memoization and selective prompt K/V reuse across frames, (2) Reasoning Recontextualization to refresh cached reasoning states in a single prefill pass without autoregressive decoding, and (3) Velocity-Field Caching using momentum extrapolation to skip flow-matching action evaluations. Evaluated on 913 closed-loop ALPASIM scenes with Alpamayo 1.5-10B, it delivers a 3.5× driver-inference speedup and a 2.4× end-to-end speedup while preserving driving quality.

Critical strengths
  1. The paper addresses a critical and real-world bottleneck in autonomous driving: mitigating the severe inference latency of reasoning VLAs (e.g., Alpamayo) that hinders real-time, closed-loop deployment.
  2. The closed-loop benchmark of 913 scenes using photorealistic neural rendering in AlpaSim provides a solid, thorough, and realistic validation setup for closed-loop evaluation.
  3. The authors propose an innovative, training-free end-to-end framework that jointly integrates visual feature memoization, prompt K/V reuse, CoC recontextualization, and flow-matching velocity-field extrapolation without modifying or retraining the pre-trained model weights.
Critical weaknesses
  1. Comparison to SOTA: The authors omit comparisons with other state-of-the-art (SOTA) autonomous driving methods.
  2. Generalisation across Driving Models: The framework is framed as a general acceleration method for reasoning VLAs, but it is demonstrated exclusively on Alpamayo. The authors do not evaluate other SOTA driving VLAs to substantiate that the caching mechanisms transfer across different architectures.
  3. Baseline fairness: Several other efficient approaches are referenced in Related Work under the "Efficient VLA Inference" section, yet only BAC, TeaCache, and VLA-Cache are benchmarked. Additionally, VLA-Cache is incompatible with FlashAttention (FA), making the wall-clock comparison unfair since the other approaches (including the reference) have FA enabled.
  4. Performance trend inconsistency: while the authors show that DriveVLA-Cache outperforms Alpamayo 1.5 (FULL) in Table 1 (70.8→73.470.8 \rightarrow 73.4 ScoreAFScore_{AF}), in Table 4 Alpamayo 1 (FULL) outperforms DriveVLA-Cache (71.1→70.471.1 \rightarrow 70.4 ScoreAFScore_{AF}), revealing contradictory driving-quality trends across model generations.
  5. Benchmark diversity: The authors evaluate their method on only a single benchmark dataset (ALPASIM public_2601). Testing across multiple diverse benchmarks (like Bech2Drive) is critical to confirm that the reported gains are not dataset- or simulator-specific.
Questions for authors
  1. How does DriveVLA-Cache transfer to other driving VLAs with different action-head designs (e.g., discrete autoregressive), and have the authors considered or tested it on architectures beyond the Alpamayo family?
  2. Can DriveVLA-Cache work on other driving VLA models, or is it strictly designed for Alpamayo? Have you tested (or can you test) it on any other VLA architectures?
  3. Comparing VLA-Cache without FlashAttention against models using FlashAttention is unfair. Can you provide an apple-to-apple comparison (e.g., both in eager mode or comparing FLOPs), and explain why other efficient VLAs from Related Work were omitted?
  4. Why does DriveVLA-Cache beat the full-compute model on Alpamayo 1.5 (Table 1), but perform worse than the full-compute model on Alpamayo 1 (Table 4)?
  5. All tests are done only on ALPASIM public2601. Have you tested (or can you test) DriveVLA-Cache on other standard benchmarks, like Bench2Drive, to show that the gains are not limited to this single simulator?
5 comments
AuthorsOpenReview ↗

RESPONSE TO REVIEWER 9pEr (1/3)

Thank you for your thoughtful review and constructive suggestions. We also sincerely invite you to view the demo video in our supplementary material, which shows Alpamayo 1.5 and DriveVLA-Cache driving the same scene side by side in closed loop. We address your comments below.

W1: Comparison to SOTA driving methods. Thank you for raising this point.

Q: "The authors omit comparisons with other state-of-the-art (SOTA) autonomous driving methods."

We would like to clarify the positioning of our work: DriveVLA-Cache is an acceleration method for a pretrained driving model, not a new driving model. It accelerates Alpamayo 1.5, a state-of-the-art reasoning VLA for driving, without changing its weights, so its driving ability comes entirely from the model it accelerates, and the full model (FULL in Table 1) is the reference it has to match. On 913 closed-loop scenes, DriveVLA-Cache preserves the driving quality of FULL (73.4 vs. 70.8) with a 3.5x lower driver latency. We view other driving models as complementary to our work: being training-free, DriveVLA-Cache can be applied directly to stronger models as they are released. Among acceleration methods (BAC, TeaCache, VLA-Cache), it achieves the highest score and the lowest latency (Table 1).

W2 / Q1 / Q2: Generalisation across driving models. Thank you for these questions.

Q: "The framework is framed as a general acceleration method for reasoning VLAs, but it is demonstrated exclusively on Alpamayo."

DriveVLA-Cache applies to "reasoning VLAs with the same architecture" (Sec. 1), i.e., models that "combine autoregressive reasoning with a flow-matching action expert" (Sec. 5). We demonstrate it on both available generations of Alpamayo, with a 2.1-2.4x end-to-end speedup and preserved driving quality on both (Table 1, Table 4).

Q: "The authors do not evaluate other SOTA driving VLAs to substantiate that the caching mechanisms transfer across different architectures."

We fully agree that results on another model family would be valuable. To our knowledge, when this work was done, the available models with this architecture were Alpamayo 1 and Alpamayo 1.5, and we evaluate both. The two other models with this architecture were released on August 4, 2026 (Alpamayo 2 Super, NVIDIA) and on August 31, 2026 (Qwen-Drive-1.0, Zhou et al., arXiv:2609.00111), shortly before the submission deadline, and are concurrent works. Extending DriveVLA-Cache to them is our next step.

Q: "How does DriveVLA-Cache transfer to other driving VLAs with different action-head designs (e.g., discrete autoregressive)?"

Visual feature caching and reasoning recontextualization act on the VLM side, before the action head, and are not specific to a flow-matching head. Sparse action evaluation acts on the flow-matching solver, so it needs a flow-matching action head; a discrete autoregressive head has no solver steps to skip.

Q: "Have the authors considered or tested it on architectures beyond the Alpamayo family?"

We tested both generations of the Alpamayo family. Beyond it, we considered the two models named above; they are concurrent works and our next step.

Q: "Can DriveVLA-Cache work on other driving VLA models, or is it strictly designed for Alpamayo?"

It is not strictly designed for Alpamayo. Each mechanism relies only on a property of the architecture: camera frames that persist across planning cycles, reasoning that conditions the action expert through its K/V states, and a flow-matching solver. What is set per model are the parameters of the reuse policy.

Q: "Have you tested (or can you test) it on any other VLA architectures?"

Not yet, for the reason given above: extending DriveVLA-Cache to Alpamayo 2 Super and Qwen-Drive-1.0 is our next step.

AuthorsOpenReview ↗

RESPONSE TO REVIEWER 9pEr (2/3)

W3 / Q3: Baseline fairness. Thank you for these suggestions.

Q: "Several other efficient approaches are referenced in Related Work under the 'Efficient VLA Inference' section, yet only BAC, TeaCache, and VLA-Cache are benchmarked."

We benchmark training-free caching methods, the category DriveVLA-Cache belongs to, with one representative per stage: VLA-Cache for prefill, BAC and TeaCache for action generation. The other methods either cache within action generation, as BAC and TeaCache do, or change the model (adaptive depth, quantization), its inputs (token pruning) or its action representation (action tokenization), and are complementary to caching.

Q: "VLA-Cache is incompatible with FlashAttention (FA), making the wall-clock comparison unfair since the other approaches (including the reference) have FA enabled."

You are right that VLA-Cache runs without FlashAttention in Table 1: it needs explicit attention maps (output_attentions=True in its official implementation), which FlashAttention does not return.

Q: "Can you provide an apple-to-apple comparison (e.g., both in eager mode or comparing FLOPs)?"

Yes. Following your suggestion, we compare computation, which does not depend on the attention kernel: over 2,172 prefills, VLA-Cache processes 79.6% of the prefill computation of FULL (query rows x layers). Prefill is 15% of the driver latency (274 of 1785 ms, Table 6), which gives:

MethodDriver speedup over FULL
VLA-Cache, as measured without FlashAttention (Table 1)0.8x
VLA-Cache, with the same kernel as FULLabout 1.03x
VLA-Cache, if prefill had zero cost (upper bound)1.18x
DriveVLA-Cache3.6x

With the same kernel as FULL the speedup of VLA-Cache would be about 1.03x, and at most 1.18x even at zero cost for this stage. DriveVLA-Cache accelerates all four stages and reaches 3.6x.

Q: "Explain why other efficient VLAs from Related Work were omitted."

As answered under your first point: we include one representative training-free caching method per stage, and the remaining methods either belong to the same kind or are complementary to caching.

W4 / Q4: Performance trend across model generations. Thank you for pointing this out.

Q: "While the authors show that DriveVLA-Cache outperforms Alpamayo 1.5 (FULL) in Table 1 (70.8 -> 73.4 ScoreAF), in Table 4 Alpamayo 1 (FULL) outperforms DriveVLA-Cache (71.1 -> 70.4 ScoreAF), revealing contradictory driving-quality trends across model generations."

This is a careful observation, and we apologize for not reporting the statistics that resolve it. The two results are consistent: driving quality is preserved on both models. Paired comparison with FULL over the 913 scenes:

ModelFULLDriveVLA-CachePaired difference (95% CI)
Alpamayo 1.570.873.4+2.6 [+0.5, +4.7]
Alpamayo 171.170.4-0.8 [-2.7, +1.1]

On Alpamayo 1 the 95% confidence interval of the paired difference includes zero ([-2.7, +1.1]).

Q: "Why does DriveVLA-Cache beat the full-compute model on Alpamayo 1.5 (Table 1), but perform worse than the full-compute model on Alpamayo 1 (Table 4)?"

On Alpamayo 1 the two are on par: the 0.7-point gap in Table 4 is within statistical uncertainty, as shown above. Preserving the driving quality of the full model is the claim of the paper, and it holds on both models; the 2.6-point gain on Alpamayo 1.5 comes on top of it.

AuthorsOpenReview ↗

RESPONSE TO REVIEWER 9pEr (3/3)

W5 / Q5: Benchmark diversity. Thank you for this suggestion.

Q: "The authors evaluate their method on only a single benchmark dataset (ALPASIM public_2601)."

AlpaSim is the benchmark built for Alpamayo, from reconstructions of real-world drives: Alpamayo takes a fixed four-camera input and, according to its model card, is "primarily trained and only tested under this setting". We evaluate every method on the full public_2601 suite of 913 scenes, the public scenario set on which Alpamayo 1.5 itself is evaluated in closed loop (913 scenarios, Alpamayo 1.5 model card).

Q: "Testing across multiple diverse benchmarks (like Bench2Drive) is critical to confirm that the reported gains are not dataset- or simulator-specific."

The gains are not specific to one type of scene: Appendix E (Figure 11) breaks the 913 scenes down into 15 categories (road type, maneuver, night, wet road, traffic density), and the speedup holds in every category. The speedup is also not specific to the simulator. On real recorded drives, outside the simulator (driver latency in ms, peak speedup over FULL in parentheses):

MethodJetson AGX OrinRTX 4090RTX 6000 Ada
Alpamayo 1.5 (FULL)722712932082
DriveVLA-Cache1855 (3.9x)286 (4.5x)316 (6.6x)

Q: "Have you tested (or can you test) DriveVLA-Cache on other standard benchmarks, like Bench2Drive, to show that the gains are not limited to this single simulator?"

Thank you for suggesting Bench2Drive. It is an excellent benchmark, and we looked into it carefully.

Bench2Drive and our study ask different questions. Bench2Drive compares end-to-end driving models that are trained on its official data, which its authors describe as "crucial for fair algorithm-level comparisons" (Jia et al., NeurIPS 2024). Our question is whether an accelerated model drives as well as its own full-compute version. To answer it, the full model has to run in the setting it was built for; otherwise the reference itself is not meaningful.

For Alpamayo, this setting is AlpaSim: it renders, from reconstructions of real-world drives, the four cameras the model takes (front-wide, front-tele, cross-left, cross-right), and according to its model card Alpamayo is "primarily trained and only tested under this setting". Bench2Drive instead provides a nuScenes-like rig of six surround cameras rendered in CARLA, whose rendering, as its authors note, "has gaps compared to real world". With the model outside its own setting, its driving would be dominated by this mismatch, and a comparison between the full and the accelerated model would say little about acceleration.

For your underlying concern, that the gains could be specific to one simulator, please see our answer above: the speedup holds across 15 scene categories and on real recorded drives outside the simulator.

We hope these responses address your concerns. If so, we would be grateful if you would consider raising your score. Please let us know if anything remains unclear.

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

This paper presents DriveVLA-Cache, a training-free framework for accelerating reasoning-based vision-language-action models for autonomous driving. The main idea is to separate reasoning content from K/V states. Combined with visual feature caching and velocity-field caching, the framework achieves 3.5×driver-inference and 2.4×end-to-end speedups over Alpamayo 1.5-10B and achieves a 2.1×end-to-end speedup over Alpamayo 1.

Critical strengths
  1. Clear motivation and practical relevance. The paper profiles latency across the inference stages of Alpamayo 1.5-10B / Alpamayo 1 and proposes targeted optimizations, including reasoning recontextualization and caching. These methods accelerate inference without changing the pretrained weights.
  2. Impressive closed-loop results. The paper demonstrates substantial acceleration while maintaining or improving driving performance in the evaluated settings.
Critical weaknesses
  1. The evidence for generality is limited. The main experiments use Alpamayo 1.5-10B, and Appendix A.2 also evaluates Alpamayo 1. This supports transfer across two versions of the same family, but not across different VLA architectures. Please clarify which components are broadly applicable and which require model-specific adaptation. If the authors retain the broader applicability claim (in Sections 1 and 5), evidence from a different compatible model family would strengthen it. Otherwise, a narrower claim would be appropriate.
  2. The discussion of the experiments is insufficient:
    • The quality gain from sparse action evaluation is not sufficiently explained. Why does the introduction of sparse action lead to higher driving scores?
    • (Optional, may hit the ICLR Contemporaneous Work Policy). FlashDrive [R1] utilizes a similar mechanism (Adaptive-step flow matching), which has been published on arXiv and accepted by ICLR-26 ES-Reasoning Workshop and CoRL. It would be appreciated if the authors could differentiate their contribution from this work.

[R1] Zekai Li et al., FlashDrive: Flash Vision-Language-Action Inference for Autonomous Driving.

  • ICLR-26 ES-Reasoning Workshop Accepted in Mar. 2026. URL
  • CoRL Accepted in Sep. 2026. (Contemporaneous Work)
  • arXiv uploaded in Aug. 2026. (Contemporaneous Work)
Questions for authors

Besides the critical weaknesses above, one other issue should also be justified:

  1. The choice not to retain refreshed CoC states needs justification:
    • Section 4.1 clearly states that refreshed CoC K/V states are used only for the current cycle. Later carry cycles return to the states stored at the last CoC renewal. However, the reason for this choice is unclear.
    • Retaining the refreshed states while keeping the CoC text unchanged would also separate content renewal from state refresh. The paper neither explains why this alternative is less suitable nor compares the two choices. Please clarify the design rationale and, if feasible, provide a targeted ablation on the existing evaluation subset.

Other minor issues worth improving but not required to be answered during the rebuttal period:

  • Presentation and Writing. For example, streamline the wording of L88-102. The discussion in Section 5.2 and Appendix A.1 often restates the tables without fully explaining the trends; the evaluation sets used in Table 3 should be clarified; Typo: L92 ", Joint" -> "joint".
4 comments
AuthorsOpenReview ↗

RESPONSE TO REVIEWER xQTR (1/2)

Thank you for your thoughtful review and constructive suggestions. We also sincerely invite you to view the demo video in our supplementary material, which shows Alpamayo 1.5 and DriveVLA-Cache driving the same scene side by side in closed loop. We address your comments below.

W1: Generality and scope of the claim. Thank you for raising this point.

Q: "This supports transfer across two versions of the same family, but not across different VLA architectures."

To our knowledge, when this work was done, the available models with this architecture were Alpamayo 1 and Alpamayo 1.5, and we evaluate both. The two other models with this architecture were released on August 4, 2026 (Alpamayo 2 Super, NVIDIA) and on August 31, 2026 (Qwen-Drive-1.0, Zhou et al., arXiv:2609.00111), shortly before the submission deadline, and are concurrent works. Extending DriveVLA-Cache to them is our next step.

Q: "Please clarify which components are broadly applicable and which require model-specific adaptation."

The three mechanisms are broadly applicable, because each relies only on a property of the architecture itself: visual feature caching on camera frames that persist across planning cycles, reasoning recontextualization on reasoning that conditions the action expert through its K/V states, and sparse action evaluation on the flow-matching solver. What is set per model are the parameters of the reuse policy: the camera and history-frame layout, the recontextualization period and renewal parameters, and the evaluated flow-matching steps. Both generations of Alpamayo are accelerated in this way (Table 1, Table 4).

Q: "If the authors retain the broader applicability claim (in Sections 1 and 5), evidence from a different compatible model family would strengthen it. Otherwise, a narrower claim would be appropriate."

We agree that the claim should be the narrower one, and this is the claim we make: DriveVLA-Cache targets models with the same architecture as Alpamayo, i.e., "reasoning VLAs with the same architecture" (Sec. 1) that "combine autoregressive reasoning with a flow-matching action expert" (Sec. 5).

W2.1: Why sparse action evaluation leads to higher driving scores. Thank you for the question.

Q: "The quality gain from sparse action evaluation is not sufficiently explained. Why does the introduction of sparse action lead to higher driving scores?"

In short, the skipped middle evaluations add little to the plan itself but make consecutive plans less consistent, and in closed loop the plan is replaced every 100 ms.

Firstly, the explanation. Flow matching generates the plan coarse-to-fine: the first steps decide how fast and how far to drive, and the last steps decide where the vehicle sits in its lane (the longitudinal position at 2 s is 66% determined after step 3, while the lateral position is 10% determined after step 3 and 50% after step 8). The evaluations we keep are the ones that decide the plan. The middle evaluations mostly re-refine the coarse plan, and what they add is variation between consecutive plans.

Secondly, the verification. We ran a controlled test in closed loop: starting from our schedule, we turn the skipped middle steps back into real evaluations one at a time, with everything else unchanged (65 scenes, same seed).

Real evaluationsSteps evaluatedScorePlan deviation
4 (ours)0,1,3,879.10.128
5+ 577.50.134
6+ 5,777.30.138
8+ 4,5,6,775.40.139
10all72.60.161

Each added middle evaluation lowers the driving score by 1.01 points (95% CI [-1.90, -0.18]) and raises the plan deviation by 0.0049 (95% CI [+0.0026, +0.0074]).

AuthorsOpenReview ↗

RESPONSE TO REVIEWER xQTR (2/2)

W2.2 (optional): FlashDrive vs. DriveVLA-Cache. Thank you for pointing us to this work.

Q: "FlashDrive [R1] utilizes a similar mechanism (Adaptive-step flow matching) ... It would be appreciated if the authors could differentiate their contribution from this work."

FlashDrive can be understood and compared with DriveVLA-Cache in four respects. Firstly, the motivation. FlashDrive starts from an open-loop observation: consecutive velocities are similar in the middle of the path, so these steps can be skipped, which is near-lossless in open loop (from their paper). DriveVLA-Cache starts from closed-loop driving, where errors compound across planning cycles (Figure 3). We find that the first steps of the flow decide the coarse plan (how fast and how far to drive) and the last steps decide the lateral placement in the lane, and that a lateral error which recurs in every planning cycle compounds.

Secondly, the design that follows from it. FlashDrive copies the velocity of the preceding step on four intermediate steps of an 8-step solver (from their paper). DriveVLA-Cache keeps all 10 steps of the native solver and evaluates the network at the first steps, for the coarse plan, and at one late step, for the lateral placement. At the other steps it extrapolates the velocity from its recent change instead of copying it, so that the skipped steps still follow the flow. With the same number of evaluations, this placement changes the closed-loop score by 7.7 points (Table 3b), and each additional middle evaluation lowers it by 1.01 points (W2.1). Neither effect appears in open-loop error.

Thirdly, beyond this mechanism, training. FlashDrive as a whole requires fine-tuning the action expert (from their paper); DriveVLA-Cache is training-free and keeps all weights frozen. The two are complementary.

Fourthly, the reasoning stage. FlashDrive accelerates reasoning decoding with a trained draft model (from their paper). DriveVLA-Cache retains the reasoning text across cycles and only refreshes its K/V states (Reasoning Recontextualization), which has no counterpart in FlashDrive.

We plan to thoroughly compare DriveVLA-Cache with concurrent works such as FlashDrive in our future work. Comparison against these is out of the scope of the rebuttal.

Q3: Why later carry cycles return to the stored CoC states. Thank you for this suggestion! Retaining the refreshed states is a natural alternative, and following your suggestion we compared the two choices.

Q: "Later carry cycles return to the states stored at the last CoC renewal. However, the reason for this choice is unclear. Retaining the refreshed states while keeping the CoC text unchanged would also separate content renewal from state refresh."

The stored states have two roles. They condition the action expert on carry cycles, and they are also the retained branch of Action-Aware CoC Renewal, which compares the trajectory from the stored CoC with the trajectory from a freshly generated CoC to decide when the reasoning is renewed (Sec. 4.1). We keep the stored states as they were generated, so that this comparison measures how far the reasoning has aged since its generation, in both content and state. If the refreshed states were retained, each refresh would reset this reference: the measured disagreement drops from 9.8 cm to 5.7 cm, and the renewal decision would no longer see the staleness of the states.

Q: "The paper neither explains why this alternative is less suitable nor compares the two choices. Please clarify the design rationale and, if feasible, provide a targeted ablation on the existing evaluation subset."

We ran the ablation on the existing evaluation subset, as you requested:

ScenesGeneration-time states (ours)Refreshed states retainedPaired difference (95% CI)
Existing evaluation subset (128)75.168.7-6.4 [-12.4, -0.4]

Retaining the refreshed states does not improve driving: the score is 6.4 points lower (95% CI [-12.4, -0.4]). This supports the design choice in the paper.

Minor issues. Thank you for the careful reading.

Q: "Streamline the wording of L88-102. The discussion in Section 5.2 and Appendix A.1 often restates the tables without fully explaining the trends; the evaluation sets used in Table 3 should be clarified; Typo: L92."

To clarify the evaluation sets of Table 3: all three parts use the same 128 scenes as Table 2. We also appreciate the suggestions on the wording of L88-102, on the discussion in Sec. 5.2 and Appendix A.1, and the typo at L92.

We hope these responses address your concerns. If so, we would be grateful if you would consider raising your score. Please let us know if anything remains unclear.

Dear Reviewer xQTR, since the discussion period is ending soon, we would appreciate hearing your thoughts on our responses. Please let us know if any concerns remain.

Dear Reviewer xQTR, as the discussion period is closing soon, we would be very grateful for your thoughts on our responses. Thank you for your time and consideration.

Comments on the paper

2 comments
AuthorsOpenReview ↗

GENERAL RESPONSE TO ALL REVIEWERS

We sincerely thank all reviewers for their valuable time and insightful reviews. We are encouraged that the reviewers found the problem practically important [xQTR, 9pEr], the 913-scene closed-loop validation solid and large-scale [9pEr, grW2], and the training-free full-pipeline design a strength [9pEr, grW2]. We also sincerely invite all reviewers to view the demo video in our supplementary material, which shows Alpamayo 1.5 and DriveVLA-Cache driving the same scene side by side in closed loop.

DriveVLA-Cache accelerates Alpamayo 1.5, the state-of-the-art reasoning VLA for driving, by 3.5x without any training, while preserving its closed-loop driving quality on 913 scenes. Following the reviewers' suggestions, we ran six new experiments, and all of them support the claims of the paper:

  • Sparse action evaluation is explained and verified by a controlled test [xQTR]. The evaluations we keep are the ones that decide the plan, while the skipped middle evaluations mainly add variation between consecutive plans. In closed loop, our 4-evaluation schedule scores 79.1, against 72.6 with all 10 evaluations.
  • The design of returning to the stored CoC states is confirmed by the requested ablation [xQTR]. Our design scores 75.1, against 68.7 when the refreshed states are retained.
  • Driving quality is preserved on both model generations [9pEr]. In a paired comparison with FULL over 913 scenes, DriveVLA-Cache gains 2.6 points on Alpamayo 1.5 (95% CI [+0.5, +4.7]) and is within statistical uncertainty of FULL on Alpamayo 1.
  • The advantage over VLA-Cache holds in a kernel-independent comparison [9pEr]. Even with the same attention kernel as FULL and a zero-cost prefill, VLA-Cache would reach at most 1.18x, whereas DriveVLA-Cache accelerates every stage of the pipeline.
  • The results hold on real recordings outside the simulator [grW2]. On 50 randomly drawn real recordings, the trajectories of DriveVLA-Cache are as close to the real driving as those of the full model (1.85 m vs. 1.86 m over 6.4 s).
  • The speedup holds on embedded and consumer hardware [grW2]. Up to 3.9x on a Jetson AGX Orin, 4.5x on an RTX 4090 and 6.6x on an RTX 6000 Ada, with only 5.75% more GPU memory.

If our responses have adequately addressed your concerns, we kindly hope you might consider raising your score.

Area_Chair_VErxOpenReview ↗

Reminder: Author Response and Reviewer Discussion

Dear Reviewers,

We are halfway through the discussion period. Please review the authors’ responses, address any remaining concerns, and engage in the discussion where appropriate. If your assessment remains unchanged, please briefly acknowledge that you have considered the authors’ responses.

Thank you for your time and contributions.

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

Related papers

Discussion (0)

Sign in to comment.