2026 VLA Model Comparison: OpenVLA, π0, GR00T, SmolVLA

There's no single best vision-language-action (VLA) model. The right one depends on three things, in order: whether you can get the weights, whether they fit your GPU, and whether your data looks like the data the model learned from. The open-weights shortlist is OpenVLA and OpenVLA-OFT, π0 and π0.5 (pi0, pronounced pi-zero) through openpi, SmolVLA, NVIDIA Isaac GR00T N1.7, and MolmoAct 2.

This guide compares what each model expects from your robot, how much GPU memory it needs, what it trained on, and what its LIBERO score measures. Every fact links to a primary source. Verified November 2026.

Key takeaways

Open-weight VLA models you can download are OpenVLA, OpenVLA-OFT, Octo, the π0 family through π0.5, SmolVLA, GR00T N1.7, MolmoAct 2, and Alpamayo.
On a single 24 GB card, SmolVLA fits, and π0 or π0.5 fit with low-rank adaptation (LoRA) in openpi's JAX path. OpenVLA does not.
LIBERO scores for VLA models from different papers aren't comparable, and every headline number stands on a cleaned copy of the benchmark.
Look at your VLA training demonstrations before you spend GPU hours. The fine-tuning failures documented in the OpenVLA, openpi, SmolVLA, and MolmoAct 2 repos are mostly data problems.

What is a VLA model?

A VLA model turns camera images and a language instruction into robot actions, usually by adding an action output (discrete tokens or a continuous action head) to a pretrained vision-language model. Architecture details are in our VLA glossary entry.

VLA models at a glance

Model family	Developer	Open weights and license	Size	Action output	Trained on
RT-2 (Jul 2023, no later version)	Google DeepMind	No	Up to 55B	Discrete tokens	Web vision-language data plus RT-1's robot demonstrations
OpenVLA (Jun 2024) and OpenVLA-OFT (Feb 2025)	Stanford-led	Yes. MIT code, Llama 2 Community License on weights	7B	Tokens (OpenVLA), continuous chunks (OFT)	970k Open X-Embodiment episodes
Octo (Dec 2023, latest 1.5 in May 2024)	UC Berkeley-led	Yes, MIT	27M and 93M	Diffusion head	800k Open X-Embodiment trajectories
π0 family (Oct 2024, latest π0.7 in Apr 2026)	Physical Intelligence	π0, π0-FAST, and π0.5 through openpi (Apache 2.0 repo). Newer models: Pi API only	π0: 3.3B. π0.7: 5B	Flow matching (FAST tokens in π0-FAST)	10k+ hours, mostly its own robots, plus Open X-Embodiment and DROID (π0)
SmolVLA (Jun 2025)	Hugging Face	Yes, Apache 2.0	450M	Flow matching	481 community LeRobot datasets, 22.9K episodes
GR00T N1 family (Mar 2025, latest N1.7 in Apr 2026)	NVIDIA	Yes. N1.7: NVIDIA Open Model License, commercial use allowed. N1 to N1.6: non-commercial	N1.7: 3B	Flow matching	N1.7: 21.6M data points, 13 datasets, 20K hours of human video
Gemini Robotics (Mar 2025, latest 2 in Jul 2026)	Google DeepMind	No. Early-access partners	Not published	Continuous values	Not published
Helix (Feb 2025, latest 2.5 in Sep 2026)	Figure AI	No	7B VLM plus 80M policy (original). 2.5: not published	Continuous	Not published
MolmoAct (Aug 2025, latest 2 in May 2026)	Ai2	Yes, Apache 2.0	5B (v2)	Tokens (v1), flow matching (v2)	SO-100/101, DROID, MolmoAct, BC-Z, Bridge, RT-1 (v2)
Alpamayo (Oct 2025, latest 2 Super in Aug 2026)	NVIDIA	Yes, OpenMDW-1.1	34B (2 Super)	Driving trajectory plus reasoning text	~115,000 hours of driving video, 3.7M reasoning traces (2 Super)

Notable VLA model families in 2026, with developer, open weights and license, size, action output, and training data. Verified November 3, 2026.

How to choose a VLA model

Work through access, GPU, data format, and control rate, in that order. Then start here:

Open weights, one consumer GPU: SmolVLA first. π0 or π0.5 with LoRA through openpi, JAX path only. OpenVLA's LoRA floor is above 24 GB.
Humanoid on the NVIDIA stack: GR00T N1.7.
Strongest generalization, and an API is fine: Physical Intelligence's newer models through the Pi API.
Driving: Alpamayo.

