Which VLA Policy Should You Train in 2026?

Five policies are trainable on an SO-100 class arm today. They differ by a factor of 24 in inference latency, 37 in parameter count and 12 in what a run costs, and in whether you may ship the result. Five model cards will not settle it: none answers the question you have, which do I run first?

Every number below was read out of the papers, repos and cards in August 2026. Platform numbers come from the AY-Robots policy catalog; where the two disagree, both are shown.

The decision table

The five candidates

All five are imitation learning policies: camera frames, joint positions and, for four of them, a language instruction, mapped to a chunk of future joint targets. What separates them is how much was learned before you arrived.

GR00T N1.7

NVIDIA's current vision-language-action model, about 3 B parameters, roughly 40 M trained during fine-tuning. The repo lists the deltas from N1.6: backbone from a vendored Eagle model to Cosmos-Reason2-2B on Qwen3-VL, diffusion layers 32 to 16, state and action dimensions 29 to 132, action horizon 16 to 40.

What matters on a small arm is the relative end-effector action space: N1.7 predicts deltas from the current pose, which is what lets 20K hours of EgoScale human video transfer into a robot policy. Spec on the N1.7 page, procedure in the N1.7 on SO-100 guide.

GR00T N1.5

Same 3 B scale, Eagle 2 backbone, SigLip2 and T5, flow-matching DiT head. It exists to extend a checkpoint you already have. Two things make it a poor default: the weights carry NVIDIA's one-way non-commercial licence, and current LeRobot releases removed N1.5 support. See N1.7 against N1.5.

Pi0.5

Physical Intelligence's flow-matching VLA, policy type pi05. The paper gives a 2 B VLM initialised from PaliGemma plus a 300 M action expert, driving the robot at 50 Hz; LeRobot's pi05 config defaults to a 50-step chunk, one second at that rate. The selling point is unseen places: about 400 hours of mobile manipulation in real homes, and a scaling study over 3, 12, 22, 53, 82 and 104 locations, where the 104-location model matched a control trained on the test homes themselves.

One limit, stated on the lerobot/pi05_base card: the port carries only the flow-matching action head. Subtask prediction, action tokenization and RL were not released upstream, and openpi says the same of its own repository. The Pi0.5 page and the Pi0.5 on SO-100 guide have the rest.

SmolVLA

450 M parameters, about 100 M in the action expert, on SmolVLM-2 with the VLM frozen and only its first 16 language-model layers used. Pretraining was community data: 481 datasets, 10.6 M frames, from the same cheap arms you use. The only VLA here that fits one 24 GB card, and the only 30 episode floor. See the SmolVLA page.

ACT

Not a foundation model. The Action Chunking Transformer from ALOHA is about 80 M parameters trained from scratch per task, on 50 demonstrations at 50 Hz. The paper reports six real bimanual tasks from roughly ten minutes of demonstrations each, at 80 to 90 percent on the examples it highlights. Its idea, action chunking, is in every model on this page, and its ablation still measures the effect best: over two simulated tasks with temporal ensembling off, success rises from 1 percent at k=1 to 44 percent at k=100. The ACT page has the rest.

What the benchmarks actually say

LIBERO is the one benchmark three of these five report on: language-conditioned tasks on a simulated Franka Panda, split into the four suites below at ten tasks each. NVIDIA ran 200 trials per suite.

SimplerEnv shows the spread, which LIBERO does not. NVIDIA compares N1.7 against N1.6, the closest public thing to a generational delta.

The Bridge row is the useful one: 5.7 points gained on average while put_eggplant_in_basket lost 36 and put_eggplant_in_sink fell from 33 to 2. A new generation moves the distribution rather than lifting it, so if your task sits where N1.7 regressed, the average says nothing.

Of the five, only the SmolVLA paper reports on an SO-100 class arm: 78.3 percent for SmolVLA and 61.7 for Pi0 across three tasks, both multi-task, against 48.3 for ACT trained single-task, which is not like for like. The clean pairing is both single-task on SO-101 pick-and-place: 90 against 70 in distribution, 50 against 40 out of it. Compare on ACT against SmolVLA and Pi0.5 against SmolVLA, or browse the arena.

Latency and cost decide deployment

