acceptodds
Under review as a conference paper at ICLR 2027

CRAFT: Coupled Rotation-Aware Action-Field Caching and Two-Bit Quantization for Vision-Language-Action Models

Abstract

Diffusion and flow-matching vision-language-action (VLA) policies incur substantial weight traffic through repeated action-head evaluations. Prior VLA quantization typically retains head weights at W4 or higher, while scalar W2 can severely degrade task success. Adaptive caching introduces per-step decision overhead that can offset savings on short trajectories (), despite often selecting identical evaluation steps. We introduce Coupled Rotation-Aware Action-Field Caching and Two-Bit Quantization (CRAFT), a training-free framework that jointly reduces action-head precision and evaluation frequency. Motivated by scalar-W2 error concentration in a few high-activation-energy directions, CRAFT quantizes the head to W2A4 using lattice codewords. It selects modules for rotation before deployment using the original weights' tail statistics and reuses the latest predicted field at fixed steps, skipping head evaluation while continuing solver-state updates. With a W4 backbone, W2A4 head, and caching, CRAFT achieves LIBERO-Object success rates of 98.4% and 97.8% on GR00T N1.5 and (FP16: 96.4% and 98.0%). Batch-1 end-to-end speedups on RTX 3090 reach and , respectively, versus and for the fastest prior methods. On GR00T N1.5, nominal weight traffic decreases by 79.6% relative to FP16 and by a factor of 2.1-3.2 relative to prior methods. Head-only W2A4 quantization achieves 80.45% average success across eight models, exceeding the strongest matched-precision baseline by 15.3 percentage points.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Vision-language-action models, efficient robotic inference, post-training quantization, extreme-low-bit quantization, predicted-field caching, training-free acceleration

Reviews

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

This paper proposes CRAFT, a training-free method for compressing diffusion/flow-matching VLAs, with a focus on the action head. Because the action head is evaluated to generate each action chunk, it can account for a large share of the weight traffic under single-sample closed-loop inference. CRAFT therefore reduces both the precision and the evaluation count of the action head. It combines W2A4 quantization using an 8-dimensional E8-lattice codebook, and static caching that evaluates the head only at fixed compute nodes and reuses the last predicted field while still updating the solver state at every step.

Critical strengths

The paper offers useful analytical insights into compressing diffusion-head VLAs.

  • The weight traffic and latency of the diffusion head, which grow with the number of denoising steps
  • The concentration of W2 output error in a few high-energy directions
  • The model-dependent weight tails that determine whether rotation helps
Critical weaknesses

The novelty of this paper is limited. Apart from Tail-guided rotation, the components of the method appear to be drawn from prior work: block rotation from DuQuant, step-wise activation scales from HoloQ-VLA, and fixed-interval caching all existed before this work.

The "matched W2A4" comparison is not matched in bits. The action head in CRAFT uses 3.14 bpw. This is a measured value that includes rotation matrices (0.997 bpw) and activation tables (0.126 bpw). The scalar baselines (QuantVLA-style, PTQ4DiT, TFMQ-DM) are reported at 2.25 bpw, a nominal value that excludes such overhead. CRAFT therefore uses roughly 0.9 more bits per weight than the baselines it is compared against.

Questions for authors

Q1. With caching, the action head is evaluated only twice per action chunk (NFE = 2), so the backbone dominates the weight traffic. In this setting, lowering the head precision from W4 to W2 reduces nominal weight traffic by only 0.21 GiB on GR00T N1.5 (2.64 -> 2.43 GiB, Table 1). What is the measured end-to-end latency difference between CRAFT and CRAFT (W4 head)?

Q2. Under the full CRAFT configuration, the success rate drops sharply relative to FP16 on π0 (98.4 ->24.0) and CogACT (72.1 -> 37.5), while π0.5 is barely affected. What causes these failures?

Q3. The static schedule appears to be motivated by the observation that existing adaptive methods (TeaCache, MagCache) mostly select a single step set (Table 11). I may have misunderstood this, so if any part of the schedule was newly designed for the characteristics of diffusion or flow-matching heads in VLAs, could the authors clarify it?

Q4. The compute-node sets differ across models ({0}, {0, 2}, {0, 4}, {0, 5}, {0, 3, 7}). What criterion and data were used to choose them? In particular, was performance on the LIBERO-Object task suite, which is also used for evaluation, used in the selection?

Q5. Adding A4 quantization raises the average success rate from 92.20 to 95.90 (Table 2), exceeding FP16 (94.00, Table 10) on all four suites. CRAFT also exceeds FP16 on GR00T N1.5 (98.4 vs. 96.4, Table 1). Could the authors report results over multiple seeds with confidence intervals?

Q6. According to Appendix D.6, rotation matrices account for about 1 bpw (0.997) of the 3.14 bpw used by the head. Why did the authors choose a stored block rotation over a Hadamard rotation, which requires no storage?

5 comments

Response to Reviewer aeLW (1/3):\textbf{Response to Reviewer aeLW (1/3):} What is new, and are the bits compared fairly?

We thank the reviewer for the careful reading and valuable feedback. Our responses follow; shared points are in the General Responses.

Response to concern 1 (W1)

Are CRAFT's components only drawn from prior work? A test against a head assembled from them

The reviewer attributes block rotation to DuQuant, step-wise activation scales to HoloQ-VLA and fixed-interval caching to prior work. We agree that these primitives are established, and that quantization and caching have been combined before (CacheQuant); we claim novelty neither in them nor in the identities of manuscript Propositions 1 and 4.

The question specific to CRAFT is whether head precision and action-field reuse can be designed independently in a closed-loop VLA policy — the subject of manuscript Section 3, which guides CRAFT's design (manuscript Section 4). Two measurements show what the analysis adds.

(1) Quantization and caching are not additive. If they were, the extra loss caching causes relative to FP16 would not depend on head precision.

  • CogACT: a closed-loop factorial test rejects this: the quantization–caching interaction is −22.1 pp with a W2 head and −7.5 pp with a W4 head, a difference of +14.6 pp [+5.8, +23.3] (paired bootstrap; Table R6).
  • InternVLA-M1: it recurs on a second high-gain head examined afterwards (−68.8 vs. −26.6 pp; General Response 2/2).
  • Implication: this difference-in-differences effect is invisible to quantization-only or caching-only evaluations.

(2) The error and execution analyses lead to measurable choices.

  • Lattice rounding: the output-error analysis (manuscript Proposition 1) motivates H-weighted lattice rounding: with the rotation fixed, it raises GR00T N1.5 from 89.00 to 92.20 over scalar rounding (W2A16, four suites).
  • vs. assembled components: against the closest existing combination, HoloQ-VLA‡ (block rotation, step-wise scales, scalar rounding), CRAFT's head averages 80.45 vs. 56.66 over eight models.
  • Selective rotation: the tail analysis supports selective rather than unconditional rotation (rotating every head costs 10.4 pp on CogACT).
  • Fixed nodes: the short-trajectory measurements motivate fixed nodes over per-step gating (up to 7.1 ms per call, no success gain detected at NFE 2).

CRAFT is therefore an empirically grounded quantization–execution co-design‾\underline{\textbf{an empirically grounded quantization–execution co-design}} whose decisions follow from measured interactions, not a new quantizer or caching primitive.

Response to concern 2 (W2)

Is the W2A4 comparison matched in bits? A measurement under one accounting

The reviewer notes that CRAFT's 3.14 bpw is measured, including rotation and activation tables, whereas the baselines' 2.25 bpw is nominal.

  • In the manuscript: in Table 1, bpw was measured from the serialized head file where one existed (CRAFT) and marked † as nominal where it did not.
  • What a fair comparison needs: it must separate matched quantization precision from matched serialized storage: a stored rotation raises a W2 head's measured bpw although its codes stay two-bit.
  • New measurement: we measured every head of every model under one accounting (codes, scales, rotation, activation tables, container):

Table R11:\textbf{Table R11:} measured head storage (bpw), eight heads.

