Native low-bit inference, measured in closed loop

FoldQuantVLA

Native Low-Bit Quantization of Vision-Language-Action Models via Consistent Folding

Anonymous Authors

1.20–1.33×

Faster on Jetson AGX Orin

Native W4A4 vs the TRT BF16 engine, end to end.
GR00T N1.5 / N1.6 / N1.7 and π0.5 · batch 1

2.11×

Smaller engine artifact

5,325 → 2,525 MB of serialized TensorRT plans.
GR00T N1.6 · not peak GPU memory.

92.5%

Real-robot success rate

W4A4 + o/d INT8 on Jetson, GR00T N1.7, four tasks.
BF16 PyTorch 87.5% · TRT BF16 90.0% · W4A4 80.0%.

0.460.85

Worst-case action cosine

W4A4 → W4A4 + o/d INT8, GR00T N1.6 held-out.
Costs +0.4–1.8 ms end to end on GR00T desktop.

Overview

A consistent fold.
A clearer measurement.

What does lower precision actually buy a robot policy?

FoldQuantVLA fixes a shared change of basis at each activation site, folds it into weights and normalization gains, and rounds once. A common build path produces floating-point, eight-bit, and four-bit engines for the language backbone and iterative action expert.

We evaluate the resulting engines with compiled floating-point controls and 48 closed-loop LIBERO campaigns. The controls separate deployment speedups from precision gains; the rollouts show where offline action fidelity stops predicting task success.

(a) Orin latency versus real-robot success on the T4 task: both ModelOpt baselines stay far below every FoldQuant arm, SmoothQuant at 30% and AWQ at 40% against 80% for FoldQuant W4A4 + o/d INT8, which is also among the fastest at 120 ms. (b) LIBERO success on N1.7 against prior W4A4 recipes.
(a) Orin latency vs. real-robot SR on the T4 task, 20 trials per configuration. Both *ModelOpt baselines stay far below every FoldQuant arm: SmoothQuant 30%, AWQ 40%, against 80% for W4A4 + o/d INT8 at 120 ms. (b) LIBERO on N1.7; †: our emulated ports.

Consistent by construction

Every projection sharing an activation site uses the same transform. Calibration, exported weights, and runtime stay in the same coordinates.

Native low-bit execution

Custom TensorRT plugins fuse activation transforms and quantization with integer tensor-core GEMMs on desktop and Jetson GPUs.

Measured end to end

Compiled controls, device measurements, and closed-loop outcomes reveal both the gains and the configurations that fail.

Evaluated onGR00T N1.5 / N1.6 / N1.7π0.5

Method

Fold the constants.
Fuse the computation.

One transform per activation site. One engine for the denoising loop.

Consistent folding method: channel scaling and orthogonal rotation define a shared basis, weights are folded, quantized and packed offline, then activations are transformed and quantized for integer GEMM online.
Fold offline, execute in low bits (toy matrices, not model measurements). (A) Channel scaling S−1 migrates activation outliers into the weights and the orthogonal rotation R spreads the remaining peaks; (WSRT)(RS−1X) = WX before rounding. (B) Offline, the folded weight W̃ = WSRT is rounded once to INT4 with per-output-channel scales and nibble-packed. (C) Online, the fused prologue quantizes RS−1X per token, the integer GEMM accumulates in INT32, and the output is rescaled by sWj sAt without dequantizing the weights.

A shared basis

Scaling and rotation define the coordinates once. Every consumer of the activation must agree on that basis before rounding.

A precise boundary

Language and expert projections use W8A8 or W4A4. Vision, attention softmax, residuals, and decoding remain floating point.

A reusable engine

Dynamic per-token scaling serves each denoising step. Calibration optimality across steps requires the paper’s stated directional-distribution condition.

Closed-loop simulation · LIBERO & SimplerEnv

Success survives
the precision change.

FoldQuantVLA against low-bit baselines in two simulators, LIBERO and SimplerEnv, with the BF16 reference first.

The note under each table gives the protocol behind every row.

GR00T N1.7

LIBERO four suites · 200 episodes per suite

SR % · 200 episodes per suite
ArmPrec.SpatialObjectGoalLongAverage SR ↑
BF16 PyTorchbf1698.5%98.5%92.5%93.5%95.75%
HoloQ-VLA†int494.0%98.5%89.5%90.0%93.00%
DuQuant†int497.0%97.5%95.0%83.5%93.25%
FoldQuant W4A4 (ours)int498.5%97.0%95.5%88.5%94.88%
FoldQuant W4A4 + o/d INT8 (ours)int496.5%98.5%94.0%93.5%95.62%

