OpenVLA
Open-source 7B-class VLA from Stanford, UC Berkeley, Google DeepMind and TRI: a Prismatic VLM (fused DINOv2 + SigLIP vision encoder, Llama 2 language model) fine-tuned on Open X-Embodiment to emit robot actions as discrete language tokens (256 bins per action dimension), one 7-DoF end-effector delta per step.
7.5B paramsopen weightsverified 2026-10-24paper →
Architecture
- Family
- vla
- Parameters
- 7,500,000,000 (README says fully fine-tuning touches 'all 7.5 billion parameters'; the paper calls it a '7B-parameter' VLA.)src
- Backbone
- Prismatic VLM (DINOv2 + SigLIP fused vision encoder, Llama 2 language model)src
- Action head
- autoregressive-tokenssrc
- Action chunking
- no
- Code license
- MIT
- Weights license
- MIT (model card); README notes the weights are derived from Llama 2 and subject to the Llama Community License
- Cameras
- min 1 · max 1src
- Language input
- required
Compute requirements
| Memory | Precision | Conditions | |
|---|---|---|---|
| train | ≥27 GB · ≤72 GBsrc | — | Upstream openvla README, LoRA fine-tuning of openvla-7b with vla-scripts/finetune.py (LoRA rank 32): batch_size 16 with grad_accumulation_steps 1 needs ~72 GB; a smaller GPU works if it has at least ~27 GB, by reducing the batch size. Full fine-tuning instead uses FSDP (e.g. a node of 8 A100s). Precision not stated in that section. |
| inference | 15 GB measuredsrc | bf16 | OpenVLA paper: 15 GB GPU memory when loaded in bfloat16 without quantization; runs at about 6 Hz on one RTX 4090 without compilation or other speed-ups. Batch size not stated. |
Training requirements: see also the LeRobot compute hardware guide, the authoritative source for LeRobot training envelopes.
Measured inference 0 runs · inference cost only, not task success
No measured runs yet. Submit one with its runtime, precision and camera count.
Robots running OpenVLA 4 of 24 with evidence
| Robot | State | Tier | Verified | Detail |
|---|---|---|---|---|
| ALOHA (stationary) | partial | T3 · community reported | 2026-10-25 today | Training evidenced by public checkpoint(s); on-robot inference not documented by a primary source. |
| Franka Emika Panda | works with caveats | T1 · upstream documented | 2026-10-24 1d ago | Panda results come from fine-tuning (10-150 demonstrations per task), not out-of-the-box use. The OpenVLA repo ships no Franka controller or deployment script. |
| Koch v1.1 | partial | T3 · community reported | 2026-10-24 1d ago | Training evidenced by public checkpoint(s); on-robot inference not documented by a primary source. |
| WidowX 250 S | works | T1 · upstream documented | 2026-10-24 1d ago |
Framework support
Checkpoints
- openvla/openvla-7b · Flagship model from the paper (MIT tag on the Hub).
Related terms
Action tokenization · Parameter-efficient fine-tuning (PEFT) and LoRA · Quantization and numeric precision · Vision-language-action model
Sources
- T1 · upstream documentedofficial-docssource 2025-03-23verified 2026-10-24 (1d ago)
Upstream README states the full model has 7.5 billion parameters.
“fully fine-tuning</ins> OpenVLA (all 7.5 billion parameters) via native PyTorch Fully Sharded Data Parallel (FSDP)”
https://github.com/openvla/openvla/blob/c8f03f48af692657d3060c19588038c7220e9af9/README.md - T1 · upstream documentedofficial-docssource 2025-03-23verified 2026-10-24 (1d ago)
LoRA fine-tuning needs ~27 GB minimum; batch 16 without accumulation needs ~72 GB.
“requires ~72 GB GPU memory. If you have a smaller GPU, you should reduce `--batch_size` and increase `--grad_accumulation_steps`”
https://github.com/openvla/openvla/blob/c8f03f48af692657d3060c19588038c7220e9af9/README.md - T1 · upstream documentedofficial-docssource 2025-03-23verified 2026-10-24 (1d ago)
LoRA fine-tuning works on GPUs with at least ~27 GB.
“(You can also fine-tune with a smaller GPU, as long as it has at least ~27 GB of memory,”
https://github.com/openvla/openvla/blob/c8f03f48af692657d3060c19588038c7220e9af9/README.md - T1 · upstream documentedofficial-docssource 2025-03-23verified 2026-10-24 (1d ago)
Code is MIT; pretrained models derive from Llama 2 and inherit the Llama Community License restrictions.
“above models are derived from Llama-2, and as such are subject to the”
https://github.com/openvla/openvla/blob/c8f03f48af692657d3060c19588038c7220e9af9/README.md - T1 · upstream documentedpapersource 2024-06-13verified 2026-10-24 (1d ago)
OpenVLA maps each continuous action dimension to one of 256 discrete token bins.
“we discretize each dimension of the robot actions separately into one of 256 bins.”
https://arxiv.org/abs/2406.09246 - T1 · upstream documentedpapersource 2024-06-13verified 2026-10-24 (1d ago)
Inference needs 15 GB in bfloat16 and runs at ~6 Hz on an RTX 4090.
“During inference, OpenVLA requires 15GB of GPU memory when loaded in bfloat16 precision (i.e., without quantization) and runs at approximately 6Hz on one NVIDIA RTX 4090 GPU”
https://arxiv.org/abs/2406.09246 - T1 · upstream documentedmodel-cardverified 2026-10-24 (1d ago)
Model card - inputs are a language instruction and one camera image; outputs 7-DoF end-effector deltas.
“OpenVLA models take a language instruction and a camera image of a robot workspace as input, and predict (normalized) robot actions consisting of 7-DoF end-effector deltas”
https://huggingface.co/openvla/openvla-7b