acceptodds
Under review as a conference paper at ICLR 2027

QCache-VLA: Quantization and Diffusion Cache for Efficient Vision-Language-Action Policy Inference

Abstract

Vision-Language-Action (VLA) models have emerged as a promising paradigm for generalist robot control. But their deployment on resource-constrained robotic platforms remains challenging due to the heavy Vision-Language Model (VLM) backbone and multi-step diffusion-based action generation. Existing acceleration methods are not directly suited to VLA diffusion policies: post-training quantization can suffer from image-text distribution mismatch and action-agnostic quantization decisions, while fixed-interval diffusion caching cannot adapt to non-uniform redundancy across denoising steps. To address these issues, we propose QCache-VLA, a discrepancy-aware acceleration framework for efficient VLA inference. For the VLM backbone, we introduce action-aware post-training quantization with modality-aligned smoothing candidate generation, action-aware candidate selection, and modality-balanced weight reconstruction. For the action expert, we propose a residual-calibrated dynamic diffusion cache that reuses deep residuals only when adjacent denoising steps are sufficiently similar. We further integrate INT8 Triton kernels and diffusion-step precomputation to enable practical end-to-end acceleration. Experiments in simulation and real-world tasks show that QCache-VLA preserves task performance while reducing GPU memory usage by and achieving a end-to-end speedup.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Vision-Language-Action Models, Post-training Quantization, Diffusion Cache, Efficient Inference.

Reviews

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

This paper proposes QCache-VLA, a training-free framework for faster vision-language-action (VLA) inference. It combines action-aware quantization of the VLM backbone, residual-based caching in the diffusion action expert, and an INT8 runtime backend. The authors evaluate it on RoboTwin, LIBERO, and real-world manipulation tasks.

Critical strengths

• The paper addresses both major sources of inference cost rather than optimizing only the VLM or the action expert. The end-to-end measurements are especially useful: on an RTX 4090, latency falls from 168 ms to 38 ms and GPU memory use drops by about 37%. The breakdown also shows why the runtime backend matters—quantization alone does not improve latency.

• The low-computation results are striking. With only two fully computed expert steps, QCache-VLA reaches 78.0% average success on RoboTwin’s easy π₀.₅ tasks, compared with 15.6% for EfficientVLA and 11.6% for DiCache at the same step budget (Appendix Table 5). The corresponding hard-task results show a similar gap.

• I find the motivation for action-aware quantization convincing. A small reconstruction error within the VLM need not translate into a small error in the policy’s final action.

Critical weaknesses

• I am not sure how much the dynamic gate contributes in the setting where QCache-VLA performs best. At δ = 1.0, Table 3(b) reports an average of 2.0 fully computed steps. The experimental setup says that these are the first and final steps, which Algorithm 3 requires to be computed in full anyway. This suggests that the gate rarely rejects reuse at intermediate steps. The two-step results are impressive, but they do not tell us whether a fixed scheme that always reuses the calibrated residual between the first and final steps would work just as well.

• Appendix Table 5 compares methods at matched numbers of fully computed steps, which is helpful. However, EfficientVLA and DiCache are paired with MBQ, while QCache-VLA uses its own quantization method. It is therefore difficult to separate the benefit of the cache from that of quantization. Comparisons using the same quantized checkpoint would help. I would also be interested in why QCache-VLA’s advantage is much larger at two fully computed steps than at three or five.

• I could not find a direct ablation of the action-aware selection loss in Eq. (9). Table 3(a) tests the smoothing and reconstruction components, but does not keep the smoothing candidates fixed and compare the proposed directional loss with a local reconstruction loss. Without this comparison, it is hard to judge how much the selection objective itself contributes.

Questions for authors

• At δ = 1.0, how often does the gate reject cache reuse? How does it compare with fixed first-and-final-step caching using the same residual calibration?

• Can the authors isolate the effects of caching and quantization on the same checkpoint, and directly compare the selection loss in Eq. (9) with a local reconstruction loss?

5 comments

We thank the reviewer for the constructive assessment and thoughtful suggestions. We address each concern below.

W1 & Q1: Contribution of Dynamic Gating and Comparison with Fixed Caching Schedules

A1: We thank the reviewer for this insightful observation. We agree that under the default threshold δ=1.0\delta=1.0, the dynamic gate rarely rejects cache reuse at intermediate denoising steps. Consequently, only the first and final steps require full action-expert evaluations, making the computation schedule effectively equivalent to a fixed first-and-last strategy.

However, our method does not simply reuse previously cached features. As described in Eqs. (16)–(17), each intermediate step still computes the current first-layer response and dynamically rescales the cached deep residual using the magnitude ratio of consecutive early residuals. Therefore, the performance under this aggressive two-full-evaluation setting primarily reflects the effectiveness of residual-calibrated cache reuse, rather than dynamic gating alone.

To further clarify the behavior of dynamic gating, we report the average number of full action-expert evaluations under different thresholds for π0.5 and GR00T N1.7.

Table R1. Average number of full action-expert evaluations under different cache thresholds, evaluated on LIBERO.

Threshold δ\deltaπ0.5 (10 steps)GR00T N1.7 (4 steps)
0.205.0253.95
0.254.153.15
0.304.003.00
1.002.002.00

Since the first and final steps are always fully computed, the average cache rejection rate at intermediate steps can be calculated as

rreject=N‾full−2T−2,r_{\mathrm{reject}}=\frac{\overline{N}_{\mathrm{full}}-2}{T-2},

where N‾full\overline{N}_{\mathrm{full}} denotes the average number of full expert evaluations and TT is the total number of denoising steps.

