Literature
Display
← All papers

BitVLA: 1-bit Vision-Language-Action Models for Robotics Manipulation

Hongyu Wang · Chuyan Xiong · Ruiping Wang · Xilin Chen

Preprint posted · CoRL 2026 (accepted) ↗

Robotics8 min text · CondensedOriginal paper ↗
Contents

Overview

Figure 1 summarizes memory, task performance and speed. This edition follows the complete 15-page arXiv v2 dated 1 March 2026, including all figures and the appendix’s detailed task protocols and hyperparameters.

Complete original Figure 1.
Fig. 1: We introduce BitVLA, the first fully native 1-bit vision-language-action (VLA) model for robotic manipulation, in which every parameter is ternary, i.e., {−1,0,1}\{-1,0,1\}. With the proposed Quantize-then-Distill stage, we compress the full-precision vision encoder to 1.58-bit weights with INT8 activations after multimodal training. Experiments show that BitVLA outperforms π0\pi_{0} [4] at similar parameter counts and achieves performance comparable to the larger OpenVLA-OFT [18]. Meanwhile, BitVLA requires only 1.4 GB memory and delivers a 4.4×4.4\times speedup over OpenVLA-OFT.

At a glance

BitVLA combines a pretrained ternary language backbone with a vision encoder compressed through quantization-aware feature distillation. It then learns robot actions from cross-embodiment data and task demonstrations. The reported model occupies 1.4 GB and reaches 96.0% average LIBERO success, compared with 97.1% and 15.4 GB for OpenVLA-OFT.

The “1-bit” name refers to ternary backbone weights, requiring about 1.58 bits in principle. Connector, action head and embedding exceptions remain in full precision. A server-GPU benchmark gives 73 ms per 25-action chunk; it is not a measured onboard edge-control latency.

I Introduction

Large vision-language-action policies can exceed robot memory and compute budgets. BitVLA incorporates low-bit constraints during learning instead of treating compression solely as an after-training conversion. Its three stages establish multimodal alignment, compress vision features with a teacher, then train a robot policy.

The study reports an elevenfold model-memory reduction relative to the larger OpenVLA-OFT and roughly 4.4-fold lower latency than the benchmark’s OpenVLA-OFT+ variant. These ratios combine architecture, model-size and numerical-precision differences; they are not an isolated same-size quantization ablation. Hardware energy savings are motivated by arithmetic, not directly measured.

II Related Works

Small VLA backbones, efficient action heads and improved pretraining data offer complementary efficiency routes. Native low-bit language models such as BitNet b1.58 2B4T supply a pretrained ternary backbone, while distillation helps transfer useful full-precision representations into a quantized vision encoder.

BitVLA extends these ideas to multimodal robot policies. It is a training recipe built around a low-bit initialization, not a demonstrated drop-in conversion for every full-precision VLA.

Complete original Figure 2.
Fig. 2: Overview of the three-stage training pipeline in BitVLA. We first perform multimodal training with a 1-bit LLM and a full-precision vision encoder, then apply Quantize-then-Distill to compress the vision encoder to 1.58-bit weights (INT8 activations) while preserving multimodal alignment, and finally conduct robotics training on large-scale cross-embodiment trajectories for downstream manipulation.

III BitVLA : 1-bit VL

The method joins a compact visual encoder and ternary language model, then progressively aligns, quantizes and adapts them to actions. The retained equations specify the quantizers and training losses.

III-A Model Architecture

The language backbone is BitNet b1.58 2B4T; SigLIP-L at 224×224 produces 256 visual tokens per image. A two-layer GeLU MLP projects vision features into language embeddings, with an optional state-token projection. A full-precision action head produces continuous action chunks.

Linear weights in the vision and language backbones use an absolute-mean scale and ternary rounding; activations use a per-token absolute-maximum scale and symmetric INT8 quantization. Input/output embeddings, connector and action head are exceptions to the broad “every parameter is ternary” wording elsewhere. BitBLAS supplies the custom multiplication kernel.

