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.
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.
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
| (1) | ||||
| (2) | ||||
| (3) |
| (4) |
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
| (5) |
| (6) |
| (7) |
| Models | Size | Memory Usage | Spatial | Object | Goal | Long | Average | |
| Large | OpenVLA [17] | 7.5B | 15.1GB () | 84.7 | 88.4 | 79.2 | 53.7 | 76.5 |
| CoT-VLA [53] | 8.0B | 16.2GB () | 87.5 | 91.6 | 87.6 | 69.0 | 81.1 | |
| UniVLA [6] | 8.5B | 17.0GB () | 96.5 | 96.8 | 95.6 | 92.0 | 95.2 | |
| UnifiedVLA [44] | 8.5B | 17.0GB () | 95.4 | 98.8 | 93.6 | 94.0 | 95.5 | |
| OpenVLA-OFT [18] | 7.7B | 15.4GB () | 97.6 | 98.4 | 97.9 | 94.5 | 97.1 | |
| Small | SpatialVLA [34] | 4.2B | 8.5GB () | 88.2 | 89.9 | 78.6 | 55.5 | 78.1 |
| NORA-Long [13] | 3.8B | 7.5GB () | 92.2 | 95.4 | 89.4 | 74.6 | 87.9 | |
| 4D-VLA [50] | 4.1B | 8.3GB () | 88.9 | 95.2 | 90.9 | 79.1 | 88.6 | |
| SmolVLA [35] | 2.3B | 4.6GB () | 93.0 | 94.0 | 91.0 | 77.0 | 88.8 | |
| GROOT-N1 [3] | 2.2B | 4.4GB () | 94.4 | 97.6 | 93.0 | 90.6 | 93.9 | |
| [4] | 3.5B | 7.0GB () | 96.8 | 98.8 | 95.8 | 85.2 | 94.2 | |
| BitVLA w/o pre-training | 3.0B | 1.4GB () | 97.4 | 99.6 | 94.4 | 87.6 | 94.8 | |
| BitVLA | 3.0B | 1.4GB () | 96.6 | 99.0 | 95.4 | 92.8 | 96.0 |
| Models | Memory Usage | Spatial | Object | Goal | Long | Avg. |
| INT8 post-training quantization | ||||||
| OpenVLA [17] | 7.4GB () | 86.4 | 85.2 | 77.2 | 58.8 | 76.9 |
| OpenVLA-OFT [18] | 7.7GB () | 98.8 | 98.0 | 96.6 | 94.0 | 96.7 |
| INT4 post-training quantization | ||||||
| OpenVLA [17] | 4.4GB () | 83.0 | 84.0 | 72.0 | 51.6 | 72.7 |
| OpenVLA-OFT [18] | 4.7GB () | 98.2 | 98.2 | 97.2 | 93.8 | 96.9 |
| BitVLA (ours) | 1.4GB () | 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
| (8) |
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.
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.
| WBits | ABits |
ViT Memory Usage (GB) |
Training Tokens (Stage III) |
MMMU (val) |
SeedBench (image) |
SeedBench2+ (test) |
MMStar (test) |
AI2D (test) |
Average | |
| BF16 | BF16 | 0.8GB () | - | - | 37.4 | 70.6 | 45.0 | 43.6 | 68.6 | 53.0 |
| 1.58-bit | INT8 | 0.1GB () | 10B | ✓ | 35.4 | 69.3 | 43.7 | 41.5 | 67.6 | 51.5 |
| 1.58-bit | INT8 | 0.1GB () | 5B | ✓ | 33.3 | 69.1 | 43.3 | 41.4 | 66.4 | 50.8 |
| 1.58-bit | INT8 | 0.1GB () | 5B | ✗ | 32.4 | 52.9 | 38.8 | 30.7 | 57.5 | 42.4 |
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.
| 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 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 | (0.9, 0.999) | ||
| AdamW | 1e-8 | ||
| Gradient Clipping | 1.0 | ||
| Dropout | ✗ | ||
| Attention Dropout | ✗ | ||
| 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 | (0.9, 0.999) | |||
| AdamW | 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.
| 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 |