At δ=1.0\delta=1.0, the rejection rate is effectively 0% for both models. At$\delta=0.2$, it increases to approximately 37.81% for π0.5 and 97.50% for GR00T N1.7. These results demonstrate that the dynamic gate adjusts the number of full evaluations under more restrictive thresholds, providing a configurable trade-off between computation and task performance. We additionally report success-rate comparisons under different numbers of full evaluations on π0.5 in the RoboTwin simulation environment in Appendix Table 5.

Regarding the suggested fixed first-and-last caching baseline, we additionally evaluate two simple fixed strategies on GR00T N1.7. As shown in Table R2, fixed first-and-last computation achieves an average success rate of 92.70%, while fixed first-and-last caching with direct reuse of the first-step residual αt=1\alpha_t=1 achieves 92.60%. In comparison, QCache-VLA achieves 93.60% with dynamically calibrated residual reuse.

Table R2. Comparison of caching strategies on GR00T N1.7 LIBERO under full precision and different W8A8 quantization methods. All cached variants use two full action-expert evaluations within the original four-step denoising schedule. Success rates are reported in %.

MethodPrecision / PTQFull NFESpatialLongGoalObjectAvg.
OriginalFP497.084.295.895.293.05
DiCacheFP297.083.494.494.292.25
EfficientVLAFP297.282.095.494.892.35
Fixed first/lastFP296.483.895.695.092.70
Fixed first/reuse/lastFP297.683.695.094.292.60
QCache-VLAFP297.285.096.495.893.60
DiCacheW8A8 (QVLA)296.481.892.095.491.40
DiCacheW8A8 (Ours)297.483.095.696.293.05
EfficientVLAW8A8 (QVLA)297.082.892.095.291.75
EfficientVLAW8A8 (Ours)296.083.695.095.292.45
QCache-VLAW8A8 (Ours)297.683.096.495.493.10

Compared with direct residual reuse without rescaling, QCache-VLA improves average success by 1.00 percentage point, supporting the benefit of adapting cached residuals to the current denoising state. Therefore, residual calibration enables accurate reuse under aggressive caching, while dynamic gating provides adaptive computation allocation at other thresholds. We will clarify this distinction in the revised manuscript.

W2 & Q2: Disentangling Quantization and Caching Effects and Understanding the Advantage at Two Full Evaluations

A2: We thank the reviewer for pointing out the confounding effects of different quantization methods. We agree that the original Appendix Table 5 combines EfficientVLA and DiCache with MBQ, whereas QCache-VLA uses our proposed quantization pipeline. Therefore, the performance differences cannot be attributed solely to caching.

To disentangle the effects of caching and quantization, we conducted additional experiments on GR00T N1.7 using LIBERO, comparing different caching strategies under full precision and two W8A8 quantization pipelines (QVLA and Ours). All cached variants use two full action-expert evaluations within the original four-step schedule (Table R2).

Under full precision, QCache-VLA achieves 93.60% average success, outperforming DiCache (92.25%) and EfficientVLA (92.35%), demonstrating its effectiveness independently of quantization. Under our unified W8A8 setting (MAS + MBR), QCache-VLA achieves 93.10%, compared with 93.05% for DiCache and 92.45% for EfficientVLA. Furthermore, keeping the caching strategy fixed, our quantization pipeline outperforms QVLA by 1.65 percentage points with DiCache (93.05% vs. 91.40%) and 0.70 percentage points with EfficientVLA (92.45% vs. 91.75%). These controlled comparisons help distinguish the contributions of caching and quantization while demonstrating near-baseline task performance.

Regarding why QCache-VLA exhibits a larger advantage at two full evaluations than at three or five, we believe this behavior is related to the accumulation of cache approximation errors under increasingly aggressive reuse.

When more full expert evaluations are available, deeper features are refreshed more frequently, limiting the duration over which approximation errors can accumulate. Consequently, different caching strategies may produce relatively similar results.

In contrast, when only two full evaluations are performed, multiple consecutive intermediate steps rely on cached approximations. Directly reusing historical features without adapting them to the current diffusion state may introduce larger deviations in the final action prediction. QCache-VLA mitigates this issue by retaining the current first-layer response and using residual calibration to adjust the cached deep transformation.

This interpretation is consistent with the original Appendix Table 5. On π0.5 under RoboTwin Easy, at three full evaluations, DiCache and QCache-VLA achieve 76.7% and 78.0% average success, respectively. However, at two full evaluations, DiCache drops to 11.6%, while QCache-VLA maintains 78.0%. EfficientVLA also drops to 15.6% under the two-full-evaluation setting.

These observations suggest that calibrated residual reuse becomes particularly important when the number of full evaluations is extremely limited.

Overall, the additional GR00T experiments reduce the confounding effects of different quantization pipelines, while the low-step comparisons provide further evidence that QCache-VLA preserves action-generation quality under aggressive caching.

W3 & Q2: Independent Contribution of the Action-Aware Candidate Selection Objective

A3: We thank the reviewer for this constructive suggestion. We agree that the original Table 3(a) primarily evaluates modality-aligned smoothing and modality-balanced reconstruction as components, but does not directly isolate the contribution of the action-aware candidate selection objective in Eq. (9).

To address this concern, we conducted an additional ablation comparing different smoothing selection objectives while keeping the smoothing candidate set unchanged. Specifically, we compare the proposed action-aware directional loss against conventional local reconstruction objectives based on Block MSE and Block MAE.

We evaluate the final-action reconstruction errors relative to the original full-precision model, together with closed-loop success on LIBERO-Long, as shown in Table R4.

Table R4. Ablation of smoothing candidate selection objectives. Final-action reconstruction errors are measured against the original full-precision model.