Equation 4 is preserved exactly as printed, with scale 127α/β. Given the quantizer definitions in Equations 1–2, ordinary inverse scaling would instead involve αβ/127; the manuscript does not explain this discrepancy. This edition does not silently alter the source formula.

Equations 1–4
Qw​(W)=RoundClip⁡(Wα,−1,1),α=1n​m​∥W∥1,\displaystyle Q_{w}(W)=\mathrm{RoundClip}\left(\frac{W}{\alpha},-1,1\right),\quad\alpha=\frac{1}{nm}\lVert W\rVert_{1}, (1)
Qa​(x)=RoundClip⁡(127​xβ,−128,127),β=∥x∥∞,\displaystyle Q_{a}(x)=\mathrm{RoundClip}\left(\frac{127x}{\beta},-128,127\right),\quad\beta=\lVert x\rVert_{\infty}, (2)
RoundClip⁡(x,a,b)=max⁡(a,min⁡(b,round⁡(x))),\displaystyle\mathrm{RoundClip}(x,a,b)=\max\bigl(a,\min(b,\mathrm{round}(x))\bigr), (3)
Y=127​αβ​Qw​(W)​Qa​(x),Y=\cfrac{127\alpha}{\beta}Q_{w}(W)Q_{a}(x), (4)
Complete original Figure 3.
Fig. 3: Overview of the forward computation for a linear transformation in BitVLA. After training, weights are offline quantized to ternary values. During inference, we online quantize activations to INT8 and invoke a custom kernel to multiply ternary weights with INT8 inputs. We then apply per-element scaling factors α\alpha and β\beta to rescale the output to full precision.

III-B Training Paradigm

Training first builds a multimodal initialization, then updates a quantized vision student against a fixed teacher, and finally learns robot action prediction. Different modules are frozen at each stage to limit disruptive representation changes.

Multimodal Training

Following LLaVA, the first stage trains only the connector on image captions to align visual and language spaces. Instruction tuning then freezes the vision encoder and updates the language backbone and connector. The vision encoder is still full precision at this point.

Quantize-then-Distill

The vision student starts from the full-precision encoder and uses ternary weights, INT8 activations and a straight-through gradient approximation. Only this student is updated; the teacher, language model and connector remain fixed.

The objective combines answer-token language cross-entropy with mean squared alignment of teacher/student hidden states across layers. Instruction and visual tokens provide context but do not contribute directly to the language loss. The alignment weight is 0.1 in the reported setup. Table III isolates a large benefit from this auxiliary loss at a fixed five-billion-token budget.