FoldQuant rows are real INT4 / INT8 TensorRT engines. † HoloQ-VLA and DuQuant are our emulated implementations of those methods in the same release repository.

π0.5

LIBERO four suites · 200 episodes per suite

SR % · 200 episodes per suite
ArmPrec.SpatialObjectGoalLongAverage SR ↑
BF16 PyTorchbf1698.5%99.0%97.5%93.5%97.12%
HoloQ-VLAint499.0%97.0%100.0%96.0%98.00%
DuQuantint496.0%99.0%94.0%88.0%94.25%
QuantVLAint494.0%98.0%80.0%56.0%82.00%
SmoothQuantint483.0%88.0%40.0%26.0%59.25%
FoldQuant W4A4 (ours)int498.0%99.5%96.0%95.5%97.25%
FoldQuant W4A4 + o/d INT8 (ours)int499.5%99.0%98.5%94.0%97.75%

FoldQuant rows are real INT4 / INT8 TensorRT engines. BF16 and FoldQuant rows: FoldQuant released openpi harness, 20 trials per task, K = 5, seed 7. HoloQ-VLA, DuQuant, QuantVLA and SmoothQuant: reported by HoloQ-VLA (emulated quantization, 10 calibration samples); their FP16 reference is also 97.1%. Our reproduction of HoloQ-VLA W4A4 on the long suite reaches 94.0% against 96.0% reported (t = −0.82, p = 0.44).

FoldQuantVLA across four checkpoints

LIBERO · four suites · 40 tasks · 800 episodes per configuration

CheckpointHKBF16 SRFoldQuant W8A8FoldQuant W4A4FoldQuant W4A4 + o/d INT8
PyTorchTensorRTSR ↑Median cos ↑SR ↑Median cos ↑SR ↑Median cos ↑
GR00T N1.716896.25%95.50%95.38%0.9999695.38%0.9981795.00%0.99928
GR00T N1.616896.38%97.75%95.75%0.9999895.75%0.9987696.62%0.99967
GR00T N1.516186.38%86.00%87.12%0.9999987.38%0.9988587.00%0.99933
π0.510596.50%98.00%97.38%1.0000097.12%0.9994297.62%0.99981

H is the action chunk length and K the executed prefix.

GR00T N1.6 · SimplerEnv Bridge (WidowX)

Seven WidowX tasks · 200 episodes per task

SR % · 200 episodes per task
ArmTaskAvg ↑
Put spoon on towelPut carrot on platePut eggplant in basketStack green cube on yellowPut eggplant in sinkClose drawerOpen drawer
BF16 PyTorch63.5%60.5%92.5%6.0%43.0%72.0%98.0%62.2%
FoldQuant W8A8 (ours)63.5%59.5%89.5%2.5%40.0%64.5%96.5%59.4%
FoldQuant W4A4 (ours)66.0%70.5%58.0%7.5%63.0%82.0%81.5%61.2%
FoldQuant W4A4 + o/d INT8 (ours)75.5%66.5%70.5%5.5%50.0%89.5%92.0%64.2%

Real-world tasks

Four tasks, two robot platforms

GR00T N1.7 deployed on Jetson AGX Orin: one single-arm ALOHA task and three SO-101 tasks, 20 episodes per task.

Five engines, one episode

GR00T N1.7 · pick a task; every engine plays at once so their pace can be compared

SO-101 · Blue block on the red block

Prompt“Pick blue cube and place on red cube”

One selected episode per engine in each scene · external camera · 4× speed

BF16 PyTorch
TRT BF16
ModelOpt W8A8 SmoothQuant*
ModelOpt W4A16 AWQ*
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
ModelOpt W8A8 SmoothQuant*
ModelOpt W4A16 AWQ*
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
ModelOpt W8A8 SmoothQuant*
ModelOpt W4A16 AWQ*
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
ModelOpt W8A8 SmoothQuant*
ModelOpt W4A16 AWQ*
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
ModelOpt W8A8 SmoothQuant*
ModelOpt W4A16 AWQ*
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)

* ModelOpt W8A8 SmoothQuant and ModelOpt W4A16 AWQ are run with NVIDIA’s TensorRT Model Optimizer (ModelOpt) repository.

SO-101 · Pick up the banana

Prompt“Pick up the banana and place it in the pot, then close the lid”

One selected episode per engine in each scene · external camera · 4× speed

BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)

SO-101 · Put all blocks into the cup

Prompt“Pick all cubes and place into cup”

One selected episode per engine in each scene · external camera · 4× speed

BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)

ALOHA · Banana into pot, then close the lid

Prompt“Use the right gripper to pick up the banana and place it into the pot. Then pick up the lid with the right gripper and place it on top of the pot to close it.”

One selected episode per engine in each scene · high camera · 4× speed

BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W8A8 (ours)
FoldQuant W4A4 (ours)
FoldQuant W4A4 + o/d INT8 (ours)

Real-robot success

GR00T N1.7 on Jetson AGX Orin · SR % · 20 episodes per task and arm · Wilson 95% interval

ArmALOHA · BananaSO101 · BananaSO101 · All blocks into cupSO101 · Blue block on redAverage SR ↑
BF16 PyTorch90%90%100%70%87.5%95% CI [78.5, 93.1]
TRT BF16 (float engine)95%90%100%75%90.0%95% CI [81.5, 94.8]
ModelOpt W8A8 SmoothQuant*N/AN/AN/A30%30.0%95% CI [14.5, 51.9]T4 only
ModelOpt W4A16 AWQ*N/AN/AN/A40%40.0%95% CI [21.9, 61.3]T4 only
FoldQuant W8A8 (ours)85%95%100%70%87.5%95% CI [78.5, 93.1]
FoldQuant W4A4 (ours)75%85%95%65%80.0%95% CI [70.0, 87.3]
FoldQuant W4A4 + o/d INT8 (ours)95%95%100%80%92.5%95% CI [84.6, 96.5]

Arms interleaved with matched object placements. W4A4 + o/d INT8 vs W4A4: +20 / +10 / +5 / +15 pp per task, +12.5 pp on average. ModelOpt W8A8 SmoothQuant stopped after one task (SO-101 blue on red): jerky motion risked the hardware. It is not in any total. ModelOpt W4A16 AWQ was also run on that task only: 8/20 (40%). Median logged-observation action cosine vs BF16 PyTorch — ALOHA: TRT BF16 0.99999 · W8A8 0.99999 · W4A4 0.99962 · W4A4 + o/d INT8 0.99975; SO-101: TRT BF16 1.00000 · ModelOpt SmoothQuant 0.99892 · W8A8 1.00000 · W4A4 0.99961 · W4A4 + o/d INT8 0.99988. * ModelOpt W8A8 SmoothQuant and ModelOpt W4A16 AWQ are run with NVIDIA’s TensorRT Model Optimizer (ModelOpt) repository.

π0.5 · three engines, one episode

π0.5 · every engine plays at once so their pace can be compared

π0.5 · SO-101 · Blue block on the red block

Prompt“Pick blue cube and place on red cube”

One selected episode per engine in each scene · external camera · 4× speed

BF16 PyTorch
TRT BF16
FoldQuant W4A4 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W4A4 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W4A4 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W4A4 (ours)
BF16 PyTorch
TRT BF16
FoldQuant W4A4 (ours)

π0.5 · SO-101 blue block on red

π0.5 on Jetson AGX Orin · SR % · 20 episodes per arm · Wilson 95% interval

ArmSR ↑
BF16 PyTorch80.0%95% CI [58.4, 91.9]
TRT BF16 (float engine)100.0%95% CI [83.9, 100.0]
FoldQuant W4A4 (ours)85.0%95% CI [64.0, 94.8]

20 episodes per arm on one task. Median logged-observation action cosine of W4A4 vs BF16 PyTorch is 0.98994; its backbone cosine (0.819) is the lowest measured on either robot while success stays at the reference. W8A8 and W4A4 + o/d INT8 were not run for π0.5 on the robot.

Results · Latency & memory

Efficiency, with the controls.

Pick a target, then a model family.
Every arm of that family in one table.

Jetson AGX Orin · on-device

Four checkpoints · TensorRT 10.3 · batch 1 · observation-to-action chunk

GR00T N1.7

ArmPrec.GPU (ms) ↓E2E (ms) ↓Rate (Hz) ↑vs TRT BF16 ↑
TRT BF16 (float engine)bf16119.11466.8ref
Eager PyTorchbf16323.23512.80.42×
torch.compilebf16202.42314.30.63×
ModelOpt W8A8 SQint8109.51377.31.07×
ModelOpt W4A16 AWQint4139.11676.00.87×
FoldQuant W8A8 (ours)int8100.51277.91.15×
FoldQuant W4A4 (ours)int491.81198.41.23×
FoldQuant W4A4 + o/d INT8 (ours)int493.51208.31.22×

GR00T N1.6