Search ObjectiveAction MSE ↓ (×10⁻⁶)Action MAE ↓ (×10⁻³)LIBERO-Long (%) ↑
Block MSE2.80121.193791.8
Block MAE3.05221.240091.4
Action-aware (Ours)2.55811.127292.4

Compared with Block MSE selection, our action-aware criterion reduces final-action MSE by approximately 8.68% and MAE by 5.57%, while improving LIBERO-Long success from 91.8% to 92.4%.

These results support the motivation behind Eq. (9). Conventional local reconstruction objectives primarily minimize quantization errors at the current module output, without explicitly considering their effects on downstream action predictions.

In contrast, our action-aware criterion uses randomly projected gradients to estimate how local quantization perturbations influence the final velocity prediction. This enables the selection of smoothing parameters that better preserve action-relevant information, even when local reconstruction errors alone do not fully reflect downstream sensitivity.

Importantly, the comparison changes the candidate selection objective rather than the smoothing candidate set, allowing us to more directly evaluate the contribution of the proposed directional loss.

The additional results indicate that action-aware selection provides better final-action numerical fidelity than the tested local reconstruction objectives and achieves higher average LIBERO-Long success under the evaluated setting. We will include this controlled ablation in the revised manuscript to clarify the independent contribution of the action-aware selection objective.

Reviewer_ujSuOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

QCache-VLA is a training-free acceleration framework combining post-training quantization, diffusion-feature caching, and a specialized inference backend. Quantization uses modality-aligned smoothing candidates, a randomly projected estimate of downstream action sensitivity for candidate selection, and modality-balanced weight reconstruction. Caching uses first-layer residual changes to decide whether deeper computation can be reused and rescales cached residuals accordingly. INT8 Triton kernels and timestep precomputation translate these changes into runtime savings. Experiments cover π0, π0.5, and OpenVLA-OFT across LIBERO, three RoboTwin tasks, and two physical tasks, reporting approximately 4.4× acceleration and 37% lower memory consumption.

Critical strengths
  1. The action-aware quantization criterion is technically motivated. The projected-gradient score estimates the first-order effect of a local quantization perturbation on downstream velocity prediction, rather than optimizing only local reconstruction error. This provides a principled connection between compression decisions and the output relevant to robot control.

  2. The method addresses actual deployment costs. The paper explicitly shows that fake quantization alone does not produce a speedup, then reports an optimized backend reducing inference latency from 168 ms to 38 ms and memory from 16,064 MB to 10,100 MB.

Critical weaknesses
  1. The comparisons confound quantization and caching improvements. Cache baselines use MBQ, whereas QCache-VLA uses its own quantization pipeline. Consequently, their performance differences cannot be assigned specifically to the cache mechanism. The ablation also does not separately establish the contribution of action-aware candidate selection or residual rescaling, leaving the effects of the individual proposed components insufficiently identified.

  2. It is unclear whether the reported closed-loop success rates use the actual INT8 Triton backend associated with the 38 ms latency or a fake-quantized implementation. Without this link, the paper does not fully substantiate its combined claim of approximately 4.4× acceleration with preserved task performance. Competing methods are also not profiled under an equivalent optimized backend.

  3. With the default threshold, only the first and final denoising steps are fully computed. This makes it important to compare against a fixed first-and-final schedule using the same residual approximation. The current threshold analysis covers only one RoboTwin task, while the physical evaluation contains two tasks with ten trials each. These results provide limited evidence that the aggressive operating point remains reliable across different action dynamics.

Questions for authors
  1. Were Tables 1–3 and the physical-task success rates obtained using the exact INT8 Triton backend associated with the 38 ms latency? If not, can you report closed-loop success and numerical agreement for that backend?

  2. Does “2 steps” mean two full expert evaluations within a ten-step integration schedule? Do all cache baselines retain the same integration schedule and first-layer computations?

  3. Under identical quantization and runtime implementations, how do the cache methods compare at matched latency? Can you also isolate the effects of the action-aware selection criterion and residual rescaling, including comparison with a fixed first-and-final evaluation schedule?

6 comments

We thank the reviewer for the constructive assessment and thoughtful suggestions. We address each concern below.

W1 & Q3: Disentangling Quantization and Caching Contributions and Component Ablations

A1: We thank the reviewer for raising this important concern. We agree that the original comparisons combine EfficientVLA and DiCache with MBQ, whereas QCache-VLA uses our proposed quantization pipeline. Consequently, the performance differences cannot be attributed solely to the caching mechanism.

To address this issue, we conducted additional experiments on GR00T N1.7 using the LIBERO benchmark, comparing different caching strategies under both full precision and our unified W8A8 quantization pipeline (including MAS and MBR), with all cached variants using two full action-expert evaluations.

Table R2. Comparison of caching strategies on GR00T N1.7 LIBERO under full precision and different W8A8 quantization methods. All cached variants use two full action-expert evaluations within the original four-step denoising schedule. Success rates are reported in %.

MethodPrecision / PTQFull NFESpatialLongGoalObjectAvg.
OriginalFP497.084.295.895.293.05
DiCacheFP297.083.494.494.292.25
EfficientVLAFP297.282.095.494.892.35
Fixed first/lastFP296.483.895.695.092.70
Fixed first/reuse/lastFP297.683.695.094.292.60
QCache-VLAFP297.285.096.495.893.60
DiCacheW8A8 (QVLA)296.481.892.095.491.40
DiCacheW8A8 (Ours)297.483.095.696.293.05
EfficientVLAW8A8 (QVLA)297.082.892.095.291.75
EfficientVLAW8A8 (Ours)296.083.695.095.292.45
QCache-VLAW8A8 (Ours)297.683.096.495.493.10