PTQ4DiTTFMQ-DMQuantVLA‡CRAFT, rotation-free heads (XR-0, π0, CogACT, SmolVLA)CRAFT, rotated heads (X-VLA, GR00T N1.5/N1.7, π0.5)
2.03–2.152.07–2.352.16–2.272.10–2.373.08–3.66

CRAFT's extra storage is the rotation, present only on the four heads with Drot>1D_{\mathrm{rot}} > 1.

  • Rotation-free heads, storage: CRAFT is within 0.31 bpw of every baseline on the same model (largest gap: SmolVLA, 2.37 vs. 2.06).
  • Rotation-free heads, accuracy: it still reaches 65.0 / 19.4 / 65.8 on SmolVLA / π0 / CogACT against 0.0 / 0.0 / 0.0 for TFMQ-DM; without rotation on any head (manuscript Table 5, "None"), CRAFT averages 80.00 against 65.15 for the strongest baseline.
  • Rotated heads: we count the rotation explicitly (3.08–3.66 bpw) rather than treat nominal W2 as equal storage.

Table R11 will be added per model to the revised manuscript.

Response to Reviewer aeLW (2/3):\textbf{Response to Reviewer aeLW (2/3):} What does the W2 head contribute to latency, and how were the schedules chosen?

Response to concern 3 (Q1)

What is the measured latency of the W2 head versus a W4 head? A component-wise timing

The reviewer observes that at NFE = 2 the backbone dominates weight traffic, so lowering the head from W4 to W2 saves only 0.21 GiB nominally. Our measurement agrees: at NFE 2 head precision barely changes end-to-end latency.

  • Latency: on GR00T N1.5 (same FP16 backbone, caching {0, 4}, RTX 4090), CRAFT runs at 1.46× with the W2 head and 1.44× with the W4 lattice head, and on CogACT at 1.117× and 1.115×.
  • Success: the same manuscript Table 1 success on GR00T N1.5 (98.4 for both).
  • What the W2 head buys: storage (3.14 vs. 5.14 bpw); its lower traffic is nominal, since the kernel expands W2 codes to INT4 operands at load time.

To show where the speedup does come from, Table R13 adds one component at a time:

Table R13:\textbf{Table R13:} policy-call time, one component at a time (ms; RTX 4090, exclusive; instrumented capture).

Model (backbone, head)FP16+ caching+ integer backbone, FP16 head+ CRAFT head
GR00T N1.5 (W4A8, W2A4)51.7935.6729.2429.77
π0.5 (W4A8, W2A4)71.5947.2431.8632.35
  • Caching: saves 16.12 / 24.35 ms.
  • Integer backbone: saves a further 6.43 / 15.38 ms.
  • CRAFT head: adds 0.53 / 0.49 ms.

(GR00T N1.5 / π0.5; end to end 1.74× / 2.21×, within 1 % of Table G1.) The speedup thus comes from caching and the integer backbone‾\underline{\textbf{The speedup thus comes from caching and the integer backbone}}, and the W2 head contributes storage while preserving success.

A natural follow-up is whether a simpler integer W4 head would be faster; Table R14 compares CRAFT with an RTN W4A4 head on the same INT4 GEMM, in one process and capture per backbone column (caching {0, 4}): Table R14:\textbf{Table R14:} CRAFT's W2A4 lattice head vs. an RTN W4A4 head — GR00T N1.5, RTX 4090 (speedup vs. uncached FP16).

HeadSpeedup, W4A4 backboneSpeedup, W4A8 backboneSuccess (W4A4 backbone)
RTN W4A41.98×1.92×59.2
CRAFT W2A4 lattice1.84×1.79×95.64 (5 runs; FP16 96.07)

RTN: per-column round-to-nearest W4 weights and calibrated A4 scales, without rotation or error compensation — the simplest integer W4A4 head, not a tuned W4 method.

  • Result: the RTN W4 head is 7–8 % faster but loses 36 pp.
  • Caveat: this compares two implementations with method-specific pre- and post-processing and does not imply that lowering precision from W4 to W2 improves accuracy; with a stronger W4 quantizer the gap closes (manuscript Table 1, GR00T N1.5: HoloQ-VLA W4A4 and CRAFT W4 stay near FP16).

Response to concern 4 (Q2)

Why do π0 and CogACT fail while π0.5 does not?

The causes differ (General Response 1/2; responses to mBz2):

  • π0: W2 weight precision is a major factor: with A8 activations fixed, W3 weights restore success from 26.4 to 96.8 on all ten tasks.
  • CogACT: it is the interaction with reuse: its DDIM ε-prediction solver has a high gain on a reused-field error (3.00), and a W4 head reduces the quantization–reuse interaction from −22.1 to −7.5 pp.
  • π0.5: it shows neither: its head-only W2 equals FP16 (98.0).

Response to concern 5 (Q3)

Is anything in the schedule specific to VLA heads?

Yes. The predicted field drifts less than the solver state on six of eight models (manuscript Figure 5), so CRAFT reuses the field while the solver state continues to update at every original step using the most recently evaluated field; the schedule fixes only the steps at which the field is evaluated.

Response to concern 6 (Q4)

What criterion and data chose the node sets?

  • Data: LIBERO-Object (initial states 40–49 for GR00T N1.5).
  • Criterion: the candidates' closed-loop success in this short screen. The sets were fixed before the reported evaluations but not independently of closed-loop results.
  • Later changes: π0.5's set was changed from {0, 6, 9} to {0, 5} after closed-loop results, and the common rule C={0,⌊T/2⌋}C = \lbrace 0, \lfloor T/2 \rfloor \rbrace was written afterwards and serves only as a sensitivity check.
  • CogACT: its three-node schedule was chosen on its SimplerEnv window and checked on held-out tasks.

On the checks we ran, the choice did not change the conclusions:

  • π0.5, unused suites: {0, 5} is +0.8 / −1.2 / +0.6 pp from uncached FP16 on LIBERO-Spatial / Goal / Long and within 1.0 pp on five LIBERO-Plus axes.
  • Elsewhere: Table R7 (response to mBz2) shows limited sensitivity (SmolVLA: 4–5 pp lower under the common rule).

Tables R13–R14 and this procedure will be added to the revised manuscript.

Response to Reviewer aeLW (3/3):\textbf{Response to Reviewer aeLW (3/3):} Do the accuracy claims hold across runs, and why a stored rotation?

Response to concern 7 (Q5)

Do the results over FP16 hold across repeated runs? A repeated-run test with confidence intervals

The reviewer notes that CRAFT exceeds FP16 on GR00T N1.5 (98.4 vs. 96.4) and that A4 activations raise success above FP16 (manuscript Table 2), and asks for repeated runs with confidence intervals.

  • In the manuscript: each entry of manuscript Tables 1–2 is a single run of 500 episodes (240 for CogACT), treated as independent Bernoulli trials (manuscript Assumption 7).
  • Test: if these differences were run-to-run noise, they should not persist across repetitions.
  • Protocol: we repeated FP16 and CRAFT as independent rollouts (n = 500 each, unseeded noise, one RTX 4090 machine) and report pooled intervals and run- and task-level bootstrap intervals.

Table R15:\textbf{Table R15:} GR00T N1.5, LIBERO-Object — independent runs.

SettingRunsPooledvs. FP16 [95 % CI]Run- and task-level bootstrap
FP1695.6 / 94.8 / 97.896.07——
CRAFT (fake quantization)98.6 / 98.4 / 98.298.40+2.33 pp [+1.17, +3.56][+0.20, +4.60]
CRAFT, deployment kernels98.0 / 97.6 / 97.497.67+1.60 pp [+0.35, +2.88][−0.73, +3.93]
W4A8-backbone configuration, deployment kernels98.0 / 98.2 / 98.098.07+2.00 pp [+0.80, +3.25][−0.27, +4.33]
  • Pooled: across the three runs CRAFT's observed range is 0.4 pp against 3.0 pp for FP16 (a descriptive range, not a variance test), and every pooled difference is positive.
  • Run and task level: the intervals of the two deployment configurations include zero, so we state no statistically significant difference from FP16‾\underline{\textbf{no statistically significant difference from FP16}} and do not read it as equivalence or superiority.
  • Original single-run H100 entries: McNemar tests with Holm correction likewise detect no significant difference.