Equations 5–7
ℒtotal=ℒLM+λ​ℒaux,\mathcal{L}_{\text{total}}=\mathcal{L}_{\text{LM}}+\lambda\,\mathcal{L}_{\text{aux}}, (5)
ℒLM=−∑i∈𝒯anslogp(yi|𝒱1.58,𝒯<i),\mathcal{L}_{\text{LM}}=-\sum_{i\in\mathcal{T}_{\text{ans}}}\log p\!\left(y_{i}\,\middle|\,\mathcal{V}_{\text{1.58}},\mathcal{T}_{<i}\right), (6)
ℒaux=1L​∑l=1L1n​‖hbf16l−h1.58l‖22,\mathcal{L}_{\text{aux}}=\frac{1}{L}\sum_{l=1}^{L}\frac{1}{n}\left\|h^{l}_{\text{bf16}}-h^{l}_{\text{1.58}}\right\|_{2}^{2}, (7)
TABLE I: Success rates (%) on LIBERO simulation. Comparison between BitVLA and prior VLA baselines (reported from their original papers). Models are grouped by parameter count (Large vs. Small).
Models Size Memory Usage↓\downarrow Spatial Object Goal Long Average
Large OpenVLA [17] 7.5B 15.1GB (10.79×10.79\times) 84.7 88.4 79.2 53.7 76.5
CoT-VLA [53] 8.0B 16.2GB (11.57×11.57\times) 87.5 91.6 87.6 69.0 81.1
UniVLA [6] 8.5B 17.0GB (12.14×12.14\times) 96.5 96.8 95.6 92.0 95.2
UnifiedVLA [44] 8.5B 17.0GB (12.14×12.14\times) 95.4 98.8 93.6 94.0 95.5
OpenVLA-OFT [18] 7.7B 15.4GB (11.00×11.00\times) 97.6 98.4 97.9 94.5 97.1
Small SpatialVLA [34] 4.2B 8.5GB (6.07×6.07\times) 88.2 89.9 78.6 55.5 78.1
NORA-Long [13] 3.8B 7.5GB (5.36×5.36\times) 92.2 95.4 89.4 74.6 87.9
4D-VLA [50] 4.1B 8.3GB (5.93×5.93\times) 88.9 95.2 90.9 79.1 88.6
SmolVLA [35] 2.3B 4.6GB (3.29×3.29\times) 93.0 94.0 91.0 77.0 88.8
GROOT-N1 [3] 2.2B 4.4GB (3.14×3.14\times) 94.4 97.6 93.0 90.6 93.9
π0\pi_{0} [4] 3.5B 7.0GB (5.00×5.00\times) 96.8 98.8 95.8 85.2 94.2
BitVLA w/o pre-training 3.0B 1.4GB (1.00×1.00\times) 97.4 99.6 94.4 87.6 94.8
BitVLA 3.0B 1.4GB (1.00×1.00\times) 96.6 99.0 95.4 92.8 96.0
TABLE II: Success rates (%) on LIBERO simulation. Comparison between BitVLA and OpenVLA, OpenVLA-OFT under post-training quantization (INT8/INT4). BitVLA achieves competitive performance with a 1.4 GB memory footprint.
Models Memory Usage↓\downarrow Spatial Object Goal Long Avg.
INT8 post-training quantization
OpenVLA [17] 7.4GB (5.29×5.29\times) 86.4 85.2 77.2 58.8 76.9
OpenVLA-OFT [18] 7.7GB (5.50×5.50\times) 98.8 98.0 96.6 94.0 96.7
INT4 post-training quantization
OpenVLA [17] 4.4GB (3.14×3.14\times) 83.0 84.0 72.0 51.6 72.7
OpenVLA-OFT [18] 4.7GB (3.36×3.36\times) 98.2 98.2 97.2 93.8 96.9
BitVLA (ours) 1.4GB (1.00×1.00\times) 96.6 99.0 95.4 92.8 96.0

Robotics Training

Robot pretraining follows OpenVLA: discretize each action dimension into 256 bins and optimize autoregressive next-action cross-entropy on an Open X-Embodiment-derived corpus. The source describes its size as roughly one million samples in the method, but calls them trajectories in the introduction; the unit is not consistent.

Downstream supervised finetuning changes to parallel chunk prediction with an L1 action loss, following OpenVLA-OFT. BitVLA retains causal attention because the tested bidirectional alternative harmed real-world performance; this also permits FlashAttention. Parallel chunk output should not be confused with a bidirectional language backbone.

Equation 8
ℒact=∑k=0h‖a^t+k−at+k‖1.\mathcal{L}_{\text{act}}=\sum_{k=0}^{h}\left\lVert\hat{a}_{t+k}-a_{t+k}\right\rVert_{1}. (8)
Complete original Figure 4.
Fig. 4: Real-world robot experiments. We evaluate three tasks: “Grasp the watermelon on the table,” “Put the bread into the basket,” and “Flip the bell upright” to assess three axes of policy capability. BitVLA outperforms π0\pi_{0} on all three tasks and achieves performance comparable to the larger OpenVLA-OFT model.

IV Experiments