Under full precision, QCache-VLA achieves an average success rate of 93.60%, compared with 92.25% for DiCache and 92.35% for EfficientVLA. This comparison removes quantization differences and provides more direct evidence of the effectiveness of our caching mechanism.

Under the unified W8A8 setting, QCache-VLA achieves 93.10%, compared with 93.05% for DiCache and 92.45% for EfficientVLA. These results further demonstrate that our caching mechanism can be combined with quantization while preserving near-baseline task performance, although the performance differences among quantized caching methods are relatively small.

Regarding action-aware candidate selection, we additionally conducted a controlled comparison using the same smoothing candidate set but different selection objectives, as shown in Table R4.

Table R4. Ablation of smoothing candidate selection objectives. Final-action reconstruction errors are measured against the original full-precision model.

Selection ObjectiveMSE ↓ (×10⁻⁶)MAE ↓ (×10⁻³)LIBERO-Long (%) ↑
Block MSE2.80121.193791.8
Block MAE3.05221.240091.4
Action-aware (Ours)2.55811.127292.4

Compared with Block MSE selection, our action-aware criterion reduces final-action MSE by approximately 8.68% and MAE by 5.57%, while improving LIBERO-Long success from 91.8% to 92.4%. These results support the motivation behind Eq. (9): accounting for downstream action sensitivity during smoothing candidate selection better preserves final action predictions than minimizing local reconstruction errors alone.

Regarding residual rescaling, Eqs. (16)–(17) introduce a calibration factor αt\alpha_t based on the magnitude ratio of consecutive early residuals. This factor adapts the cached deep residual to the current denoising state, rather than directly reusing historical features.

As shown in Table R2, we further compare a fixed first-and-last computation strategy, a fixed first-and-last strategy with direct reuse of the cached residual αt=1\alpha_t=1, and QCache-VLA with dynamically estimated residual calibration. On GR00T N1.7, the three configurations achieve average success rates of 92.70%, 92.60%, and 93.60%, respectively. Compared with uncalibrated residual reuse, QCache-VLA improves average success by 1.00 percentage point. These results support the effectiveness of adapting cached residuals to the current denoising state, although differences in the implementations of the fixed baselines should be considered when attributing the improvement exclusively to residual rescaling.

To further address the reviewer's concern regarding inference latency under identical quantization and runtime settings, we conducted additional latency measurements on GR00T N1.7 under both the original BF16 configuration and our W8A8 fake-quantization implementation (MAS + MBR). All caching methods retain the original four-step denoising schedule and use two full action-expert evaluations.

As shown in Table R5, under BF16, QCache-VLA achieves 102.8 ms (1.32× speedup), compared with 103.3 ms (1.31×) for DiCache and 123.7 ms (1.10×) for EfficientVLA. Under W8A8 fake quantization, QCache-VLA achieves 179.3 ms (1.38×), compared with 173.6 ms (1.43×) for DiCache and 210.3 ms (1.18×) for EfficientVLA.

These results demonstrate competitive caching efficiency under both precision settings. We emphasize that the W8A8 results are obtained using software-based fake quantization. Therefore, the reported speedups reflect the relative benefits of caching within each runtime configuration.

Table R5. Inference latency (ms) and speedup of different caching strategies on GR00T N1.7 LIBERO. All methods retain the original four-step denoising schedule, while cached variants use two full action-expert evaluations. W8A8 results use our MAS + MBR fake-quantization implementation. Speedups are calculated relative to the no-cache baseline under the same precision setting.

Cache StrategyBF16W8A8 (Ours, Fake Quant)
No Cache135.5 ms248.3 ms
QCache-VLA102.8 ms (1.32×)179.3 ms (1.38×)
DiCache103.3 ms (1.31×)173.6 ms (1.43×)
EfficientVLA123.7 ms (1.10×)210.3 ms (1.18×)

W2 & Q1: Closed-Loop Performance and Numerical Consistency of the INT8 Triton Backend

A2: We thank the reviewer for highlighting the need to distinguish between fake-quantized evaluation and actual INT8 deployment. We clarify that the quantized simulation results in Tables 1–3 were obtained using the fake-quantized implementation, whereas the real-world robotic experiments were conducted using the actual INT8 Triton backend. The reported 38 ms corresponds to the end-to-end latency of one complete policy inference in the real-world deployment setting, rather than the latency of an individual denoising step.

To further verify the closed-loop performance of the actual INT8 backend, we conducted additional experiments on π0.5 using the LIBERO benchmark, comparing the original model, fake quantization, and actual INT8 Triton execution, as shown in Table R6.

Table R6. Closed-loop success rates of the original π0.5 model, fake quantization, and actual INT8 Triton deployment on LIBERO.

MethodPrecisionSpatialObjectGoalLongAvg.
OriginalFP0.9940.9880.9780.9220.971
Fake QuantW8A80.9860.9820.9840.9100.966
INT8 TritonW8A80.9800.9740.9820.9220.965

The actual INT8 Triton implementation achieves an average success rate of 96.5%, compared with 96.6% for fake quantization and 97.1% for the original full-precision model. We further compare the two backends on the same action prediction and obtain an action-level MSE of 1.24133×10−41.24133\times10^{-4}. It provides a direct measurement of the discrepancy between the two implementations, complementing the closed-loop evaluation. The difference between fake quantization and actual INT8 execution is only 0.1 percentage points, indicating that the deployment backend preserves comparable closed-loop task performance under our evaluation protocol.