Repeating manuscript Table 2 in the same way tests the A4 effect:

Table R16:\textbf{Table R16:} W2 vs. W2A4 head — three runs per arm (n = 1,500 per arm, RTX 4090).

SuiteW2A4W2 (A16 activations)Difference [95 % CI]Run- and task-level bootstrap
Long91.2786.47+4.80 [+2.55, +7.06][−0.87, +10.87]
Spatial96.4789.20+7.27 [+5.45, +9.13][+3.67, +11.00]
Goal96.9395.80+1.13 [−0.21, +2.50][−1.27, +3.67]
Object98.2098.00+0.20 [−0.80, +1.21][−1.40, +1.80]
  • LIBERO-Spatial: step-wise A4 activations yield a supported +7.27 pp‾\underline{\textbf{a supported +7.27 pp}} under both kinds of interval.
  • Other three suites: no significant difference; on LIBERO-Long, FP16 in these runs reaches 91.27 (W2A4 − FP16 +0.00 pp [−2.03, +2.03]).
  • Revision: it replaces "at or above FP16" with "no statistically significant difference from FP16" and reports manuscript Table 2 with these runs and both intervals.

These repeated runs support the A4 improvement on LIBERO-Spatial; the other comparisons carry no claim of significant superiority.

Response to concern 8 (Q6)

Why a stored rotation rather than a storage-free Hadamard? A direct replacement test

  • Already in CRAFT: a storage-free randomized Hadamard is applied to every head (incoherence processing, 0.0155 bpw, manuscript Appendix D.6).
  • Why a stored rotation on top: the stored block rotation is added only where Drot>1D_{\mathrm{rot}} > 1, because rotation shrinks heavy weight tails but enlarges light ones (manuscript Section 3.1).

We tested the reviewer's alternative in its place:

Table R12:\textbf{Table R12:} storage-free Hadamard vs. stored block rotation — W2A4 head (success %, n = 500 per run).

ModelStorage-free HadamardStored block rotation
GR00T N1.5, head-only (n = 1,500)98.47 (2.14 bpw)98.27 (3.14 bpw)
GR00T N1.5, full configuration97.698.4 (n = 1,500)
GR00T N1.798.498.2
X-VLA99.099.2
π0.598.099.6
VLA-JEPA (SimplerEnv, n = 828)64.4 (2.17 bpw)68.2 (4.10 bpw)
  • Matches: the storage-free Hadamard matches the stored rotation on GR00T N1.5, GR00T N1.7 and X-VLA at about 1 bpw less (full GR00T N1.5 configuration: −0.8 pp [−2.6, +0.5]).
  • Falls behind: on π0.5 and VLA-JEPA.
  • Decision: we retain the tail-guided stored rotation as the default, since it is never more than 0.2 pp worse in the head-only comparisons and gains more on π0.5 and VLA-JEPA, and we report the storage-free variant as an alternative.

Again, we sincerely thank the reviewer for the constructive feedback. If you feel your concerns have been addressed, we would be grateful if you could reconsider the rating.

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

In VLA models, the action head may execute multiple times for a single decision, leading to significant overhead. The authors observe that while the ViT and LLM components might run only once, the action head may need to run 4–10 times to generate action segments incrementally, resulting in substantial computational costs. To address this, the authors propose CRAFFT, which reduces weight storage overhead by quantizing the backbone weights to 4-bit and the action head to W2A4, while employing selective rotation to manage quantization errors. Furthermore, by pre-calculating and fixing the number of computation steps for each action head, this method can reuse the most recent prediction results, thereby effectively reducing the number of times each action head actually performs computations.

Critical strengths

To address the inference overhead incurred by the repeated execution of action heads in Vision-Language-Action models, this paper proposes a joint approach to reduce both weight bit-width and the number of invocations. By analyzing the output errors resulting from low-bit quantization alongside the characteristics of the less significant components of the weights, the authors develop strategies for error redistribution and selective rotation. Furthermore, the method employs a fixed number of computational steps while continuously updating the action state through the reuse of previously predicted results, thereby lowering the costs associated with action-head computation and real-time decision-making. Through extensive experiments, the paper evaluates the contributions of individual components and the applicability of the proposed method across various settings. It also provides empirical data across multiple hardware platforms including timing measurements for policy invocations and a breakdown of computational costs, offering a solid experimental basis for assessing the operational efficiency of the approach.

Critical weaknesses

① The CRAFT method causes severe task degradation in certain models, raising concerns regarding its generalizability across different architectures. As shown in Table 1, the full CRAFT configuration leads to a near-total collapse in the performance of π₀ and CogACT. While other models perform better and the CRAFT (W4 head) variant mitigates this degradation, the success rates for π₀ and CogACT still suffer significant declines. Furthermore, the table fails to indicate the level of acceleration achieved alongside such substantial drops in success rates. ② The success rates and acceleration results have not been jointly validated under consistent deployment configurations. Appendix C.2 explicitly states that accuracy evaluations utilize a W4 weight-only backbone, whereas the RTX latency tests employ RTN W4 weights and A4 activations. Consequently, it is questionable whether the reported success rates and speedups correspond to the same deployment configuration.

Questions for authors

① In Table 1, CRAFT does not perform well across all models; for instance, it leads to significant performance drops for π₀ and CogACT. This indicates a lack of generalizability, which is a major issue. ② Table 1 mixes comparisons based on original precision, uniform bit-width, caching methods, and various ablation studies, making it difficult to interpret. I suggest restructuring the table to allow for a more intuitive comparison of success rates versus overhead across different methods. ③ In Appendix C.2, the accuracy experiments and speed benchmarks utilize different quantization configurations. For example, the accuracy experiments employ W4 weight quantization for the backbone, while the speed benchmarks use W4A4. These results do not sufficiently demonstrate that a single, unified deployment configuration can simultaneously achieve the accuracy and efficiency gains reported in the paper; additional data on success rates and latency under consistent settings are required.

14 comments

Response to Reviewer uuTH (1/2):\textbf{Response to Reviewer uuTH (1/2):} Does one executable configuration deliver both success and speedup?

We thank the reviewer for the careful reading and valuable feedback. Our responses follow; shared points are in the General Responses.

Response to concern 1 (W②/Q③)

Do the reported success and speedup come from one deployment configuration? A joint measurement

The reviewer notes that manuscript Appendix C.2 evaluates success with a weight-only W4 backbone but measures latency with RTN W4A4, so the reported success and speedup may not correspond to one configuration.

  • Why they were separate: the action head, which runs at every denoising step, is where CRAFT's contribution lies, while the backbone runs once per call and received standard quantization (General Response 1/2).
  • Why it matters: this question decides whether the accuracy–efficiency trade-off is real.
  • New measurement: we implemented the full deployment path and measured success and latency with the same quantized artifacts and integer kernels (Table G1):
ModelSuccess (FP16)RTX 4090RTX 3090
GR00T N1.598.07 (96.07)1.76×1.88×
π0.598.3 (99.2; same caching 98.8)2.22×2.36×
π098.2 (96.8)2.14×2.41×
CogACT70.4 (68.3)2.47×3.11×
  • One configuration: for each of the four configurations, success and speedup were measured with the same deployed artifacts and kernel path‾\underline{\textbf{the same deployed artifacts and kernel path}}, removing the original need to combine an accuracy-only setup with a different latency-only setup.
  • Success: none is significantly below FP16 on the same device (π0.5, π0 and CogACT: both measured on the RTX 3090).
  • Manuscript Table 1 configuration: it also transfers: on the kernels it reaches 97.67, with no significant difference from fake quantization, at 1.41×; it is the memory configuration (4× smaller backbone), whose speed comes from caching.