Experiments evaluate simulation success, physical manipulation, model-memory footprint, server-GPU inference and retained multimodal representation quality. Their different protocols and comparison sources matter when interpreting the headline ratios.

IV-A Pre-training Setup

Multimodal alignment uses LLaVA-1.5-558k, followed by a ten-million-example single-image MammoTH-VL subset. Vision quantization uses five million examples and up to ten billion tokens. These VLM stages take seven days on eight 80-GB H800 GPUs.

Robot pretraining uses a batch of 2,048 for 200,000 steps, with peak learning rates 3×10⁻⁴ for the language model and 10⁻⁴ for vision. It is reported to take fourteen days on sixteen H800s. Compact deployment therefore follows substantial training compute; the memory saving is not a claim of cheap pretraining.

IV-B Experiments on Simulation Environment

LIBERO evaluation uses wrist and external images plus a projected state token, with eight-action chunks executed before replanning. Spatial, Object and Goal finetuning runs for 10,000 steps; Long uses 100,000. The appendix selects the best of three learning rates for the first three suites.

BitVLA averages 96.0% across suites versus OpenVLA-OFT’s 97.1%. Robot pretraining improves Long from 87.6% to 92.8%, although Spatial and Object scores decrease slightly. Many Table I baseline numbers are taken from their original papers rather than reproduced under one common run.

The separately tested post-training-quantized OpenVLA-OFT reaches 96.7% with INT8 at 7.7 GB and 96.9% with INT4 at 4.7 GB, versus BitVLA’s 96.0% at 1.4 GB. BitVLA prioritizes a smaller footprint with a modest mean-success tradeoff. A four-GB laptop GPU is cited as a feasible deployment target, but its latency is not measured here.

Complete original Figure 5.
Fig. 5: Real-world robot experiments on out-of-distribution tasks. We evaluate policy generalization on three tasks with diverse instructions or visual robustness: “Grasp the watermelon on the table,” “Put the bread into the basket,” and “Flip the bell upright.” All models are evaluated zero-shot.
Complete original Figure 6.
Fig. 6: Inference efficiency results. BitVLA achieves 73 ms latency and 341.1 Hz throughput, outperforming OpenVLA-OFT+ by 4.4×\times lower latency and 4.4×\times higher throughput, and also exceeding π0\pi_{0} in both metrics.

IV-C Experiments on Real-world Tasks

Physical experiments use a seven-DoF Franka arm, an external RealSense D435i camera and proprioception. Each base task has 50 teleoperated demonstrations, finetuning on an H800, and evaluation over a 4×5 workspace grid. Inference runs remotely on an A800 server; the robot retrieves action chunks over a network.

For watermelon grasping, bread placement and bell flipping, Figure 4 reports BitVLA scores of 85%, 80% and 50%; OpenVLA-OFT gives 75%, 95% and 65%, and π₀ gives 75%, 70% and 45%. The latter two tasks award partial credit for grasping, so these percentages are not uniformly binary completion rates.

Zero-shot shifted tests replace objects or add a tablecloth. BitVLA scores 75%, 60% and 40%, compared with OpenVLA-OFT’s 55%, 77.5% and 55%; gains are not uniform. The no-pretraining variant is mostly near zero. These narrow tests support some transfer, not broad deployment robustness.

A separate efficiency test uses an A100, three 224×224 images, a 14-dimensional state, a fixed task command and 25-action chunks, averaged over 100 queries. BitVLA takes 73 ms and reports 341.1 action outputs/s, compared with OpenVLA-OFT+ at 321 ms and 77.9/s; baseline values come from the cited OFT study. Chunk throughput is not the closed-loop control frequency or a measurement of network-inclusive robot latency.