Furthermore, the real-world robotic experiments reported in the original manuscript were conducted using the actual INT8 Triton backend. With two full action-expert evaluations, QCache-VLA achieves 8/10 successes on Open the Microwave and 10/10 on Fold the Clothes. These results provide direct evidence that the actual deployment implementation can maintain task performance under aggressive caching.

Together, these results strengthen the connection between practical INT8 deployment and closed-loop performance preservation.

W3 & Q2: Dynamic Gating, Fixed Caching Schedules, and Evaluation Reliability

A3: We thank the reviewer for this insightful observation. We first clarify that “2 steps” refers to two full action-expert evaluations within the original ten-step denoising schedule, rather than directly reducing the integration process to two denoising steps.

Specifically, QCache-VLA preserves the original ten-step integration schedule. The first and final steps execute the complete action expert, while the intermediate eight steps still perform integration updates using cached approximations of the deep expert computation.

The compared caching methods follow their respective computational mechanisms:

  • QCache-VLA: Computes the first action-expert layer at every denoising step and uses the early residual to determine cache reuse. When reuse is accepted, the cached deep residual is rescaled by αt\alpha_t, allowing the remaining expert layers to be skipped.
  • DiCache: Uses the first-layer output as an online similarity probe and therefore also computes the first layer at every denoising step before deciding whether to reuse deeper features.
  • EfficientVLA: Follows its original fixed-interval caching strategy, directly reusing historical features at cached steps without performing the same additional first-layer online probe.

Thus, all methods retain the same original denoising integration schedule, but their computational overhead at cached steps is not identical.

Regarding dynamic gating, we agree that under the default threshold δ=1.0\delta=1.0, intermediate steps almost always accept cache reuse. Consequently, the full-computation schedule effectively reduces to evaluating only the first and final steps. In this setting, performance preservation mainly reflects the effectiveness of residual-calibrated cache reuse, rather than an independent benefit from dynamic gating.

To further clarify the behavior of dynamic gating, we report the average number of full action-expert evaluations under different thresholds for π0.5 and GR00T N1.7, as shown in Table R1.

Table R1. Average number of full action-expert evaluations under different cache thresholds, evaluated on LIBERO.

Threshold δ\deltaπ0.5 (10 steps)GR00T N1.7 (4 steps)
0.205.0253.95
0.254.153.15
0.304.003.00
1.002.002.00

As the threshold increases, the average number of full evaluations decreases from 5.025 to 2.00 for π0.5 and from 3.95 to 2.00 for GR00T N1.7. These results demonstrate that dynamic gating can adaptively control the amount of deep computation under different thresholds, providing a configurable trade-off between computation and task performance.

Regarding the suggested fixed first-and-last caching baseline, we conducted additional experiments on GR00T N1.7. As shown in Table R2, under full precision, the fixed first-and-last strategy achieves an average success rate of 92.70%, while the fixed first-and-last strategy with direct residual reuse αt=1\alpha_t=1 achieves 92.60%. In comparison, QCache-VLA achieves 93.60% with dynamically calibrated residual reuse.

These results indicate that QCache-VLA better preserves task performance than the evaluated simple fixed caching strategies. Nevertheless, when all intermediate steps accept reuse, a fixed first-and-last schedule using exactly the same residual calibration and cache-state updates should be computationally equivalent to QCache-VLA at δ=1.0\delta=1.0. Therefore, we attribute the performance preservation under this aggressive setting primarily to residual-calibrated reuse rather than the independent contribution of dynamic gating.

To further address the limited task coverage of the original threshold analysis, we extend our evaluation to GR00T N1.7 across all four LIBERO suites: Spatial, Object, Goal, and Long. As shown in Table R2, QCache-VLA achieves 93.60% average success under full precision and 93.10% under W8A8 quantization, both with only two full action-expert evaluations. These results provide additional evidence of aggressive caching across different manipulation tasks and a different action-expert architecture.

Reviewer_GKU5OpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes QCache-VLA, a training-free acceleration framework for VLA models. For the VLM backbone, it applies W8A8 quantization with modality-aligned smoothing, action-aware candidate selection, and modality-balanced GPTQ reconstruction. For the action expert, it reuses cached deep residuals based on a first-layer residual check, with magnitude calibration. It also implements INT8 Triton kernels and denoising-step precomputation. Experiments on RoboTwin, LIBERO, and a real robot report a latency reduction from 168 ms to 38 ms on an RTX 4090 and a 37% memory reduction. The work is deployment-oriented with a fairly complete implementation. However, the "dynamic" cache is effectively a fixed skipping schedule in the main experiments, the memory reduction cannot be attributed to quantization, and the model coverage and baselines are insufficient.

Critical strengths

1. A sound action-aware criterion for quantization.

Instead of minimizing layer-wise output error, smoothing candidates are selected by how much the quantization error affects the final velocity prediction. The Rademacher-projection estimator avoids constructing the full Jacobian and is shown to be unbiased, giving a good trade-off between cost and accuracy.

2. Residual calibration preserves action quality with very few steps.

With only 2 fully computed steps, QCache-VLA still achieves 78.0 on RoboTwin (π0.5), while EfficientVLA and DiCache drop to 15.6 and 11.6. On the real robot it reaches 8/10 and 10/10, versus 2/10 and 0/10 for EfficientVLA, suggesting that calibrated residual reuse is more stable than direct feature reuse.

3. A complete, deployment-oriented implementation.

Beyond fake quantization, the authors implement INT8 Triton kernels and denoising-step precomputation, reporting real end-to-end latency on an RTX 4090 (168 ms → 38 ms). Closed-loop deployment on an ALOHA bimanual robot further shows practical value.

Critical weaknesses