Which VLA for LeRobot and SO-101 arms

SmolVLA is native to LeRobot. GR00T N1.7 ships as the groot policy type with an SO100 example, and openpi fine-tunes π0 and π0.5 from LeRobot datasets. MolmoAct 2 trained on SO-100 and SO-101 data, joined LeRobot in May 2026, and works out of the box on an SO-100 for simple in-distribution tasks, Ai2 says.

Fine-tuning open VLAs: what fits your robot and your GPU

Control rate, chunk size, and latency trade against each other: OpenVLA predicts one action per call and wants 5 to 10 Hz data, OpenVLA-OFT predicts 25-step chunks on ALOHA, and π0 predicts 50-step chunks at up to 50 Hz.

Does it fit your robot? Cameras, state, action output, data format

Model	Camera inputs	Proprioceptive state in?	Action space, output, and chunk	Inference rate (GPU)	Data format
OpenVLA	1 third-person image	No	Delta end-effector actions, 7 degrees of freedom, 256-bin tokens, chunk 1	~6 Hz bfloat16 (RTX 4090). 4.2 Hz (A100, OFT paper)	RLDS
OpenVLA-OFT	Third-person + wrist	Yes	Continuous (L1 head), parallel decoding, chunk 8 (LIBERO) or 25 (ALOHA)	71.4 Hz throughput, 0.112 s latency (A100, LIBERO)	RLDS
π0 / π0.5 (openpi)	2 to 4 RGB (wrist + base or exterior)	Yes	Joint or end-effector actions per platform, flow matching, chunk 50	Up to 50 Hz control. GPU rate not published	LeRobot datasets + norm stats
SmolVLA	Up to 3 (top, wrist, side)	Yes	Flow matching, chunk 50	Not published. Async inference ~30% faster on SO-100	LeRobotDataset v3
GR00T N1.7	Any count, set in modality.json	Yes	Relative end-effector actions, flow-matching diffusion transformer, executes 8 to 16 per call	27.9 ms, ~36 Hz (H100 or RTX PRO 6000, TensorRT). 12.4 Hz (Jetson AGX Thor)	LeRobot v2 + modality.json
MolmoAct 2	2 (external + wrist) or 3 (YAM, order matters)	Yes	Absolute joint pose on real robots, flow matching, chunk 10 (LIBERO)	Not published	LeRobot v3 + norm stats

Open VLA models by camera inputs, proprioceptive state, action space and chunk size, inference rate, and data format. Model names link to sources.

VLA fine-tuning GPU requirements: VRAM, steps, and hours

Here is the minimum GPU memory each open VLA needs to fine-tune, and how long a typical run takes, from its own repo or paper.

Model	Method	VRAM floor	Typical run	Source
OpenVLA	LoRA r=32	~27 GB (small batch). ~60 to 72 GB at batch 16	10 to 15 h per task on one A100	README, paper
OpenVLA	Full	8-A100 node	5 to 15 h per task	paper
OpenVLA-OFT	LoRA r=32	~25 GB at batch 1. ~62 GB at batch 8 per GPU	50K to 150K steps on 8 A100s or H100s	LIBERO.md
π0 / π0.5 (openpi)	LoRA (JAX only)	>22.5 GB (RTX 4090)	30k steps (LIBERO checkpoint). Wall-clock not published	README
π0 / π0.5 (openpi)	Full	>70 GB (A100 80GB or H100)	Not published	README
SmolVLA	Full (action expert)	Single GPU. No floor published, Colab offered	20k steps ≈ 4 h on one A100	LeRobot docs
GR00T N1.7	Full	40 GB+ recommended	2,000 steps at batch 32 (example). "A few thousand steps"	README
MolmoAct 2	LoRA (default) or full	Not published	10k steps on 8 H100s for LIBERO. LoRA at batch 16 to 32 under 200 demos	LeRobot docs

Fine-tuning GPU memory floors and typical run lengths for open VLA models, from each model's own repo or paper.

GR00T N1.7 also needs Hugging Face access to its gated Cosmos-Reason2-2B backbone, even for the base model.

Starting checkpoints matter too. openpi can reload its pretraining norm stats for robots in its mixture, MolmoAct 2 says to start from its fine-tuned checkpoint if your embodiment is similar, and GR00T matches robots through embodiment tags.

Before you fine-tune, look at the data