The abstract and manuscript Section 5.4 will name the configuration of every quoted speedup.

Response to concern 2 (W①/Q①)

What speedup accompanies the π0 and CogACT results? Recovery measured with its speedup

The reviewer notes that manuscript Table 1 does not show the acceleration achieved alongside the π0 and CogACT drops. These drops are not specific to CRAFT:

  • Closed loop: at the same W2A4 precision every baseline of manuscript Table 1 collapses further (π0: ≤ 12.8 vs. 19.4; CogACT: ≤ 42.9 vs. 65.8).
  • Local error: every other quantizer leaves 9.8–58× more W2 output error than CRAFT on these heads (Table R3, response to mBz2).

Controlled experiments identify a configuration that recovers each model; Table R8b reports each recovery together with its measured speedup.

Table R8b:\textbf{Table R8b:} recommended π0 and CogACT configurations — deployment kernels (success on RTX 3090; speedups on RTX 4090).

Model, benchmarkCRAFTFP16 uncached (cached)Δ [95 % CI]SpeedupCaching alone
π0, LIBERO-Object98.296.8 (96.8)+1.4 [−0.6, +3.5]2.14×1.51×
CogACT, SimplerEnv window (n = 240)70.468.3 (67.9)+2.1 [−6.1, +10.3]2.47×1.10×
CogACT, four held-out tasks86.7— (91.1)−4.4 [−11.7, +2.6]

Each recovery keeps a speedup well above caching alone‾\underline{\textbf{Each recovery keeps a speedup well above caching alone}} (RTX 4090: 2.14× vs. 1.51×; 2.47× vs. 1.10×).

  • π0: a W3/A8 head, a W4A8 backbone and caching {0, 5}; with the same caching it reaches 98.8 vs. 97.4 on Spatial, 94.2 vs. 94.2 on Goal and 71.0 vs. 78.2 on Long.
  • CogACT: its language backbone (LLaMA-2 7B) runs as a compute-bound prefill, so its speed requires integer activations: W4A8 vision encoders, a W4A4 language backbone (GPTQ, Hadamard rotation, per-token A4), a W4 head and caching {0, 3, 6}, chosen on the window.
  • CogACT variants: with the submission's two nodes it reaches 62.1 at 2.57×, and with FP16 vision encoders 69.2 at 2.40×.

The revised manuscript Table 1 will carry the measured speedup of every configuration for which deployment kernels exist, so that each success rate is read next to what it buys.

Response to Reviewer uuTH (2/2):\textbf{Response to Reviewer uuTH (2/2):} How does CRAFT compare at matched budgets, including its overhead?

Response to concern 3 (Q②)

Can manuscript Table 1 compare success against cost directly? A restructuring by comparison budget

Manuscript Table 1 placed the full configuration next to the controls that isolate head quantization, backbone quantization and caching (manuscript Section 5.2), but we acknowledge that this mixes comparison budgets. We will restructure it as success versus cost:

  • Blocks: one block per budget.
  • Columns: head bpw, NFE, nominal weight traffic and measured speedup next to success.
  • Ablations: moved to a separate table.

Table R9 previews the strongest method of each block.

Table R9:\textbf{Table R9:} success versus cost, condensed (success from manuscript Table 1).

BlockMethodHead bpwNFENominal traffic (GiB)Mean SR, 6 models†Mean SR, 8 models
ReferenceFP1616811.9093.3091.29
Higher head precisionHoloQ-VLA, head only5.3886.7092.0389.75
Matched W2A4 precisionQuantVLA‡ (strongest baseline)2.16–2.2785.8381.4765.15
CRAFT, head only3.14 (2.10–2.37 without rotation)85.8393.0780.45
CachingMagCache1636.6993.7391.28
BothCRAFT3.1422.4392.4377.01

† Excluding π0 and CogACT. NFE and traffic for GR00T N1.5; traffic is nominal (bit widths × evaluation counts; rotation not counted; the RTX kernels expand lattice codes to INT4 at load time, manuscript Appendix C.2).

Read by budget:

  • Same W2A4 head precision: CRAFT has the highest mean success‾\underline{\textbf{the highest mean success}} (80.45 vs. at most 65.15).
  • Lowest nominal traffic: at 2.43 GiB (4.9× below FP16), its six-model mean is 0.87 pp below FP16 (individual differences up to −7.8 pp, SmolVLA).

Where does each method's overhead come from? A kernel-level breakdown

  • Caching: TeaCache adds +2.77 to +4.07 ms per call and AdaptiveDiffusion up to +3.51 ms on an RTX 4090 (up to 7.1 ms on an RTX 3090; MagCache ≈ 0; manuscript Tables 11–12), whereas CRAFT's static schedule makes no runtime decision.
  • Quantized heads: we profiled each W2A4 head by kernel in one deployed GR00T N1.5 stack (RTX 4090):

Table R9b:\textbf{Table R9b:} one head evaluation by kernel category, and the whole policy call (ms).

HeadAct. quant., transforms, epilogueGEMMOtherTotalPolicy call, NFE 2
QuantVLA‡0.834.940.646.3444.07
PTQ4DiT0.590.900.642.0935.47
CRAFT1.430.900.652.9437.11
  • GEMM: on the quantized layers, CRAFT's integer GEMM costs the same as PTQ4DiT's (0.656 vs. 0.655 ms).
  • Extra kernels: its activation-quantization, transform and epilogue kernels take 0.84 ms more per evaluation.
  • Whole call: 1.64 ms longer (37.11 vs. 35.47 ms) — less than TeaCache's decision cost on the same model and GPU (+4.07 ms).

To see whether this cost pays off, we ran each head through its own executable path in the same stack (W4A16 backbone, caching {0, 4}):

Table R10:\textbf{Table R10:} W2A4 heads in one deployed stack (success %, n = 400–500 per cell).

Head (kernel path)ObjectCameraLightLayoutTableMean
PTQ4DiT (INT4×INT4 GEMM)64.4022.7562.0037.4762.7549.87
QuantVLA‡ (W2 weights, A4 codes, FP16 GEMM)98.6073.25‾\underline{73.25}97.7570.22‾\underline{70.22}99.00‾\underline{99.00}87.76‾\underline{87.76}
CRAFT (INT4 lattice GEMM)97.67‾\underline{97.67}81.1297.7571.2299.5089.45
  • vs. PTQ4DiT: the faster head is 33–58 pp lower.
  • vs. QuantVLA‡: CRAFT is 7.9 pp higher under camera shift ([2.9, 13.1], paired p = 3×10⁻⁴), with no significant difference on the other four settings.
  • Caveat: kernel paths differ, so Table R10 compares success, not equal-cost compute.

Within the W2A4 budget, CRAFT therefore has the highest mean success‾\underline{\textbf{the highest mean success}}, with fake quantization and in the deployed stack, at a small fixed overhead.

Again, we sincerely thank the reviewer for the constructive feedback. If you feel your concerns have been addressed, we would be grateful if you could reconsider the rating.

Additional result for Reviewer uuTH:\textbf{Additional result for Reviewer uuTH:} success versus overhead, kernel by kernel

We thank the reviewer again and add a new result for question ②.

Response to concern 3 (Q②), continued

How does success compare against overhead across methods? A kernel-level breakdown of one policy call

The reviewer asked for a direct comparison of success rates against overhead across methods. We compare CRAFT with the strongest matched-precision baseline in success (QuantVLA‡) and the W2A4 baseline with an integer kernel (PTQ4DiT; TFMQ-DM shares its kernel path). Table R17 splits one policy call of each W2A4 head into its parts.

Table R17:\textbf{Table R17:} one policy call of each W2A4 head in one deployed GR00T N1.5 stack (W4A16 backbone, caching {0, 4}, two head evaluations per call, RTX 4090; ms, share of the call in parentheses).