1. The "dynamic" cache is effectively a fixed skipping schedule.

The main experiments set δ = 1.0, and the paper itself states that "only the first and final denoising steps are fully computed," so all 8 intermediate steps reuse the cache. This is essentially the same as the fixed-interval scheme the authors criticize. In Table 3(b), varying the threshold from 0.2 to 1.0 keeps the success rate within 63–65, showing no benefit from the dynamic decision. Please compare against a "fixed first/last 2 steps + α calibration" variant to separate the contributions of dynamic gating and residual calibration.

2. The memory reduction cannot be attributed to quantization.

Quantization alone increases memory by 15% (16 GB → 18.5 GB), and memory only drops to 10 GB after switching to the Triton backend. The 6 GB reduction also exceeds the theoretical saving of INT8 weight quantization (~3 GB), and the 16 GB baseline does not match FP16 loading. Please clarify the actual loading precision of the baseline, add an "FP16 + Triton without quantization" control, and report the memory breakdown of weights, activations, and precomputed parameters.

3. Model coverage is limited, so the generality of the cache is not verified.

The full method and efficiency evaluation are conducted only on π0.5. π0 covers only 3 RoboTwin tasks, and OpenVLA-OFT has no diffusion head, so it only validates quantization. The action cache is therefore verified on a single architecture family. We suggest adding GR00T N1.6/N1.7, which uses only 4 denoising steps by default and a cross-attention DiT action head, to test whether the method holds under a different architecture and fewer steps.

4. Baselines are insufficient, and the quantization gains are unclear.

Quantization is compared only with SmoothQuant and MBQ, not with QVLA, a VLA-specific method the paper itself cites. The cache comparison also lacks the simplest baseline of directly reducing denoising to 2 steps. Moreover, all quantization components in the ablation fall within 0.964–0.972, which is within noise, so the contribution of each module is unclear.

Questions for authors

see weakness

5 comments

We thank the reviewer for the constructive assessment and thoughtful suggestions. We address each concern below.

W1: Limited contribution of dynamic gating under the default threshold

A1: We thank the reviewer for this insightful observation. We agree that under the default threshold δ=1.0\delta=1.0, intermediate denoising steps almost always satisfy the cache reuse condition, effectively reducing the computation schedule to full evaluations at only the first and final steps. We will clarify the distinct roles of dynamic gating and residual calibration in the revised manuscript.

Importantly, our method does not simply reuse previously cached features. As described in Eqs. (16)–(17), each intermediate step still computes the current first-layer output and dynamically rescales the cached deep residual according to the magnitude ratio of consecutive early residuals. Therefore, the performance under this aggressive two-full-evaluation setting primarily demonstrates the effectiveness of residual-calibrated cache reuse, rather than dynamic gating alone.

To further clarify the behavior of dynamic gating, we report the average number of full action-expert evaluations under different thresholds for π0.5 and GR00T N1.7.

Table R1. Average number of full action-expert evaluations under different cache thresholds, evaluated on LIBERO.

Threshold δ\deltaπ0.5 (10 steps)GR00T N1.7 (4 steps)
0.205.0253.95
0.254.153.15
0.304.003.00
1.002.002.00

As the threshold increases, the average number of full evaluations decreases from 5.025 to 2.00 for π0.5 and from 3.95 to 2.00 for GR00T N1.7. These results also help explain the observation in Table 3(b): although success rates remain relatively stable across different thresholds, the computational requirements vary substantially. This demonstrates the ability of dynamic gating to adjust the trade-off between computational cost and task performance. We additionally provide performance comparisons under different thresholds and corresponding numbers of full evaluations in Appendix Table 5.

Regarding the suggested fixed first/last + α calibration baseline, we agree that this is an important comparison. According to Algorithm 3, when all intermediate steps accept cache reuse, a fixed first-and-last schedule using exactly the same residual calibration and cache updates should be computationally equivalent to our method at δ=1.0\delta=1.0.

As shown in Table R2, we additionally evaluate fixed caching strategies on GR00T N1.7. Directly using only the first and final full evaluations yields an average success rate of 92.70%, compared with 93.05% for the original four-step model. When the first-step cache is directly reused at intermediate steps without our residual calibration, the average success rate is 92.60%, representing a decrease of 0.45 percentage points relative to the original model. In contrast, QCache-VLA achieves 93.60% with residual-calibrated reuse, exceeding the original four-step baseline by 0.55 percentage points.

These results support the effectiveness of residual calibration compared with the evaluated simple fixed reuse strategies. We emphasize that a fixed schedule employing identical residual calibration and cache-state updates would be equivalent to QCache-VLA when the gate accepts all intermediate reuse decisions. Therefore, the value of dynamic gating lies in its adaptive computation allocation under more restrictive thresholds, while residual calibration enables accurate feature reuse under aggressive caching.

Table R2. Comparison of caching strategies on GR00T N1.7 LIBERO under full precision and different W8A8 quantization methods. All cached variants use two full action-expert evaluations within the original four-step denoising schedule. Success rates are reported in %.

MethodPrecision / PTQFull NFESpatialLongGoalObjectAvg.
OriginalFP497.084.295.895.293.05
DiCacheFP297.083.494.494.292.25
EfficientVLAFP297.282.095.494.892.35
Fixed first/lastFP296.483.895.695.092.70
Fixed first/reuse/lastFP297.683.695.094.292.60
QCache-VLAFP297.285.096.495.893.60
DiCacheW8A8 (QVLA)296.481.892.095.491.40
DiCacheW8A8 (Ours)297.483.095.696.293.05
EfficientVLAW8A8 (QVLA)297.082.892.095.291.75
EfficientVLAW8A8 (Ours)296.083.695.095.292.45
QCache-VLAW8A8 (Ours)297.683.096.495.493.10