ArmPrec.GPU (ms) ↓E2E (ms) ↓Rate (Hz) ↑vs TRT BF16 ↑
TRT BF16 (float engine)bf16130.11506.7ref
Eager PyTorchbf16313.23333.00.45×
torch.compilebf16196.62174.60.69×
ModelOpt W8A8 SQint8121.51427.01.06×
ModelOpt W4A16 AWQint4155.61775.60.85×
FoldQuant W8A8 (ours)int8117.01377.31.09×
FoldQuant W4A4 (ours)int4104.81258.01.20×
FoldQuant W4A4 + o/d INT8 (ours)int4106.31277.91.18×

GR00T N1.5

ArmPrec.GPU (ms) ↓E2E (ms) ↓Rate (Hz) ↑vs TRT BF16 ↑
TRT BF16 (float engine)bf16107.01357.4ref
Eager PyTorchbf16216.22494.00.54×
torch.compilebf16166.11995.00.68×
ModelOpt W8A8 SQint8105.41347.51.01×
ModelOpt W4A16 AWQint4144.81745.70.78×
FoldQuant W8A8 (ours)int894.71238.11.10×
FoldQuant W4A4 (ours)int482.11119.01.22×
FoldQuant W4A4 + o/d INT8 (ours)int485.01148.81.18×

π0.5

ArmPrec.GPU (ms) ↓E2E (ms) ↓Rate (Hz) ↑vs TRT BF16 ↑
TRT BF16 (float engine)bf16224.72294.4ref
Eager PyTorchbf16856.98611.20.27×
torch.compilebf16337.9342.52.90.67×
ModelOpt W8A8 SQint8206.12114.71.09×
ModelOpt W4A16 AWQint4321.63263.10.70×
FoldQuant W8A8 (ours)int8221.12264.41.01×
FoldQuant W4A4 (ours)int4167.61725.81.33×
FoldQuant W4A4 + o/d INT8 (ours)int4198.72034.91.13×

RTX 4070 Ti SUPER · desktop

Four checkpoints · TensorRT 10.15 · batch 1 · observation-to-action chunk

GR00T N1.7

ArmPrec.GPU (ms) ↓E2E (ms) ↓Rate (Hz) ↑vs TRT BF16 ↑
TRT BF16 (float engine)bf1639.041.024.4ref
Eager PyTorchbf1665.067.314.90.61×
torch.compilebf16N/A54.718.30.75×
ModelOpt W8A8 SQint834.037.526.71.09×
ModelOpt W4A16 AWQint452.260.3§16.60.69×
FoldQuant W8A8 (ours)int833.035.927.91.14×
FoldQuant W4A4 (ours)int430.032.231.11.27×
FoldQuant W4A4 + o/d INT8 (ours)int431.034.029.41.21×

o/d INT8 vs W4A4: +1.8 ms E2E · § ModelOpt W4A16 AWQ measured in the framework runtime; its ratio uses that runtime’s TRT BF16 (41.5 ms) · GPU components printed as whole ms by the upstream timer. o/d INT8 uses the campaign recipe engine.

GR00T N1.6

ArmPrec.GPU (ms) ↓E2E (ms) ↓Rate (Hz) ↑vs TRT BF16 ↑
TRT BF16 (float engine)bf1642.546.621.5ref
Eager PyTorchbf1664.768.814.50.68×
torch.compilebf16N/A59.85§16.70.74×
ModelOpt W8A8 SQint833.140.3§24.81.09×
ModelOpt W4A16 AWQint457.264.1§15.60.69×
FoldQuant W8A8 (ours)int836.440.624.61.15×
FoldQuant W4A4 (ours)int431.635.827.91.30×
FoldQuant W4A4 + o/d INT8 (ours)int433.037.127.01.26×

o/d INT8 vs W4A4: +1.3 ms E2E · § torch.compile, ModelOpt W8A8 SQ and ModelOpt W4A16 AWQ measured in the framework runtime; their ratio uses that runtime’s TRT BF16 (44.1 ms)

GR00T N1.5

ArmPrec.GPU (ms) ↓E2E (ms) ↓Rate (Hz) ↑vs TRT BF16 ↑
TRT BF16 (float engine)bf1636.941.524.1ref
Eager PyTorchbf1650.654.818.20.76×
torch.compilebf16N/A53.46§18.70.75×
ModelOpt W8A8 SQint825.434.1§29.31.18×
ModelOpt W4A16 AWQint443.953.2§18.80.76×
FoldQuant W8A8 (ours)int832.738.026.31.09×
FoldQuant W4A4 (ours)int428.433.130.21.25×
FoldQuant W4A4 + o/d INT8 (ours)int429.133.529.91.24×