Inference latency is the constraint people discover last and regret first. A policy five points better on a benchmark but half a second per action step looks worse on your desk: contact dynamics do not wait.

One caveat: the GR00T figure disagrees with NVIDIA's card, which times 4 denoising steps and one camera at 85.8 ms on an H100 in eager mode, 48.6 ms with torch.compile, 27.9 ms through full TensorRT. The 152 ms here is a whole-stack figure with serving overhead and more than one camera, not a forward pass.

One way to buy time without changing model: the SmolVLA paper measures synchronous execution, where the policy finishes a chunk before predicting the next, against asynchronous, where prediction overlaps execution. Success is similar, 78.3 against 73.3, but the same pick-and-place takes 9.7 seconds instead of 13.75, and in a fixed window the robot manages 19 cycles instead of 9.

Licences, checked because nobody checks them

The Pi0.5 row needs care. The LeRobot pi05 documentation states Apache 2.0 consistent with openpi, while the Hub card for lerobot/pi05_base carries license: gemma. Both are live. GR00T N1.7 has a milder version: the Isaac-GR00T README says in passing that N1.7 is fully commercially licensable under Apache 2.0, while its own licence section and the model card put only the code under Apache 2.0 and the weights under the NVIDIA Open Model License.

The defaults you will actually run

Each trainer form ships a default, and they are not arbitrary. ACT's are LeRobot's own: batch 8, lr 1e-5, 100000 training steps, chunk size 100, matching ACTConfig upstream and k=100 from the ACT paper. One column below is a trap.

The knob that matters more than the model choice

It is the action chunk. Longer chunks give smoother motion and fewer compounding errors, but the policy is committed while the block executes, so it reacts late to anything that moves: confident on a static cube, hopeless on a rolling one. If it overshoots, shortening the executed portion beats retraining and is free. A joint that stops short is a different problem; see the joint-stops-early page.

• ACT: ACTConfig defaults to chunk_size 100 and n_action_steps 100. Temporal ensembling is off and requires n_action_steps 1.
• GR00T N1.7: internal horizon went 16 to 40, yet LeRobot's SO-101 example still runs --policy.chunk_size=16 --policy.n_action_steps=16. The rollout flag was renamed to --execution-horizon.
• Pi0.5: a 50-step chunk, of which LeRobot's LIBERO recipe executes 10 via --policy.n_action_steps=10; with --policy.pretrained_path it falls back to 50 if you omit the flag.
• SmolVLA: 50-action chunks, both knobs exposed.

How to screen all five in one afternoon

The cheapest answer is not more reading. Spend about 15 USD and let the arm tell you: record once, train the cheap model first, escalate once it has proven the data sound. Structure beats volume, the point of SO-100 data collection and the LeRobot dataset format.

1. 1
   Record 50 episodes once

   Fifty clears the floor for GR00T, Pi0.5 and ACT, and SmolVLA's 30. Repeat each variation rather than spreading thin: 50 episodes across 5 cube positions trained where 25 did not. See record your first dataset.

   bash

   lerobot-record \
     --robot.type=so100_follower \
     --robot.port=/dev/ttyACM1 \
     --robot.id=my_follower_arm \
     --teleop.type=so100_leader \
     --teleop.port=/dev/ttyACM0 \
     --teleop.id=my_leader_arm \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --dataset.num_episodes=50 \
     --dataset.single_task="Put the lego brick into the box"

2. 2
   Train ACT first, because it cannot lie to you

   No pretrained weights, so if it does the task at all, your dataset contains the task. If ACT flatlines, fix the data. 1 to 3 USD, 2 to 5 hours on a 24 GB card.

   bash

   lerobot-train \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --policy.type=act \
     --policy.device=cuda \
     --batch_size=8 \
     --steps=100000 \
     --seed=1000 \
     --output_dir=outputs/train/act_pickplace \
     --job_name=act_pickplace

3. 3
   Run SmolVLA on the same dataset, unchanged

   Same data, same arm, 450 M parameters instead of 80 M, plus language conditioning. LeRobot puts a 20K step run at roughly 4 hours on one A100. This is what tells you whether pretraining buys anything.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --batch_size=64 \
     --steps=20000 \
     --policy.device=cuda \
     --output_dir=outputs/train/smolvla_pickplace \
     --job_name=smolvla_pickplace