TABLE III: Zero-shot accuracy on multimodal benchmarks. The Quantize-then-distill stage preserves the multimodal ability while reducing the memory footprint from 0.8GB to 0.1GB. Then we conduct ablations on data size and representation alignment loss of Quantize-then-distill stage. WBits and ABits denote the bit-width of weight and activations, respectively.
WBits ABits ViT Memory Usage
(GB)
Training Tokens
(Stage III)
ℒa​u​x\mathcal{L}_{aux} MMMU
(val)
SeedBench
(image)
SeedBench2+
(test)
MMStar
(test)
AI2D
(test)
Average
BF16 BF16 0.8GB (8.00×8.00\times) - - 37.4 70.6 45.0 43.6 68.6 53.0
1.58-bit INT8 0.1GB (1.00×1.00\times) 10B ✓ 35.4 69.3 43.7 41.5 67.6 51.5
1.58-bit INT8 0.1GB (1.00×1.00\times) 5B ✓ 33.3 69.1 43.3 41.4 66.4 50.8
1.58-bit INT8 0.1GB (1.00×1.00\times) 5B ✗ 32.4 52.9 38.8 30.7 57.5 42.4
Complete original Figure 7.
Fig. 7: t-SNE visualization of full-precision and 1.58-bit vision encoders on the COCO dataset [23]. As the network depth increases, the internal representations of the 1.58-bit vision encoder become increasingly aligned with those of the full-precision encoder. This result validates the effectiveness of the proposed distillation-aware training strategy.

V Analysis

Quantize-then-Distill reduces the vision encoder footprint from 0.8 to 0.1 GB. Across five zero-shot visual-question-answering benchmarks, average accuracy changes from 53.0% in full precision to 51.5% after ten-billion-token distillation. At five billion tokens, alignment improves 42.4% to 50.8%, and more data increases it to 51.5%.

The t-SNE diagnostic uses up to 50 COCO-validation images in each of 15 categories. Joint teacher/student projections from layers 0, 12 and 26 show closer paired embeddings at greater depth. This qualitative two-dimensional projection is consistent with alignment, but is not a quantitative guarantee of preserved geometry or robot-task performance.

VI Discussion and Limitations

Ternary-by-INT8 projections can replace many floating-point multiply–accumulates with integer additions and sign operations, leaving scaling work. The O(n²) accumulation workload itself remains; the claimed O(n) floating-point scaling argument concerns a single projection, not the entire transformer or all deployment costs.

No end-to-end power measurement or edge-device timing is reported. The method depends on quantization-aware training and the native low-bit backbone, so arbitrary full-precision models may not tolerate the same compression. Broader tasks, environments and embodiments need more evidence beyond the roughly one-million-example robot corpus.

VII Conclusion

BitVLA shows that a ternary language backbone and distilled low-bit vision encoder can support competitive manipulation while substantially reducing reported model memory. The tested policy trades a small LIBERO mean-success reduction for a much smaller footprint.

The result is strongest as evidence for low-bit training and server inference. Some modules remain full precision, real-world task scores include partial credit, and the hardware/benchmark conditions limit stronger claims of uniform accuracy preservation or ready-made edge deployment.

Details of Real-world Experiments

Watermelon grasping is trained for 30,000 steps and allows 500 inference steps, with binary secure-lift success. Bell flipping uses 50,000 training steps and a 600-step budget; grasping alone earns 0.5 and a complete flip earns 1. Bread-to-basket uses 50,000 steps and a 500-step budget, with the same partial-credit structure.

The sponge substitution uses the grasp task’s 500-step budget. Bell with a tablecloth extends the budget to 1,000; watermelon-to-basket uses 500. The main text says all shifted variants receive no additional finetuning, while two appendix descriptions repeat 50,000 training steps; these appear to refer to their base-task models, but the wording is ambiguous. Different inference budgets also affect comparisons.

Hyper-parameters

Tables IV–V retain complete multimodal-stage and LIBERO finetuning settings. Visual instruction tuning decays weight decay from 0.1 to zero; the quantized-vision stage uses 0.01. The three VLM stages run for 25k, 40k and 20k steps with batch size 256.