W2A4 headBackbone + restAct. QTransf.GEMM (Q)GEMM (FP16)Epil.OtherHeadCallSR (%)SR / call ↑
PTQ4DiT (INT4)31.290.41 (1.2)–1.31 (3.7)0.49 (1.4)0.76 (2.2)1.28 (3.6)4.18 (11.8)35.4749.871.41
QuantVLA‡ (FP16 GEMM)31.390.54 (1.2)–9.37 (21.3)0.51 (1.2)1.11 (2.5)1.27 (2.9)12.68 (28.8)44.0787.76‾\underline{87.76}1.99‾\underline{1.99}
CRAFT (INT4 lattice)31.230.38† (1.0)1.91 (5.1)1.31 (3.5)0.50 (1.3)0.57† (1.5)1.29 (3.5)5.88(15.8)‾\underline{5.88 (15.8)}37.11‾\underline{37.11}89.452.41

† Fused with the input and output transforms. GEMM (Q) / (FP16): quantized / unquantized layers. Head parts are per-evaluation kernel-time medians, times two; Backbone + rest is Call minus Head. SR: mean over the five settings of Table R10; SR / call in %/ms.

  • Backbone: the backbone and the rest of the call take the same 31.2–31.4 ms for all three heads, so the differences come from the head alone.
  • QuantVLA‡: QuantVLA reports memory savings without an integer kernel, and its activation scales vary across input channels, i.e., along the reduction dimension of the GEMM. An integer GEMM can apply only per-token and per-output-channel scales after accumulation, and folding the input-channel scales into the weights would change the W2 codes. QuantVLA‡ therefore runs its quantized layers as an FP16 GEMM, which takes 21.3 % of the call (9.37 vs. 1.31 ms on the INT4 path).
  • PTQ4DiT: it runs the same INT4 GEMM as CRAFT on the quantized layers (0.655 vs. 0.656 ms per evaluation) and is the fastest, but 39.6 pp lower in success.
  • CRAFT: it has the highest success per unit latency‾\underline{\textbf{the highest success per unit latency}} (2.41 vs. 1.99 and 1.41 %/ms).

We hope this result addresses the reviewer's concerns, and we would be grateful if the reviewer could consider updating the rating.

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

This paper proposes CRAFT, a training-free framework combining 2-bit action-head quantization with static action-field caching for efficient VLA inference. The method uses activation-aware lattice quantization, selective rotation, and fixed denoising-step reuse. Experiments across eight VLA models demonstrate substantial speedups while maintaining competitive task success on several architectures.

Critical strengths
  • The paper addresses an important efficiency bottleneck in diffusion-based VLA models. Jointly reducing action-head precision and evaluation frequency is well motivated.

  • The experimental evaluation is extensive, covering eight VLA models, multiple simulation benchmarks, and several hardware platforms.

  • The ablation studies provide useful insights into quantization error, rotation strategies, and caching overhead. The reported end-to-end speedups are encouraging.

Critical weaknesses
  • The core components, including lattice quantization, rotation, and timestep caching, largely build on existing techniques. The main contribution is their integration and adaptation to VLA action heads.

  • CRAFT suffers substantial performance degradation on π0 (98.4% to 24.0%) and CogACT (72.1% to 37.5%). These failures raise concerns about the general applicability of the proposed W2A4 and caching configuration.

  • All task evaluations are simulation-based, with no real-robot experiments. Moreover, task success is evaluated using fake quantization, while the reported hardware speedups rely on a separate deployment implementation. The consistency between these settings requires further validation.

Questions for authors
  • What causes the severe performance degradation on π0 and CogACT? Could model-specific precision allocation address these failures?

  • How are the static caching schedules selected, and how sensitive are they to different tasks, action horizons, and environments?

  • Can the authors provide real-robot evaluations or closed-loop results using the actual deployment kernels to verify the reported accuracy-efficiency trade-off?

5 comments

Response to Reviewer mBz2 (1/3):\textbf{Response to Reviewer mBz2 (1/3):} Why do π0 and CogACT fail under the default W2 head?

We thank the reviewer for the careful reading and valuable feedback. Our responses follow; shared points are in the General Responses.

Response to concern 1 (W1)

Is CRAFT more than an integration of existing techniques?

We address this in General Response 2/2. In short, head precision changes the cost of reuse:

  • Interaction: on CogACT, caching costs a W2 head 22.1 pp more than FP16 but a W4 head only 7.5 pp more (Table R6).
  • Assembled components: a head assembled from existing components (HoloQ-VLA‡) averages 56.66 against 80.45 for CRAFT.

Response to concern 2 (W2/Q1)

What causes the degradation on π0 and CogACT? An output-error test and a precision-recovery test

The reviewer asks what causes the failures and whether model-specific precision allocation can address them. The manuscript applies one default head — W2A4, rotated by the tail rule — to all eight models without per-model tuning, and reports both failures in manuscript Table 1. We separate two questions:

  • (a) Local error: does CRAFT leave more local error than other quantizers on these heads?
  • (b) Remedy: what change is needed where even CRAFT's head fails?

By manuscript Proposition 1, the weight-error term of the output error is ∑kλk∥ΔWuk∥2\sum_k \lambda_k \lVert \Delta W u_k \rVert^2, so error along high-λk\lambda_k directions is fully expressed, and CRAFT's H-weighted lattice rounding (manuscript Section 4.1) targets exactly this term. Table R3 measures this error for every quantizer on the first attention projection of every head.

Table R3:\textbf{Table R3:} W2 relative output error tr(ΔWHΔW⊤)/tr(WHW⊤)\mathrm{tr}(\Delta W H \Delta W^\top)/\mathrm{tr}(W H W^\top) (%), weight-only.

HeadRTNGPTQAWQRot. + scalarQuantVLACRAFT
π014.286.70‾\underline{6.70}11.039.4813.960.248
CogACT17.628.54‾\underline{8.54}17.4017.3818.630.868
GR00T N1.510.747.378.835.89‾\underline{5.89}9.940.145
GR00T N1.77.273.38‾\underline{3.38}5.783.946.580.221
π0.50.4950.281‾\underline{0.281}0.4340.3330.5420.00715
SmolVLA68.606.6335.674.35‾\underline{4.35}44.430.174
X-VLA10.008.029.277.81‾\underline{7.81}9.420.472
XR-03.421.541‾\underline{1.541}3.301.541‾\underline{1.541}3.520.0385
  • (a) Local error: CRAFT leaves the least output error on both heads‾\underline{\textbf{CRAFT leaves the least output error on both heads}}: every other W2 quantizer leaves 27–58× more on π0 and 9.8–21× more on CogACT, including GPTQ, which also uses second-order information.
  • Closed loop: every W2A4 baseline of manuscript Table 1 collapses further (π0: ≤ 12.8 vs. 19.4; CogACT: ≤ 42.9 vs. 65.8).

Since local error alone does not set closed-loop success, we next located CRAFT's remaining loss on each model.

For π0, our hypothesis is that the W2 weights are the limiting factor. We test it by holding the A8 activations fixed and raising only the weights from W2 to W3:

Table R4:\textbf{Table R4:} π0, LIBERO-Object — head-only (RTX 3090, BF16 backbone, no caching, n = 500).

HeadSuccess
FP1696.8
W2 weights, A8 activations26.4
W3 weights, A8 activations96.8
  • (b) Remedy, π0: One more weight bit restores π0 to FP16‾\underline{\textbf{One more weight bit restores π0 to FP16}} (26.4 → 96.8, +70.4 pp [+65.9, +74.3]), identifying insufficient W2 weight precision as a major factor in π0's failure under A8 activations.
  • Answer to Q1: yes for π0 — the recommended W3/A8 head (about 3.2 bpw) still uses fewer head bits than every prior method that keeps π0 above 90 % (HoloQ-VLA W4, CacheQuant W8; Table R5).
  • CogACT: its failure has a different mechanism and is addressed in our next response.

Tables R3–R4 will be added to the revised manuscript.

Response to Reviewer mBz2 (2/3):\textbf{Response to Reviewer mBz2 (2/3):} Does model-specific precision recover success, and why does CogACT fail?

