- 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
-
The proposed Reasoning Recontextualization offers a practical workaround without retraining or fine‑tuning the original VLA weights.
-
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.
-
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.
-
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
-
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.
-
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.
-
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?
-
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
- Does the caching strategy remain effective on real-world, embedded automotive hardware rather than server-class A100 GPUs?
- What is the complete latency–memory–accuracy trade-off introduced by caching?
- Are the reported speedups measured against properly matched system-level baselines with comparable computational components?
- 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
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:
| Method | Vision | Prefill | CoC | Action | Other | Total | Speedup |
|---|---|---|---|---|---|---|---|
| Alpamayo 1.5 (FULL) | 147 | 274 | 650 | 462 | 252 | 1785 | 1.0x |
| BAC | 147 | 277 | 632 | 151 | 256 | 1464 | 1.2x |
| TeaCache | 146 | 276 | 641 | 210 | 254 | 1527 | 1.2x |
| VLA-Cache | 147 | 718 | 611 | 454 | 249 | 2179 | 0.8x |
| Fastest stage of every method above (hypothetical) | 146 | 274 | 611 | 151 | 249 | 1431 | 1.25x |
| The same, with its CoC cost removed (hypothetical) | 146 | 274 | 0 | 151 | 249 | 820 | 2.2x |
| DriveVLA-Cache | 37 | 179 | 62 | 160 | 61 | 499 | 3.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).
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:
| Model | A100 | RTX 4090 | RTX 6000 Ada |
|---|---|---|---|
| Alpamayo 1.5 (FULL) | 0.5 Hz | 0.8 Hz | 0.5 Hz |
| DriveVLA-Cache | 1.9 Hz | 3.5 Hz | 3.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.
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:
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?"
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.