o/d INT8 vs W4A4: +0.4 ms E2E · § torch.compile, ModelOpt W8A8 SQ and ModelOpt W4A16 AWQ measured in the framework runtime; their ratio uses that runtime’s TRT BF16 (40.2 ms)

π0.5

ArmPrec.GPU (ms) ↓E2E (ms) ↓Rate (Hz) ↑vs TRT BF16 ↑
TRT BF16 (float engine)bf16102.8113.88.8ref
Eager PyTorchbf16154.9165.76.00.69×
torch.compilebf16N/A99.610.01.14×
ModelOpt W8A8 SQint8N/AN/AN/AN/A
ModelOpt W4A16 AWQint4N/AN/AN/AN/A
FoldQuant W8A8 (ours)int877.788.211.31.29×
FoldQuant W4A4 (ours)int464.574.713.41.52×
FoldQuant W4A4 + o/d INT8 (ours)int470.380.912.41.41×

o/d INT8 vs W4A4: +6.2 ms E2E · ModelOpt SQ / AWQ are not buildable on a 16 GB GPU

GPU memory · RTX 4070 Ti SUPER

Four checkpoints · batch 1 · steady device memory during inference, one process per arm

GR00T N1.7

ArmPrec.Floor (MiB) ↓As served (MiB) ↓Weights (MB) ↓Floor vs TRT BF16
TRT BF16 (float engine)bf167,1937,1936,482ref
Eager PyTorchbf166,4696,4696,288−10%
FoldQuant W8A8 (ours)int86,1496,1494,782−15%
FoldQuant W4A4 (ours)int45,5635,5633,689−23%
FoldQuant W4A4 + o/d INT8 (ours)int45,5135,5133,866−23%

The upstream N1.7 pipeline already deletes replaced modules, so floor equals as served.

GR00T N1.6

ArmPrec.Floor (MiB) ↓As served (MiB) ↓Weights (MB) ↓Floor vs TRT BF16
TRT BF16 (float engine)bf166,34910,6093,802ref
Eager PyTorchbf166,9476,9476,574+9%
FoldQuant W8A8 (ours)int85,2599,5192,104−17%
FoldQuant W4A4 (ours)int44,6738,9331,011−26%
FoldQuant W4A4 + o/d INT8 (ours)int44,6238,8831,189−27%

GR00T N1.5

ArmPrec.Floor (MiB) ↓As served (MiB) ↓Weights (MB) ↓Floor vs TRT BF16
TRT BF16 (float engine)bf165,1517,9872,315ref
Eager PyTorchbf165,7975,7975,448+13%
FoldQuant W8A8 (ours)int84,4517,2871,282−14%
FoldQuant W4A4 (ours)int44,1116,947635−20%
FoldQuant W4A4 + o/d INT8 (ours)int44,0596,895736−21%

π0.5

ArmPrec.Floor (MiB) ↓As served (MiB) ↓Weights (MB) ↓Floor vs TRT BF16
TRT BF16 (float engine)bf166,97112,3134,849ref
Eager PyTorchbf167,6917,6917,473+10%
FoldQuant W8A8 (ours)int84,92710,2692,443−29%
FoldQuant W4A4 (ours)int44,5539,8951,349−35%
FoldQuant W4A4 + o/d INT8 (ours)int44,6519,9931,669−33%

What the controls reveal

Smaller bits.
A more nuanced picture.

Compilation explains much of the speedup.

The compiled float engine already supplies 61–75% of the eager-to-W4A4 reduction on the desktop and 83–92% on Jetson AGX Orin, where four-bit adds the last 8–17%. Reporting speedups against compiled float engines keeps graph optimisation from being credited to quantization.

Low-bit engines cut GPU memory.

When the weights an engine replaces are not kept on the GPU, FoldQuant W4A4 needs 20–35% less steady device memory than the TRT BF16 engine on all four checkpoints. Vision, embeddings and runtime workspaces set the floor that bit width cannot remove.

Offline fidelity screens; closed loop decides.

Above 0.99 held-out action cosine, success differences between arms stay within closed-loop noise and are not ordered by cosine. High cosine screens a broken configuration without ranking the working ones.

Citation

Cite this work.

Anonymous manuscript · 2026

BibTeX
@misc{anonymous2026foldquantvla,
  title  = {FoldQuantVLA: Native Low-Bit Quantization of Vision-Language-Action Models via Consistent Folding},
  author = {{Anonymous Authors}},
  year   = {2026},
  note   = {Anonymous ICRA submission}
}