Response to concern 2 (W2/Q1) (continued)

Does the π0 recovery hold across suites and against prior methods?

A recovery on one suite could reflect suite-specific tuning, so we evaluated the W3/A8 head on all four LIBERO suites next to the prior methods that quantize π0's head. Rows come from three settings and are compared only within a block:

  • Manuscript: manuscript Table 1 and its Appendix grid (H100, GPU rendering).
  • Same lane: one lane where CRAFT's head and FP16 run together (H100, CPU rendering).
  • Deployed: the deployment kernels (RTX 3090, W4A8 backbone, caching {0, 5}).

Table R5:\textbf{Table R5:} π0, four LIBERO suites (success %, n = 500 per cell).

MethodHead W / A (bpw)ObjectSpatialGoalLong
FP16 (manuscript Table 1)1698.497.094.681.2
CacheQuantW8 / A8 (8.00)97.096.689.677.6
QuantVLA (original recipe)W4 / A8 (8.22)0.00.02.00.0
HoloQ-VLAW4 / A4 (5.38)95.895.675.640.6
PTQ4DiT / TFMQ-DMW2 / A40.0 / 0.06.8 / 0.02.8 / 5.80.0 / 0.0
Same lane: FP161696.896.693.280.4
Same lane: CRAFTW3 / A8 (3.2)98.297.495.070.4
Deployed: FP16, same caching1696.897.494.278.2
Deployed: CRAFTW3 / A898.298.894.271.0
  • Three of four suites: CRAFT’s W3/A8 head matches or exceeds the FP16 point estimate‾\underline{\textbf{CRAFT's W3/A8 head matches or exceeds the FP16 point estimate}} in both CRAFT blocks (no significant difference claimed).
  • Fewer head bits: it uses fewer head bits than every prior method that keeps π0 above 90 %: CacheQuant needs W8/A8, and HoloQ-VLA at W4/A4 falls to 75.6 and 40.6 on Goal and Long.
  • Equal head bits (W3A4): CRAFT reaches 87.4 against 31.0 for QuantVLA‡ (same RTX 3090 lane, earlier runs).
  • Remaining gap: on LIBERO-Long it stays lower: −10.0 pp [−14.0, −6.0] in the same lane and −7.2 pp deployed.

Why does CogACT fail? A factorial test of quantization–reuse interaction

CogACT's failure is not explained by head quantization alone: its head-only W2A4 success is 65.8, but full CRAFT falls to 37.5.

  • Mechanism (manuscript Proposition 4): the reused field carries the quantization error of the cached step, δk(t)\delta_k(t), which differs from the current-step error δt\delta_t, so the combined error is not the sum of the two, and CogACT's DDIM solver amplifies such errors (gain 3.00 vs. 0.50–1.00).
  • Prediction: if this interaction drives the failure, caching should cost a quantized head more than FP16, and a higher head precision should shrink that excess.
  • Test: SimplerEnv (the Google-robot window of manuscript Table 1: 4 tasks × 60 episodes) with FP16, W2 and W4 heads, each with and without caching {0, 4}, sharing the FP16 backbone, guidance 1.5, an RTX 3090 and the same 240 (task, initial state) pairs.

The interaction is I=[S(p,cache)−S(p)]−[S(FP16,cache)−S(FP16)]I = [S(p,\text{cache}) - S(p)] - [S(\text{FP16},\text{cache}) - S(\text{FP16})].

Table R6:\textbf{Table R6:} CogACT, SimplerEnv — success with and without caching {0, 4} (%, n = 240 per cell).

HeadNo cachingCaching {0, 4}ChangeInteraction I [95 % CI]
FP1668.367.5−0.8—
W261.738.8−22.9−22.1 [−30.8, −13.3]
W470.061.7−8.3−7.5 [−15.8, +0.8]
  • Interaction: caching reduces FP16 success by only 0.8 pp but the W2 head's by 22.9 pp; a W4 head reduces the interaction from −22.1 to −7.5 pp, a difference of +14.6 pp [+5.8, +23.3].
  • Robustness: the pattern recurs on four further visual-matching tasks (n = 135: −18.5 vs. +5.9 pp), without guidance (W2: −12.1 pp) and in the manuscript Table 1 setting (H100, W2: −20.0 pp).
  • Interpretation: these measurements are consistent with that account: on CogACT the loss appears when low-bit head error and field reuse are combined, which separate evaluations of quantization and caching do not reveal.
  • Deployed: the configuration with a 4-bit backbone, W4 head and three nodes {0, 3, 6} chosen on this window reaches 70.4 against 67.9 for FP16 under the same caching at 2.47× (RTX 4090; 3.11× on the RTX 3090), and 86.7 against 91.1 on four held-out tasks.

Both failures are thus addressed by model-specific precision allocation‾\underline{\textbf{Both failures are thus addressed by model-specific precision allocation}} — W3 weights for π0 and a W4 head under reuse for CogACT. Tables R5–R6 will be added to the revised manuscript.

Response to Reviewer mBz2 (3/3):\textbf{Response to Reviewer mBz2 (3/3):} Are the static schedules robust, and does accuracy hold on the deployment kernels?

Response to concern 3 (Q3)

How are the static schedules selected, and how sensitive are they? A placement and transfer test

  • Why static: at NFE ≤ 10, adaptive gates select one step set in fourteen of sixteen combinations while paying a per-step decision cost (manuscript Section 3.2, Tables 11–12).
  • How the sets were chosen: for the LIBERO models they were fixed before the reported evaluations but not independently of closed-loop results: GR00T N1.5's after a short screen on LIBERO-Object initial states 40–49, and π0.5's changed from {0, 6, 9} to {0, 5} after closed-loop results.
  • Test: if such a schedule were fragile, success would vary with node placement and degrade on tasks and environments not used for the choice; Table R7 tests both.

Table R7:\textbf{Table R7:} sensitivity of the static schedule.

CheckResult
One common rule C={0,⌊T/2⌋}C = \lbrace 0, \lfloor T/2 \rfloor \rbraceno significant difference on X-VLA and XR-0; SmolVLA 4–5 pp lower (needs three nodes)
All seven two-node placements, GR00T N1.5within 1.2 pp
Rescoring without the calibration and screen episodesCRAFT − FP16 keeps its sign (+1.33 pp, n = 300)
Transfer without re-selectionGR00T N1.7, eight benchmarks: −4.4 to +2.8 pp vs. FP16; X-VLA S / G / L 97.8 / 96.4 / 95.2; π0.5 {0, 5}, S / G / L: +0.8 / −1.2 / +0.6 pp vs. FP16
LIBERO-Plus shifts (4 models, 19 cells)CRAFT −1.01 pp head-only, −1.42 pp with caching vs. FP16; PTQ4DiT −43.9, TFMQ-DM −51.9
  • Placement: every two-node placement on GR00T N1.5 lies within 1.2 pp‾\underline{\textbf{every two-node placement on GR00T N1.5 lies within 1.2 pp}}.
  • Transfer: the sets transfer without re-selection to other benchmarks and to environment shifts, where CRAFT stays within 1.42 pp of FP16 on average while PTQ4DiT and TFMQ-DM lose 43.9 and 51.9 pp.
  • CogACT: {0, 3, 6} was chosen in this rebuttal on its SimplerEnv window ({0, 4}: 62.1 → 70.4); on four tasks not used for the choice the same change gives 77.0 → 86.7 (+9.6 pp [+2.4, +17.0]; n = 135), and FP16 gains similarly (80.7 → 91.1), so the third node lowers the cost of reuse itself.

The revision discloses this procedure.

Response to concern 4 (W3/Q3)

Does the accuracy hold on the actual deployment kernels? A closed-loop test on integer kernels

The reviewer asks for real-robot evaluations or closed-loop results on the actual deployment kernels; we provide the latter here, and real-robot evaluation remains for future work. If fake quantization hid integer-execution errors, success on the kernels would drop.

  • Deployment path: the backbone with GPTQ weights and per-token dynamic activation scales, and every operation of the evaluated head, including the incoherence transforms and the channel and step-wise scales (unlike the kernel timed for manuscript Table 6).
  • Correctness: across 576 layer–step pairs, outputs are bit-identical to our reference integer kernel, which differs from the fake-quantized head by at most 2×10−32\times10^{-3} in relative error.
  • Latency protocol: CUDA-graph capture of each policy call, the minimum of 36 timings after 50 warm-ups and a same-process FP16 reference on an exclusive GPU.

Table R8:\textbf{Table R8:} GR00T N1.5 — deployment kernels (success on an RTX 4090, n = 500 per run).

ConfigurationObjectLongRTX 4090RTX 3090
FP1696.07 (3 runs)89.61.00×1.00×
FP16 + caching——1.48×1.49×
Manuscript Table 1 config.: W4A16 backbone + W2A4 head + caching97.67‾\underline{97.67} (3 runs)89.61.41×1.48×
W4A8 backbone + W2A4 head + caching98.07 (3 runs)93.41.76×‾\underline{1.76\times}1.88×‾\underline{1.88\times}
A4 backbone + W2A4 head + caching95.64 (5 runs)89.61.86×1.94×
  • Accuracy: on the kernels, the manuscript Table 1 configuration shows no significant difference from its fake-quantization success‾\underline{\textbf{no significant difference from its fake-quantization success}} (−0.73 pp [−1.77, +0.27]).
  • Integer-activation backbone: CRAFT reaches 98.07 at 1.76× (1.86× with an A4 backbone).
  • Revised manuscript Table 6: it reports both: on an RTX 4090, 1.76× on GR00T N1.5, 2.22× on π0.5 and 2.47× on CogACT's recommended configuration (the submitted 2.48× timed a W2, two-node configuration), above the caching methods of manuscript Table 6 (MagCache 1.40× / 1.32×).

For the configurations of Tables G1 and R8, CRAFT's accuracy–efficiency trade-off is thus measured in closed loop on the kernels that deliver it.

Again, we sincerely thank the reviewer for the constructive feedback. If you feel your concerns have been addressed, we would be grateful if you could reconsider the rating.

Comments on the paper

3 comments

General Response (2/2):\textbf{General Response (2/2):} What is the contribution, and does it transfer?

Response to shared concern 3 (mBz2 W1, aeLW W1)

Is CRAFT more than an integration of known components? Can they be chosen independently?

mBz2 and aeLW note that lattice quantization, block rotation, step-wise scales and fixed-step caching each exist in prior work. We agree and claim novelty neither in these primitives nor in the identities of manuscript Propositions 1 and 4.

The manuscript starts from three open limitations (manuscript Section 1):

  • Quantization: scalar W2 error concentrates in a few directions.
  • Caching: per-step gating costs more than it saves at NFE ≤ 10.
  • Their combination: the joint loss of quantization and caching was unmeasured.

Our contribution is the analysis of how these choices interact in extreme-low-bit VLA action heads (manuscript Section 3) and the co-design it guides (manuscript Section 4). Table R1 lists each analysis, its decision and the evidence.

Table R1:\textbf{Table R1:} analysis, design decision and direct evidence (new = this rebuttal).

Analysis (manuscript Sec.)Design decisionDirect evidence
Quantization–reuse coupling (3.3)choose head precision jointly with reusenew: CogACT interaction −22.1 (W2) vs. −7.5 pp (W4); without guidance −12.1 pp; solver gain 3.00 vs. 0.50–1.00
W2 output error concentrates in few directions (3.1)H-weighted lattice rounding; rotate only where the weight tail calls for itsuccess-change correlation −0.52 (output error) vs. +0.37 (weight error); error 9.8–40.6× below the best other quantizer on all eight heads; tail change predicted on 16/16 modules; rotating every head −10.4 pp on CogACT
Short solver trajectories (3.2)fixed nodes instead of per-step gatesgates pick nearly one node set and cost up to 7.1 / 4.5 / 0 ms per call for TeaCache / AdaptiveDiffusion / MagCache (manuscript Tables 11–12); new: at NFE 2 on GR00T N1.5, fixed nodes 96.0 vs. TeaCache 97.4 / MagCache 96.8 (n.s.)
  • The choices are not independent: if the effects of quantization and caching were additive, the extra loss caching causes relative to FP16 would not depend on head precision. On CogACT, caching costs a W2 head 22.1 pp more than FP16 but a W4 head only 7.5 pp more (difference +14.6 pp [+5.8, +23.3]; Table R6), so head precision changes the closed-loop cost of reuse‾\underline{\textbf{head precision changes the closed-loop cost of reuse}}, which separate evaluations miss.
  • Assembled components fall short: HoloQ-VLA‡ (block rotation, step-wise scales, scalar rounding) averages 56.66 over the eight models and QuantVLA‡ 65.15, against 80.45 for CRAFT's head (same FP16 backbone, no caching).

Response to shared concern 4 (uuTH ①, mBz2 W2)

Does CRAFT generalize beyond its design models? A test on three unseen VLAs and a high-gain head

  • Hypothesis: if CRAFT's default configuration were fitted to the eight paper models, it should degrade on new architectures.
  • Test: we applied it unchanged to three recent VLAs not used in its design — default W2A4 head, tail rule for rotation, caching nodes from the common rule (NORA-1.5: a LIBERO-Goal screen).

Table R2:\textbf{Table R2:} three unseen VLAs — W2A4 head (success %, n = 500 per cell).

Model, suiteReuse gainOfficialQuantVLA‡PTQ4DiTCRAFT (+ caching)W2 output error (%), QuantVLA‡ / PTQ4DiT / CRAFT
FastWAM, LIBERO-Object0.9197.294.8‾\underline{94.8}43.297.2 (98.4)2.86 / 4.52 / 0.025
VLA-JEPA, LIBERO-100.5097.294.895.6‾\underline{95.6}97.2 (95.0)1.96 / 3.65 / 0.037
NORA-1.5, LIBERO-100.8087.053.6‾\underline{53.6}46.886.8 (85.8)7.43 / 11.18 / 0.027
  • Three low-gain heads: CRAFT matches the official success on all three models‾\underline{\textbf{CRAFT matches the official success on all three models}} (0.0 / 0.0 / −0.2 pp, paired), whereas QuantVLA‡ loses up to 33.4 pp and PTQ4DiT up to 54.0 pp. These heads are low-gain (0.50–0.91, computed afterwards), so the default W2A4 head transfers to them.
  • A high-gain head: a fourth model, InternVLA-M1 (LIBERO-Object, n = 500), has a high-gain DDIM ε-prediction head. With the interaction definition, the W2 and W4 heads and the two-node schedule fixed before the runs, the interaction recurs: −68.8 pp [−73.2, −64.4] with the W2 head and −26.6 pp [−31.4, −21.8] with a W4 head.
  • Failure and recovery: on this head the default configuration fails under reuse (19.8), as on CogACT; a W4 head with a third node, added afterwards, reaches 95.0 against 97.8 for FP16 under the same reuse (99.4 uncached).

These results show that precision-dependent reuse sensitivity extends beyond CogACT, motivating the joint evaluation of head precision and caching that CRAFT performs.

General Response (1/2):\textbf{General Response (1/2):} Do success and speedup hold for one deployed policy, and what do the π0 and CogACT failures imply?

We thank the reviewers and answer two shared concerns with new experiments.

Response to shared concern 1 (mBz2 W3/Q3, uuTH ②/③)

Do success and speedup hold for one deployment configuration? A joint measurement on integer kernels

mBz2 and uuTH note that manuscript Appendix C.2 measures success (weight-only W4 backbone, fake quantization) and RTX latency (RTN W4A4) in different configurations.

  • Why they were separate: the backbone runs once per policy call, while the action head runs at every denoising step and carries CRAFT's contribution (manuscript Sections 1 and 4). The backbone therefore received standard quantization, once for accuracy (manuscript Table 1) and once for latency (manuscript Table 6).
  • The question: do the reported success and speedup coexist in one executable configuration? If not, success would drop on the integer path.
  • New measurement: we measured both on the full deployment path with the same quantized artifacts and kernels (Table G1).

Table G1:\textbf{Table G1:} one configuration, both numbers — success (%) and speedup over uncached FP16.

ModelBackbone / head / cachingCRAFTFP16Δ [95 % CI]RTX 4090RTX 3090
GR00T N1.5W4A8 / W2A4 / {0, 4}98.0796.07+2.00 [+0.80, +3.25]†1.76×1.88×
π0.5W4A8 / W2A4 / {0, 5}98.399.2 (98.8)−0.9 [−2.0, +0.5]2.22×2.36×
π0W4A8 / W3A8 / {0, 5}98.296.8 (96.8)+1.4 [−0.6, +3.5]2.14×2.41×
CogACTW4A8 vision + W4A4 language / W4 / {0, 3, 6}70.468.3 (67.9)+2.1 [−6.1, +10.3]2.47×3.11×

LIBERO-Object (CogACT: SimplerEnv window); success on an RTX 4090 (GR00T N1.5) or RTX 3090 (others), latency on both; FP16 uncached on the same device (same caching in parentheses). † Three runs each, pooled; run/task bootstrap [−0.27, +4.33]. π0.5: two runs. CogACT: n = 240; its nodes {0, 3, 6} were chosen on this window (four held-out tasks: 86.7 vs. 91.1 for FP16 with the same caching).

Table G1 directly resolves the configuration mismatch for these four policies:‾\underline{\textbf{Table G1 directly resolves the configuration mismatch for these four policies:}}

  • Success: none is significantly below FP16 re-run on its success device (same harness and tasks).
  • Speedup: the same artifacts run 1.76–2.47× faster on an RTX 4090 and 1.88–3.11× on an RTX 3090.

Response to shared concern 2 (mBz2 W2/Q1, uuTH ①, aeLW Q2)

Do the π0 and CogACT failures limit generality? A matched-precision and recovery test

The reviewers point to the drops on π0 (98.4 → 24.0) and CogACT (72.1 → 37.5). Two questions decide this, and Table G2 answers both:

  • (a) Matched precision: is CRAFT unusually poor at the same W2A4 budget?
  • (b) Recovery: does a higher head precision recover success?

Table G2:\textbf{Table G2:} π0 and CogACT (success %).

MethodHead W / Aπ0 (LIBERO-Object)CogACT (SimplerEnv)
Manuscript Table 1 (H100, fake quantization)
FP1616 / 1698.472.1
QuantVLA‡2 / 412.8‾\underline{12.8}19.6
HoloQ-VLA‡2 / 40.212.5
PTQ4DiT2 / 40.042.9‾\underline{42.9}
TFMQ-DM2 / 40.00.0
CRAFT (default head)2 / 419.465.8
Recommended configuration, deployment kernels (success: RTX 3090; speedup: RTX 4090 / 3090)
FP1616 / 1696.868.3
CRAFT, 4-bit backboneπ0 3 / 8; CogACT 4 / 498.2 · 2.14× / 2.41×70.4 · 2.47× / 3.11×

‡ as in manuscript Table 1. Prior methods at higher head precision: Table R5 (π0) and manuscript Table 1; measured head storage: Table R11.

  • (a) Matched precision: at the same W2A4 head precision, CRAFT is the strongest method on both heads‾\underline{\textbf{CRAFT is the strongest method on both heads}}; every other W2A4 method fails further.
  • (b) Recovery, π0: W3 instead of W2 weights (A8 fixed) restores head-only success from 26.4 to 96.8.
  • (b) Recovery, CogACT: its DDIM solver amplifies a reused-field error (gain 3.00 vs. 0.50–1.00, manuscript Proposition 4); a W4 head cuts the quantization–caching interaction from −22.1 to −7.5 pp (Table R6).
  • Deployment kernels: with these heads (CogACT: a third node), both models show no significant difference from FP16 at 2.14× / 2.47× (RTX 4090) and 2.41× / 3.11× (RTX 3090).
  • Remaining gap: π0 LIBERO-Long stays 7.2 pp lower.

Both therefore remain failures of the default W2A4 configuration, and a higher head precision recovers each (see mBz2).

General Response:\textbf{General Response:} the revised manuscript

We have uploaded the revised manuscript. All changes are in red\textbf{All changes are in red}, and a summary at the start of the appendix (Summary of Revisions, p. 13) lists where each concern is addressed. The main text stays within the page limit. Below we group the reviewers' concerns and state what changed and how each concern is resolved.

Concern (reviewers)What changed in the revisionHow the concern is resolved
Combination of known components (mBz2 W1, aeLW W1)Section 5.3 presents the precision–reuse interaction as a main result (Figure 7); Appendix D.3 maps each analysis to its design decision.Head precision changes the cost of reuse: on CogACT caching costs a W2 head 22.1 pp more than FP16 but a W4 head 7.5 pp, and the effect recurs on the unseen InternVLA-M1 (−68.8 vs. −26.6 pp). A head assembled from existing components averages 56.66 against 80.45.
Failures on π0 and CogACT; generality (mBz2 W2/Q1, uuTH ①, aeLW Q2)New failure case analysis (Appendix E.4, Tables 31–35); Table 2 adds three unseen VLAs.Every W2A4 baseline fails further on both models. W3 weights restore π0 (26.4 → 96.8), and a W4 head with a third node recovers CogACT; both show no significant difference from FP16 at 2.14× and 2.47× (RTX 4090). On the unseen VLAs the unchanged default head stays within 0.2 pp of the official models.
Success and speedup from different configurations; fake quantization (uuTH ②/③, mBz2 W3/Q3)Section 5.4 now states which backbone each latency row uses; Table 7 and the red row of Table 6 report both with the same quantized artifacts and integer kernels; the abstract and conclusion quote this configuration; full table in Appendix C.3 (Table 9).For four models, success is not significantly below FP16 at 1.76–2.47× (RTX 4090) and 1.88–3.11× (RTX 3090). The Table 1 configuration shows no significant difference between the kernels and fake quantization.
Table 1 mixes budgets and ablations; success versus overhead (uuTH Q②, aeLW Q1)Table 1 is regrouped by comparison budget with a measured-speedup column; ablation rows moved to Appendix D.2 (Table 16); Figure 8 and Appendix C.4 (Tables 10–13) break down each W2A4 head.At matched W2A4, CRAFT has the highest mean success (80.45 vs. at most 65.15) and the highest success per unit latency (2.41 vs. 1.99 and 1.41 %/ms). W2 and W4 heads run at nearly the same speed, so the W2 head's benefit is storage.
Bits not matched; stored rotation (aeLW W2, Q6)Table 1 reports measured bpw for the W2A4 baselines; Appendix D.9 (Table 28) measures every head of every model under one accounting.The extra storage is the stored rotation, present on four heads; elsewhere CRAFT is within 0.31 bpw of every baseline. A storage-free Hadamard variant saves about 1 bpw and matches on three of five models.
Schedule selection and sensitivity (mBz2 Q2, aeLW Q4)The selection procedure is disclosed (Appendix D.7, Table 24; Limitations).All seven two-node placements on GR00T N1.5 lie within 1.2 pp, and the sets transfer without re-selection to further benchmarks and environment shifts.
Repeated runs and intervals (aeLW Q5)Three-run repeats with pooled and run-/task-level intervals (Appendix D.6, Table 20; F.8, Table 36); "at or above FP16" is removed.The main text now states that differences from FP16 are not statistically significant; the A4 gain is supported on LIBERO-Spatial (+7.27 pp).
Real-robot evaluation (mBz2 Q3)Limitations state real-robot deployment on an onboard edge device as future work.Closed-loop success on the deployment kernels is reported (Appendix C.3).

We thank the reviewers again and welcome further questions on the revised manuscript.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.