Every model above learns from episodes: camera frames, robot state (proprioception), actions, an instruction, and an outcome. They come in three formats: Reinforcement Learning Datasets (RLDS) for the Open X-Embodiment family, LeRobotDataset v3 for most of the rest, and LeRobot v2 plus modality.json for GR00T. Format is the easy part. Four other things break fine-tuning, and none shows up in a loss curve.

A benchmark score is a data decision. Before training on LIBERO, OpenVLA's authors replayed every demonstration in the simulator and dropped the ones that failed: 307 of 2,000 across the four suites. They also dropped no-op steps, re-rendered at 256x256, and rotated images 180 degrees to fix an upside-down render. OpenVLA-OFT and openpi fine-tune on that same cleaned set, openvla/modified_libero_rlds, so the 76.5, 97.1, and 96.85 all stand on it, and raw LIBERO won't reproduce them. Same lesson for your data: OpenVLA's README warns that idle frames make the model "get stuck," so record at 5 to 10 Hz without pauses.

Normalization stats. OpenVLA bins each action dimension between the 1st and 99th percentile of its training data and un-normalizes with unnorm_key. openpi won't train until you run compute_norm_stats.py, and its README flags diverging loss from tiny q01, q99, or std values on rarely used dimensions. MolmoAct 2's LeRobot docs warn that the LIBERO quantiles on the Hub don't match its released stats.

Camera names. SmolVLA's authors found community datasets using images.laptop for a top, side, or wrist view, and mapped every camera to a fixed order by hand. GR00T declares the mapping in modality.json, LeRobot uses --rename_map, and MolmoAct 2 says camera order matters.

Gripper and sign conventions. OpenVLA's loader aligns grippers to 0 = close, 1 = open, and its LIBERO eval flips the sign because the simulator wants -1 = open, +1 = close. openpi's robots use 0.0 = open, 1.0 = closed. MolmoAct 2's SO-100 checkpoint needs a shoulder sign flip and 90-degree offsets after a LeRobot calibration change, or "the arm may move in the wrong direction." SmolVLA's docs add one more: use the task description you recorded with.

All of these show up when you open the episodes.

Look at it in a free Voxel51 workspace

Fine-tuning SmolVLA, π0, or MolmoAct 2 on your own LeRobot dataset? Add it to a free Voxel51 workspace and look before you train. The free plan holds 3 datasets of up to 10,000 samples each, and for LeRobot datasets one sample equals one episode. Storage is capped at 20 GB, which most video datasets hit first.

Or start with the data these models use:

LIBERO: 1,693 episodes (3,386 grouped samples, one per camera view), the same count as the filtered set behind those scores. Compare the agent and wrist views of each episode.
DROID: 1,000 episodes as MCAP recordings, with three cameras, robot telemetry, task instructions, and phase tags. π0 pretrained on it, and openpi and GR00T N1.7 ship DROID fine-tunes.
LeRobot Community: 2,378 tabletop episodes from 117 community LeRobot datasets, with embeddings, the kind of data SmolVLA pretrained on.

Add DROID, LIBERO, or LeRobot Community to a free Voxel51 workspace, or bring your own LeRobot dataset. Each one uses one of your 3 dataset slots. Open the episodes and see what your model will learn from before you spend GPU hours on it.

Get started free

Further reading: data-centric VLA training, VLA generalization, LIBERO curation, LeRobot curation metrics, and the multimodal datasets guide.

VLA models head to head

OpenVLA vs π0 (pi0)

Pick π0 if you have multiple cameras, proprioceptive state, and a task that needs smooth, fast control. Pick OpenVLA if you want the simplest single-camera setup. OpenVLA emits one tokenized action per call from one image, while π0 generates 50-step continuous chunks with flow matching. OpenVLA reads RLDS and openpi reads LeRobot datasets, with LoRA floors of about 27 GB and above 22.5 GB (JAX).

OpenVLA vs SmolVLA

SmolVLA is the default for a single GPU. OpenVLA is the better-studied baseline. At 450M parameters, SmolVLA fine-tunes in about four hours on one A100, or in Colab, while the 7B OpenVLA needs about 27 GB for LoRA. SmolVLA also takes up to three cameras and robot state, where OpenVLA sees one image and no state.

π0 (pi0) vs GR00T N1.7

Both use flow matching and take multiple cameras plus state, so the choice comes down to stack and embodiment. GR00T N1.7 adds 20K hours of EgoScale human video to pretraining and targets humanoids on NVIDIA hardware. openpi trains π0 on LeRobot datasets, while GR00T expects LeRobot v2 plus modality.json.

SmolVLA vs ACT