W2: Attribution of memory reduction to quantization and runtime optimization

A2: We thank the reviewer for pointing out the ambiguity in our memory analysis. We acknowledge that the original manuscript did not clearly distinguish weight storage precision, mixed-precision computation, and GPU memory measurement metrics, potentially leading to the impression that the entire memory reduction was attributable to INT8 quantization.

We first clarify that the original π0.5 baseline uses FP32 weight storage with BF16 autocast inference, rather than FP16 weight storage. The fake-quantized implementation retains reconstructed floating-point weights and unpacked integer representations, resulting in additional memory overhead. In contrast, the actual INT8 deployment uses packed INT8 weights, a single-copy weight layout, and buffer reuse through the Triton backend.

To isolate the contribution of quantization, we conducted additional memory measurements under a consistent measurement protocol and introduced the requested FP16 + Triton without quantization baseline, as shown in Table R3.

Table R3. GPU memory comparison across different quantization and deployment configurations. All memory values are reported in GiB.

ConfigurationWeight StoragePeak AllocatedPeak ReservedProcess Peak
Original (FP32 storage, BF16 autocast)12.4916.4617.1617.66
Fake Quantization16.7617.8718.5019.00
FP16 Storage + Triton (Unquantized)6.036.276.346.84
INT8 + Triton (Ours)3.904.354.414.91

Under the same Triton deployment framework, the unquantized FP16 implementation requires 6.27 GiB of peak allocated memory, whereas the INT8 implementation requires 4.35 GiB, corresponding to a reduction of approximately 1.92 GiB.

Furthermore, approximately 2.293 billion parameters are quantized from 16-bit to 8-bit representations, yielding a theoretical weight-storage reduction of:

ΔM=2.293×109×(2−1)230≈2.136 GiB.\Delta M=\frac{2.293\times10^9\times(2-1)}{2^{30}}\approx2.136\ \text{GiB}.

The measured weight-storage difference between FP16 and INT8 is approximately 2.13 GiB, closely matching this theoretical estimate. After accounting for quantization metadata, scaling factors, and runtime buffers, the observed reduction in peak allocated memory is approximately 1.92 GiB.

These results clarify that the overall memory reduction arises from a combination of reduced weight precision, elimination of redundant representations, and Triton-based memory management, rather than INT8 quantization alone. We will update the original memory analysis with these consistently measured results and explicitly distinguish weight-storage savings from runtime memory reductions.

W3: Limited architectural generality of the proposed diffusion cache

A3: We appreciate the reviewer's suggestion to evaluate the proposed cache mechanism on a different action-expert architecture.

To address this concern, we conducted additional experiments on GR00T N1.7 using the LIBERO benchmark. Unlike π0.5, which employs ten denoising steps, GR00T N1.7 uses a four-step action-generation process and a different action-expert architecture. This provides an additional evaluation of our caching mechanism under fewer denoising steps and a different model structure.

As shown in Table R2, we first compare different caching strategies on GR00T N1.7 under full precision. To further disentangle caching and quantization effects, we additionally evaluate these strategies using different quantization method under the same W8A8 setting.

Under full precision, QCache-VLA achieves an average success rate of 93.60% with only two full expert evaluations, compared with 93.05% for the original four-step model. It also achieves higher average success rates than the evaluated alternative caching strategies.

Under W8A8 quantization, QCache-VLA achieves 93.10%, closely matching the original full-precision model at 93.05%. We further compare our quantization pipeline (MAS + MBR) with QVLA under identical caching strategies. When combined with DiCache, our quantization achieves 93.05%, compared with 91.40% using QVLA. Similarly, under EfficientVLA caching, our quantization achieves 92.45%, compared with 91.75% using QVLA. These results indicate that our caching mechanism can be combined with quantization while preserving task performance on GR00T N1.7.

Overall, the additional experiments extend our evaluation from π0/π0.5 to GR00T N1.7 and from ten-step to four-step action generation, providing further evidence of the method's applicability across different action-expert architectures.

W4: Missing quantization and direct two-step baselines, and unclear contributions of individual quantization components

A4: We thank the reviewer for these constructive suggestions. We address the three concerns separately.

(1) Comparison with QVLA. We agree that QVLA is a closely related VLA-specific quantization method and that its relationship to our approach should be clarified.

QVLA primarily investigates the quantization sensitivity of different action-related channels, whereas QCache-VLA focuses on image-text distribution discrepancies and their downstream effects on action prediction. While QVLA focuses on quantizing the VLM backbone, our quantization pipeline covers the attention and MLP projections of both the VLM backbone and the diffusion/flow-based action expert.

To further evaluate the differences between these quantization approaches, we conducted additional experiments on GR00T N1.7 using the LIBERO benchmark. Specifically, we applied QVLA and our proposed quantization pipeline (MAS + MBR) to the same underlying full-precision policy, while keeping the caching strategy fixed to either DiCache or EfficientVLA.

As shown in Table R2, our quantization method consistently achieves higher average success rates under both caching strategies. When combined with DiCache, our method achieves 93.05%, compared with 91.40% using QVLA, an improvement of 1.65 percentage points. Similarly, when combined with EfficientVLA, our method achieves 92.45%, compared with 91.75% using QVLA, an improvement of 0.70 percentage points.

These results indicate that our quantization pipeline is better able to preserve task performance under the evaluated caching configurations. One possible explanation is that explicitly accounting for image-text modality discrepancies helps reduce quantization errors in multimodal representations that condition downstream action generation.