4. 4
   Convert down to v2.1 before you touch GR00T

   GR00T reads a flavour of the LeRobot v2 format plus an extra meta/modality.json mapping how concatenated state and action arrays split into named fields. A v3.0 dataset crashes that loader, because v3.0 packs many episodes into shared files where v2 wrote one per episode. Isaac-GR00T ships the downgrade helper as scripts/lerobot_conversion/convert_v3_to_v2.py; the v3 rejection page is the fast path.

   text

   # GR00T expects this layout, not the v3.0 file-based one
   my_dataset/
     meta/
       info.json
       episodes.jsonl      # episode index and lengths
       tasks.jsonl         # language task descriptions
       modality.json       # GR00T-specific: state/action/video key mapping
     data/chunk-000/       # parquet, state and action per timestep
     videos/chunk-000/     # one mp4 per episode

5. 5
   Escalate to GR00T N1.7 only if the first two left something on the table

   Through NVIDIA's CLI, shown here, or LeRobot's groot policy type. NVIDIA recommends 40 GB or more of VRAM for fine-tuning, 16 GB for inference. On an OOM, see the OOM page.

   bash

   CUDA_VISIBLE_DEVICES=0 uv run python \
     gr00t/experiment/launch_finetune.py \
     --base-model-path nvidia/GR00T-N1.7-3B \
     --dataset-path demo_data/cube_to_bowl_5 \
     --embodiment-tag NEW_EMBODIMENT \
     --modality-config-path examples/SO100/so100_config.py \
     --num-gpus 1 \
     --output-dir /tmp/test_finetune \
     --max-steps 2000 \
     --global-batch-size 32 \
     --dataloader-num-workers 4

Two ways to run that screening pass

# 1. LeRobot: ACT, SmolVLA, Pi0.5 and GR00T N1.7 via --policy.type=groot
pip install "lerobot[smolvla]"
pip install "lerobot[pi]"
pip install "lerobot[groot]"

# 2. GR00T reference implementation and benchmark examples
git clone https://github.com/NVIDIA/Isaac-GR00T

# 3. Physical Intelligence reference implementation
git clone --recurse-submodules https://github.com/Physical-Intelligence/openpi

Foundation model or from scratch

The real fork is not which 3 B model to pick. It is whether to use a pretrained VLA at all, given that ACT learned six real bimanual tasks from about ten minutes of demonstrations each, with 80 M parameters and nothing pretrained.

The reproducing-an-old-run case

Chasing a 2025 checkpoint makes the model choice for you and turns the problem into version pinning: current LeRobot rejects N1.5, so you pin lerobot==0.5.1. With no seed field and 5 to 6 percent variance between runs, the reproduction is approximate by construction. The N1.5 on SO-100 guide and the N1.5 policy page have the platform side.

Down to two? ACT against GR00T N1.7 and GR00T N1.7 against SmolVLA. Raw rows sit in the arena entries: GR00T N1.7, Pi0.5, SmolVLA and ACT.

Where this platform does not help you

• It cannot make remote inference fast. The 20 to 485 ms loop belongs to the model; internet round trips add to it.
• It cannot fine-tune GR00T or Pi0.5 on your own hardware. Both are cloud-only here; only SmolVLA and ACT run locally.
• It cannot fix a dataset. Loss falls but the policy does nothing is a data problem, a policy that only works in one setup is a coverage problem.
• It cannot make GR00T runs reproducible: the upstream config has no seed field.

Picking one and moving on

One default: record 50 episodes, train ACT for 1 to 3 USD to prove the dataset, then SmolVLA on the same data. Under 6 USD together, and they answer the question that matters: whether pretraining helps here, or whether the bottleneck is the data. Escalate to GR00T N1.7 for contact-rich multi-step tasks, to Pi0.5 when the scene changes.

Platform walkthrough: train your first policy, then run your first policy. The training docs and dataset docs cover form and format; the SO-100 page and the complete SO-100 guide cover build and calibration. Background: the VLA overview and the Pi0 flow-matching article. The one that will move your success rate is the data quality guide.