SmolVLA adds language and pretraining, and Action Chunking with Transformers (ACT) trains from scratch on each task. In SmolVLA's own SO-100 tests, it averaged 78.3% across three tasks against 48.3% for ACT. If your tasks change by instruction, start with SmolVLA.

The models, one by one

OpenVLA and OpenVLA-OFT

Stanford-led · Jun 2024, OFT Feb 2025 · MIT code, Llama 2 Community License weights · 7B · Tokens (OpenVLA), continuous chunks (OFT) · LIBERO 76.5 (OpenVLA), 97.1 (OFT) · Hugging Face

OpenVLA is the baseline most papers compare against. It reads one image and outputs one 7-degree-of-freedom action as tokens: simple and slow, about 6 Hz on an RTX 4090. OpenVLA-OFT keeps the backbone and changes the recipe: a wrist camera, proprioceptive state, continuous actions, and parallel-decoded action chunks. Good fit when you want a well-documented baseline and have the GPU for it.

π0 family (pi0, pi0.5)

Physical Intelligence · Oct 2024, latest π0.7 Apr 2026 · π0 to π0.5 open through openpi · π0: 3.3B · Flow matching · LIBERO 96.85 (π0.5) · openpi

π0 pairs a vision-language model with an action expert that generates continuous 50-step chunks for dexterous, high-frequency tasks. π0 vs π0.5: π0's open-data share includes Open X-Embodiment, Bridge v2, and DROID. π0.5 extends π0's training data, including Open X-Embodiment, for better generalization to new environments, and openpi ships checkpoints for both. Good fit when you have multiple cameras and need smooth control.

SmolVLA

Hugging Face · Jun 2025 · Apache 2.0 · 450M · Flow matching · LIBERO 87.3 · Hugging Face

SmolVLA is small on purpose. At 450M parameters (the model card rounds to 0.5B), it trains on one GPU and runs on consumer hardware. Its 87.3 on LIBERO came with no robot pretraining, only the vision-language backbone. Good fit when you're on an SO-100 or SO-101 arm or a single GPU.

NVIDIA Isaac GR00T N1.7 (often written GROOT)

NVIDIA · N1 Mar 2025, N1.7 Apr 2026 · NVIDIA Open Model License (commercial use allowed) · 3B · Flow matching · LIBERO and DROID checkpoints · Hugging Face

GR00T N1.7 is NVIDIA's open foundation model for humanoids. It shipped as early access in April 2026, is marked generally available in the repo as of November 2026, and is the first GR00T N1 release whose weights allow commercial use. Its data loader expects LeRobot v2 plus modality.json. Good fit when you're building on NVIDIA hardware or a humanoid.

MolmoAct 2

Ai2 · v1 Aug 2025, v2 May 2026 · Apache 2.0 · 5B · Flow matching (v2) · LIBERO 97.2 · GitHub

MolmoAct 2 is fully open, code and training data included, and its LeRobot docs are unusually candid about what breaks. Good fit when you want a fully open model on an SO-100 or Franka.

Octo

UC Berkeley-led · Dec 2023, 1.5 May 2024 · MIT · 27M and 93M · Diffusion head · Paper

Its authors call Octo a generalist robot policy, not a VLA, since it has no pretrained vision-language backbone, but it's still a common lightweight baseline.

Alpamayo

NVIDIA · Oct 2025, 2 Super Aug 2026 · OpenMDW-1.1 · 34B · Trajectory plus reasoning text · Hugging Face

Alpamayo 2 Super is a driving VLA that outputs a trajectory with a written reasoning trace. Inference was tested on one 80 GB H100.

Partner, API, or research-only models

Gemini Robotics 2 (early-access partners, with ER 2 in preview in AI Studio), Helix 2.5 (architecture unpublished), and RT-2 (weights never released) can't be fine-tuned, but they show where the field is heading.

LIBERO benchmark scores: how to read them

LIBERO has 130 tasks, and the four suites VLA papers report (Spatial, Object, Goal, and Long) cover 40 of them. Several fine-tuned models now score 97 or higher, in simulation, on the cleaned dataset described above, so LIBERO mostly tells you whether a model can fit LIBERO.

