Open-Source VLA Models Compared

This page compares four models that publish a paper and a public code repository: OpenVLA, Octo, π0 and GR00T N1. The OpenVLA paper (https://arxiv.org/abs/2406.09246) introduces a 7B-parameter open-source vision-language-action (VLA) model. The π0 repository, openpi (https://github.com/Physical-Intelligence/openpi), describes itself as holding open-source models and packages for robotics. The GR00T N1 paper (https://arxiv.org/abs/2503.14734) is titled as an open foundation model for generalist humanoid robots. The Octo paper (https://arxiv.org/abs/2405.12213) is titled as an open-source generalist robot policy.

Octo is worded the way its own paper words it: a generalist robot policy. The π0 paper states that "Octo is not a VLA" while using it as a baseline, so this page does not label Octo a VLA. RT-2 (https://arxiv.org/abs/2307.15818) appears only as context. Its paper describes a VLA that expresses actions as text tokens, and the OpenVLA abstract describes RT-2-X (55B) as a closed model. This page does not call RT-2 open-source.

There is no winner here. Each paper evaluates its own model on its own tasks, robots and baselines, so a number from one paper does not transfer to another. This page quotes no cross-paper benchmark figures, and wherever a source is silent the cell says Not stated in the sources read.

The first table below sets the four against the same questions: what the source calls the model, its backbone and size, and how it outputs actions. The second covers training data and licence. Every row carries a source link.

The clearest split is in how actions leave the model. OpenVLA maps continuous robot actions to discrete tokens in the language model’s output space. Octo uses a diffusion head, and π0 and GR00T N1 use flow matching for continuous action chunks. That choice changes what a fine-tuning dataset has to contain and how it is normalised.

OpenVLA builds on a Llama 2 language model combined with a visual encoder that fuses pretrained DINOv2 and SigLIP features, starting from the Prismatic-7B VLM. Its paper says the actions are represented in the output space of the language model by mapping continuous actions to discrete tokens, "discretize each dimension of the robot actions separately into one of 256 bins". Its architecture figure states that the model predicts 7-dimensional robot control actions.

π0 starts from the PaliGemma vision-language model, adds an action expert of about 300M parameters, and generates continuous action chunks with flow matching. The paper writes the action horizon as 50 steps and the observation as multiple RGB images, a language command and the robot’s proprioceptive state. The openpi README also lists a π0-FAST model, described as an autoregressive VLA based on the FAST action tokenizer.

Octo is described by its paper as a transformer-based policy that tokenizes task descriptions with a pretrained language model and observations with a lightweight CNN, then decodes actions with a conditional diffusion head. The Octo repository states that it can be instructed with language commands or goal images, and that it was pretrained with an action chunk size of 4. A vision-language backbone is Not stated in the sources read.

All four were trained on robot data, and the volumes are each paper’s own. The OpenVLA abstract states 970k real-world robot demonstrations from the Open X-Embodiment dataset. The Octo paper states 800k trajectories curated from roughly 1.5M Open X-Embodiment episodes. The π0 paper describes about 10,000 hours of its own dexterous manipulation data from 7 robot configurations and 68 tasks, combined with the Open X-Embodiment dataset. These counts describe different things and are not directly comparable.

GR00T N1 describes its training corpus as a data pyramid. The GR00T N1 paper places web data and human videos at the base, synthetic data in the middle, and real-robot data at the top. For action-less sources such as human video, it describes learning a latent-action codebook and training an inverse dynamics model to infer pseudo-actions. That is the paper’s own method for turning human video into training signal, and it is stated for GR00T N1’s data, not as a general rule.

The EgoScale abstract (https://arxiv.org/abs/2602.16710) separately describes training a VLA on over 20,854 hours of action-labeled egocentric human video. That is a statement about its own paper, not about the models above.

Licences are quoted from each repository’s LICENSE file or README and are never inferred. The OpenVLA and Octo LICENSE files are MIT License. The openpi and Isaac-GR00T LICENSE files are Apache License 2.0.

A repository licence covers the code in that repository. The OpenVLA README adds a separate note: all code is released under the MIT License, but "our pretrained models may inherit restrictions from the underlying base models we use", and its released models "are derived from Llama-2, and as such are subject to the Llama Community License". The code licence and the weights licence can differ, so read both.

For the others, the sources read state a repository licence and not a separate weights licence. The openpi README does not state a licence for its checkpoints. The Isaac-GR00T repository currently documents GR00T N1.7 and says N1.7 is fully commercially licensable under Apache 2.0. A licence for the GR00T N1 checkpoints named in the N1 paper is Not stated in the sources read.

No source reviewed here names a best model, and this page does not either. What it can do is list the questions each source’s own text makes relevant. What does your robot output: a single arm’s end-effector deltas, bimanual joints, or humanoid whole-body commands? How fast does it need to be controlled? The π0 paper cites control at up to 50 Hz and describes OpenVLA as not supporting action chunking. The OpenVLA README, in turn, now lists an optimised fine-tuning recipe that it says enables high-frequency bimanual control, so check the current repository, not the original paper.

How much GPU memory do you have? The openpi README lists above 8 GB for inference, above 22.5 GB for LoRA fine-tuning and above 70 GB for full fine-tuning. The OpenVLA README says LoRA fine-tuning can run on a GPU with at least about 27 GB with a reduced batch size. The Isaac-GR00T README lists a 16 GB GPU for inference and 40 GB or more recommended for fine-tuning. Those are each repository’s own figures for its own setup.

Every one of these models is fine-tuned on episodes from your robot: camera observations, usually robot state, an action at each step, and a task instruction. The OpenVLA README says a custom dataset not in Open X-Embodiment should be converted to RLDS, then registered with its observation and action spaces. The openpi README says to convert your data to a LeRobot dataset, define training configs and compute normalisation statistics. The Isaac-GR00T README describes a flavour of the LeRobot v2 format with a modality file that maps state, action and video keys.

The sources give a few volumes for their own tasks, and none is a target for yours. The Octo paper fine-tunes on small target datasets of around 100 trajectories in its experiments. The π0 paper says its simplest post-training tasks needed only 5 hours of data and its most complex used 100 or more hours. These show the range each team reported, not what your robot will need.

The third table below pairs each need with what Firsthand’s site states it delivers. Robot joint state, gripper action and a robot-executed action vector are Not stated, because Firsthand captures first-person human video, not robot or teleoperation data.

Write down the model, the stage it is at and the format your trainer reads. Then name the tasks, the setting and the wording of the single task instruction for each episode. We turn that into a written spec covering tasks, environments, capture tier, annotation depth and accept criteria, then quote reach, timeline and price before any capture begins.

The site states that capture is fast and on demand. Where coverage is already deep, the first validated batch lands in a median of 48 hours from a signed spec. Where coverage is thin it typically takes three to four weeks, and the quote says which applies. The usual route starts with a Spec Pilot, a small batch that proves the spec on real footage before you scale.

Delivery formats stated on this site include RLDS, LeRobot v2.1, WebDataset, HDF5 and zarr, plus a Rerun .rrd recording for inspection. Whether a given trainer accepts the delivered field names unchanged is Not stated and untested, so plan for a short mapping step. The only language field the site states is one task instruction per episode; captions, narration and other language labels are not offered.