We will include these additional comparisons in the revised manuscript to provide a more comprehensive evaluation against VLA-specific quantization methods.

(2) Direct two-step denoising baseline. We agree that directly reducing the denoising schedule to two steps is an important baseline.

Our two-full-evaluation configuration differs from direct two-step sampling: QCache-VLA preserves the original denoising integration schedule, while approximating intermediate action-expert outputs using current shallow features and calibrated historical deep residuals. In contrast, direct two-step sampling changes the integration schedule itself.

As shown in Table R2, our additional GR00T N1.7 experiments include fixed first-and-last computation and the same intermediate cache reuse strategies. These comparisons help distinguish our residual-calibrated reuse mechanism from simpler fixed caching strategies. However, they are distinct from directly reducing the integration schedule to two steps and therefore do not replace a direct two-step sampling baseline.

(3) Individual component contributions and statistical variation.

To further isolate the contribution of action-aware candidate selection, we conducted an additional comparison using the same smoothing candidate set but different selection objectives.

Table R4. Ablation of smoothing candidate selection objectives. We report final-action reconstruction errors relative to the original full-precision model and task success on LIBERO-Long.

Selection ObjectiveMSE ↓ (×10⁻⁶)MAE ↓ (×10⁻³)LIBERO-Long (%) ↑
Block MSE2.80121.193791.8
Block MAE3.05221.240091.4
Action-aware (Ours)2.55811.127292.4

Compared with Block MSE selection, our action-aware criterion reduces final-action MSE by approximately 8.68% and MAE by 5.57%, while improving LIBERO-Long success from 91.8% to 92.4%. These results suggest that accounting for downstream action-prediction errors is more effective than relying solely on local feature reconstruction errors when selecting smoothing parameters.

Regarding statistical variation, the simulation results reported in our paper are averaged over four evaluation runs with different random seeds. We agree that reporting the mean alone does not rule out evaluation noise, particularly when differences are small.

Comments on the paper

1 comment

We sincerely thank the AC and reviewers for their constructive feedback on QCache-VLA. The discussions have helped us clarify our contributions and strengthen the experimental evidence. We summarize the main contributions and key additional results below.

We propose QCache-VLA, a training-free framework for efficient Vision-Language-Action (VLA) inference, addressing both image-text modality discrepancies in the VLM backbone and non-uniform redundancy across diffusion steps. Our framework combines action-aware post-training quantization, residual-calibrated diffusion caching, and optimized INT8 Triton execution. Experiments on RoboTwin, LIBERO, and real-world robotic tasks demonstrate substantial acceleration while preserving competitive task performance.

In response to the reviewers' concerns, we conducted additional controlled experiments:

  • Independent contribution of residual calibration and dynamic gating: Reviewers (GKU5, ujSu, Unx3) questioned the effectiveness of dynamic gating under the default threshold δ = 1.0, where only the first and final denoising steps are fully computed. We clarify that residual calibration is primarily responsible for preserving performance under this aggressive setting, while dynamic gating adjusts the computation budget at other thresholds (Table R1). To isolate residual calibration, we conducted a strict α-only ablation with identical computation schedules and cache operations. As shown in Table R8, residual rescaling improves success by 5.3 and 2.3 percentage points on RoboTwin Easy and Hard, respectively. On GR00T N1.7, it further improves average success by 1.0 point (Table R2), confirming its independent contribution across architectures.

  • Fair caching comparisons and architectural generality: To eliminate quantization-related confounding, we evaluated different caching methods under identical full-precision and W8A8 settings. We also extended our evaluation to GR00T N1.7, which uses a different action-expert architecture and a four-step denoising schedule. Under full precision, QCache-VLA achieves 93.60% average success with only two full expert evaluations, outperforming DiCache (92.25%) and EfficientVLA (92.35%). Under unified W8A8 quantization, QCache-VLA maintains 93.10% success (Table R2). These results strengthen the evidence for effective cache reuse across different VLA architectures.

  • Effectiveness of action-aware quantization: To isolate the proposed selection objective, we compared it with conventional Block MSE and MAE criteria using the same smoothing candidates. As shown in Table R4, our action-aware criterion reduces final-action MSE by 8.68% and MAE by 5.57% compared with Block MSE, while improving LIBERO-Long success from 91.8% to 92.4%. We also added comparisons with the VLA-specific quantization method QVLA. Under identical caching strategies on GR00T N1.7, our quantization improves success by 1.65 points with DiCache and 0.70 points with EfficientVLA (Table R2).

  • Practical INT8 deployment and fair efficiency comparisons: We clarified that the original simulation results use fake quantization, whereas the real-world experiments use the actual INT8 Triton backend. Additional closed-loop evaluation confirms that actual INT8 execution achieves 96.5% average LIBERO success, closely matching fake quantization (96.6%) (Table R6). We further benchmarked all caching methods using the same optimized W8A8 Triton backend. At approximately two full expert evaluations, QCache-VLA achieves 37.76 ms, compared with 38.18 ms for DiCache and 40.32 ms for EfficientVLA (Table R7). Additionally, an FP16 + Triton control confirms that INT8 reduces peak allocated memory from 6.27 GiB to 4.35 GiB under the same runtime (Table R3), clarifying the respective contributions of quantization and backend optimization.

Overall, these additional experiments provide stronger evidence for the independent effectiveness of action-aware quantization and residual-calibrated caching, while addressing concerns regarding comparison fairness, architectural generality, and practical deployment. We have incorporated the corresponding clarifications and experimental results into the revised manuscript and appendix.

We sincerely thank the AC and reviewers again for their valuable feedback. Please refer to our individual responses for further details.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.