Model and checkpoint	Average	Spatial / Object / Goal / Long	Robot pretraining	Trials	Source
OpenVLA	76.5	84.7 / 88.4 / 79.2 / 53.7	Yes	500 per suite, 3 seeds	paper
OpenVLA-OFT	97.1	97.6 / 98.4 / 97.9 / 94.5	Yes	500 per suite, 3 seeds	paper
π0.5 (openpi pi05_libero)	96.85	98.8 / 98.2 / 98.0 / 92.4	Yes	50 per task (script default)	openpi
π0.5 (LeRobot, 6k more steps)	97.5	97.0 / 99.0 / 98.0 / 96.0	Yes	10 per task	LeRobot docs
SmolVLA (0.45B)	87.3	90 / 96 / 92 / 71	No	10 per task	paper
MolmoAct 2	97.2	97.8 / 100.0 / 97.8 / 93.2	Yes	50 per task	LeRobot docs

Reported LIBERO success rates (%) for VLA models by suite, with robot pretraining and trial counts. Each comes from its developer's own evaluation.

Also reported: π0-FAST 85.5 and Octo 75.1 (OpenVLA-OFT, Table I). π0 scores 86.0 in SmolVLA's paper and 94.2 in OpenVLA-OFT's, on the same cleaned data.

Same model, same data, two reported numbers, eight points apart. Scores move with the evaluation plumbing, and every one of these is documented:

OpenVLA-OFT: evaluate on the GPU you trained on.
OpenVLA-OFT: pass --center_crop True.
MolmoAct 2: the default 10-step settle time is unreliable, so it waits 50.
GR00T: 5 to 6% run-to-run variance from image augmentation.
MolmoAct 2: 98.25 in LeRobot, 97.20 in its original code.
LeRobot: pin the dataset revision, since Hub datasets get re-uploaded.

For a better signal, read the real-robot results. OpenVLA beat RT-2-X across 17 WidowX tasks (170 rollouts). π0.5 cleaned up kitchens and bedrooms in homes it had never seen. SmolVLA averaged 78.3% on three SO-100 tasks, against 61.7% for π0 and 48.3% for ACT. GR00T N1.7 was validated on Unitree G1, a bimanual YAM, and AGIBot Genie 1, with no success rate published.

Before you trust any number, open the LIBERO episodes (see above) and look at the demonstrations behind it.

Frequently asked questions

Fine-tune OpenVLA with LoRA (rank 32) on a GPU with at least about 27 GB, and expect 10 to 15 hours per task on one A100. Convert your data to RLDS, record at 5 to 10 Hz without pauses, drop failed demos, and set unnorm_key to your dataset.

Open-weight VLAs include OpenVLA and OpenVLA-OFT (MIT code, Llama 2 Community License weights), Octo (MIT), π0, π0-FAST, and π0.5 (openpi, Apache 2.0 repo), SmolVLA (Apache 2.0), GR00T N1.7 (NVIDIA Open Model License, commercial use allowed), MolmoAct 2 (Apache 2.0), and Alpamayo (OpenMDW-1.1).

SmolVLA is the VLA most likely to fine-tune and run on a single consumer GPU, and π0 or π0.5 also fit with LoRA in openpi's JAX path (more than 22.5 GB). OpenVLA and OpenVLA-OFT need more than a 24 GB card to fine-tune.

Fine-tuning a VLA takes between 10 and 300 demonstrations per task, depending on the model. OpenVLA's authors used 10 to 150, Hugging Face recommends about 50 for SmolVLA (25 was too few), and OpenVLA-OFT's ALOHA tasks used 20, 30, 45, and 300. NVIDIA and Physical Intelligence publish no count.

Octo is not strictly a VLA. Its authors call it a generalist robot policy: it takes language and images but has no pretrained vision-language backbone.

The companies building VLA models include Google DeepMind (RT-2, Gemini Robotics), Physical Intelligence (π0 family), NVIDIA (GR00T, Alpamayo), Figure AI (Helix), Hugging Face (SmolVLA), and Ai2 (MolmoAct).

Yes, VLA models exist for autonomous driving. NVIDIA's Alpamayo models turn camera video into a planned trajectory with a written reasoning trace. XPeng's VLA 2.0 keeps the name but, by XPeng's description, drops the explicit language step.

Pick a model, then look at its data

Pick a model, then look at the data it learns from. LIBERO, DROID, and LeRobot Community are all there to add, and each uses one of your 3 free dataset slots.

Get started free

Methodology. Verified November 2026 from primary sources: papers, official repos, model cards, and developer docs. Scores come from each developer's own evaluation and aren't comparable across rows. Other LeRobot model families may be added at the next verification on December 3, 2026.

VLA models compared: OpenVLA, π0, GR00T, SmolVLA, and more

Try Voxel51 for yourself

Key takeaways

What is a VLA model?

VLA models at a glance