Choosing an Open Robot Policy Model: OpenVLA vs Octo vs π0 vs GR00T N1.7 on License, Size and GPU Needs

Several robot policy models now ship open weights that you can download and fine-tune for your own robot. That shifts the first question away from architecture and toward “what can we actually run under our GPU budget and license constraints?” This article compares OpenVLA, Octo, π0 (openpi) and GR00T N1.7 on operational criteria. For how each one turns observations into actions, read the VLA pipeline analysis first.

Five criteria to settle before choosing

1. License — code and weights are often licensed differently. If the model will ship in a product, judge by the weight license.
2. Model size and GPU memory — check inference memory and fine-tuning memory (LoRA and full) separately.
3. Action generation and control rate — emitting discrete tokens one at a time and generating a whole action chunk at once lead to very different achievable control rates.
4. Data format — find out what format your demonstrations must be converted into before training.
5. Framework and platform — JAX or PyTorch, supported operating systems, and whether there is a documented path to edge devices.

Comparison table

All values were checked against each model’s paper, README or model card on 2026-10-19. Speed figures were measured on different GPUs with different optimizations, so do not rank them against each other directly; re-measure on the same hardware.

OpenVLA: the reference open VLA, but heavy

The OpenVLA paper discretizes each action dimension into 256 bins and overwrites the 256 least-used tokens in the Llama tokenizer so the language model can emit actions. Loaded in bf16 it needs 15 GB of GPU memory and runs at about 6 Hz on a single RTX 4090. 4-bit quantization kept performance close to bf16 while using less than half the memory, but measured 3 Hz on an A5000.

LoRA is the standard fine-tuning path. The paper reports adapting to a new task in 10 to 15 hours on a single A100 while training only 1.4% of the parameters. According to the README, batch size 16 needs about 72 GB, and smaller batches fit on GPUs with at least about 27 GB. Because the weights derive from Llama 2, the Llama Community License applies, which belongs in any commercial review. The README also points to the follow-up OFT recipe, which reports 25-50x faster inference than vanilla fine-tuning, so look there first if speed is the blocker.

Octo: a small diffusion policy for fast iteration

Octo ships in two sizes, Small (27M) and Base (93M), as a transformer-based diffusion policy pretrained on 800K robot trajectories. The README reports 13 inferences per second for Base and 17 for Small on one RTX 4090. Fine-tuning comes in three modes — head_only, head_mlp_only and full — so with little data you can train just the action head and keep compute low.

The limits are equally clear. Without a language-model backbone, expect weaker generalization to complex instructions or unfamiliar object names than a VLA offers. Octo is also built on JAX, which adds ramp-up time for PyTorch-centric teams. Its small size, however, makes experiment loops fast on laptop GPUs and modest hardware.

π0 (openpi): a flow-based VLA you can fine-tune on a consumer GPU

The openpi repository distributes π0, the autoregressive π0-FAST, and π0.5 with improved open-world generalization. According to the π0 paper, π0 pairs PaliGemma 3B with a 300M action expert trained from scratch, for 3.3B parameters in total. It generates 50-step action chunks with flow matching and controls dexterous tasks such as laundry folding at up to 50 Hz. On-board inference latency on an RTX 4090 is 73 ms.

Memory is the operational win. The README lists more than 8 GB for inference, more than 22.5 GB for LoRA fine-tuning (for example an RTX 4090), and more than 70 GB for full fine-tuning (A100 80 GB or H100). Caveats: Ubuntu 22.04 is the only tested OS, and the PyTorch implementation added in September 2025 does not yet support π0-FAST, mixed precision, FSDP, LoRA or EMA, so LoRA training goes through the JAX path. Training data is converted to LeRobot datasets.

GR00T N1.7: the most concrete path to humanoid deployment

The latest model in the Isaac-GR00T repository, N1.7, has 3B parameters. It uses Cosmos-Reason2-2B, built on the Qwen3-VL architecture, as its vision-language backbone and a flow-matching DiT action head for continuous actions. The README says the state and action dimension grew from 29 to 132 and the action horizon from 16 to 40 compared with N1.6. The backbone is a gated Hugging Face model, so request access first.

Requirements are 16 GB or more for inference and 40 GB or more recommended for fine-tuning, the highest training bar of the four. In exchange, the model card publishes per-device speeds: with the full TensorRT pipeline, 35.9 Hz on H100, 26.0 Hz on L40 and 10.7 Hz on Jetson AGX Thor. The repository’s hardware recommendation explains that action chunking lets roughly 10 Hz replanning support about 30 FPS robot execution. Having the path down to robot-mounted hardware documented officially is what sets it apart. The fine-tuning procedure itself is walked through in the GR00T N1.7 fine-tuning guide.

Filtering candidates by the GPU you already own

The published numbers alone are enough to rule options in or out for your hardware. The script below copies the memory requirements from the table as-is and leaves unpublished values empty.

# GPU memory requirements in GB from official docs. None = not published
MODELS = {
    "OpenVLA (7B)":    {"infer": 15,   "lora": 27,   "full": None},
    "Octo-Base (93M)": {"infer": None, "lora": None, "full": None},
    "pi0 (3.3B)":      {"infer": 8,    "lora": 22.5, "full": 70},
    "GR00T N1.7 (3B)": {"infer": 16,   "lora": None, "full": 40},  # default mode: projector + DiT tuning
}

def shortlist(vram_gb, stage):
    for name, req in MODELS.items():
        need = req[stage]
        verdict = "check docs" if need is None else ("fits" if vram_gb >= need else "too small")
        print(f"{name:18s} {stage:5s} needs {need!s:>5} GB -> {verdict}")

shortlist(24, "infer")
shortlist(24, "lora")

On a 24 GB GPU, OpenVLA, π0 and GR00T can all run inference, but only π0 LoRA meets the published requirement for fine-tuning on the same card. GR00T’s 40 GB figure applies to the default mode that tunes the projector and DiT action head; the hardware guide recommends 80 GB or more per GPU once --tune-llm or --tune-visual is enabled. To size the edge device that will run the policy on the robot, including memory bandwidth, continue with the VLA edge hardware sizing guide.

Which model to try first, by situation

Widen the lens beyond released models and you also find research concepts such as TRI and Boston Dynamics’ large behavior models, diffusion policies trained mainly on robot demonstrations. Whichever model you pick, the first step is the same: collect demonstrations of your own robot in LeRobot format, train two candidates on the same data, and compare them from identical initial conditions.