Spatial, Object and Goal select the best learning rate from 5×10⁻⁵, 10⁻⁴ and 3×10⁻⁴. Long uses 4×10⁻⁴ for the language model and 8×10⁻⁵ for vision. The reported performance therefore includes learning-rate selection, not a single universally fixed finetuning setting.

TABLE IV: Hyper-parameters for the training of BitVLA.
Hyper-parameter Stage I Stage II Stage III
Peak Learning rate 1e-3 3e-4 1e-4
Batch Size 256 256 256
Weight decay ✗ 0.1→\rightarrow 0 0.01
Trainable modules Connector LLM, Connector ViT
Training steps 25k 40k 20k
Training sequence 1024 2048 2048
Vision sequence 256
Learning rate scheduling polynomial decay
AdamW β\beta (0.9, 0.999)
AdamW ϵ\epsilon 1e-8
Gradient Clipping 1.0
Dropout ✗
Attention Dropout ✗
TABLE V: Hyper-parameters for the fine-tuning of BitVLA on LIBERO dataset.
Hyper-parameter Spatial Object Goal Long
Peak Learning rate {5e-5, 1e-4, 3e-4} 4e-4,8e-5
Training steps 10k 10k 10k 100k
Learning rate scheduling cosine decay
Warmup steps 375
Batch Size 64
Weight decay 0.01
Trainable modules LLM, Connector, ViT
AdamW β\beta (0.9, 0.999)
AdamW ϵ\epsilon 1e-8
Gradient Clipping ✗

Tasks in LIBERO

The four LIBERO suites emphasize spatial arrangements, object identities, goal instructions and longer task sequences. Each contains ten tasks and 500 expert demonstrations according to this source. Table VI preserves every task instruction, and Figure 8 retains all ten illustrated examples.

These suites characterize the evaluation setting; the paper finetunes on each suite, so “generalization” here should not be read as zero-shot performance on every listed task.

TABLE VI: Task description in LIBERO benchmark task suites.
Task suite Task description
Spatial pick up the black bowl between the plate and the ramekin and place it on the plate
pick up the black bowl next to the ramekin and place it on the plate
pick up the black bowl from table center and place it on the plate
pick up the black bowl on the cookie box and place it on the plate
pick up the black bowl in the top drawer of the wooden cabinet and place it on the plate
pick up the black bowl on the ramekin and place it on the plate
pick up the black bowl next to the cookie box and place it on the plate
pick up the black bowl on the stove and place it on the plate
pick up the black bowl next to the plate and place it on the plate
pick up the black bowl on the wooden cabinet and place it on the plate
Object pick up the alphabet soup and place it in the basket
pick up the cream cheese and place it in the basket
pick up the salad dressing and place it in the basket
pick up the bbq sauce and place it in the basket
pick up the ketchup and place it in the basket
pick up the tomato sauce and place it in the basket
pick up the butter and place it in the basket
pick up the milk and place it in the basket
pick up the chocolate pudding and place it in the basket
pick up the orange juice and place it in the basket
Goal open the middle drawer of the cabinet
put the bowl on the stove
put the wine bottle on top of the cabinet
open the top drawer and put the bowl inside
put the bowl on top of the cabinet
push the plate to the front of the stove
put the cream cheese in the bowl
turn on the stove
put the bowl on the plate
put the wine bottle on the rack
Long put both the alphabet soup and the tomato sauce in the basket
put both the cream cheese box and the butter in the basket
turn on the stove and put the moka pot on it
put the black bowl in the bottom drawer of the cabinet and close it
put the white mug on the left plate and put the yellow and white mug on the right plate
pick up the book and place it in the back compartment of the caddy
put the white mug on the plate and put the chocolate pudding to the right of the plate
put both the alphabet soup and the cream cheese box in the basket
put both moka pots on the stove
put the yellow and white mug in the microwave and close it
Complete original Figure 8.
Fig. 8: Examples in LIBERO benchmark tasks suites.
Concept demonstration

Open image ↗