| Fact | Pi0.5Flow-matching Vision-Language-Action model (policy type pi05) | SmolVLACompact Vision-Language-Action model |
|---|---|---|
| Vendor | Physical Intelligence | Hugging Face |
| Trainer key | pi0 | smolvla |
| GPU tier | A100 80 GB or H100 80 GB | RTX 4090 or any card with 24 GB |
| Inference | about 485 ms per action step | about 245 ms per action step |
| Batch size | 1 | 2 |
| Gradient accumulation | 16 | 8 |
| Learning rate | 5e-5 | 1e-4 |
| Default steps | 30,000 | 20,000 |
| Dataset format | LeRobot v2.1 | LeRobot v2.1 |
| Episodes from | 50 | 30 |
| Extra fields in the form | seed, logFreq | seed, logFreq |
| Where it runs | Rented cloud GPU only | Cloud GPU, or a local 24 GB card |
| Typical run | 3 to 6 hours, about 4 to 12 USD | 2 to 5 hours, about 1 to 3 USD |
Stay on SmolVLA until your policy reliably reaches the right place and fails in the last centimeters, because contact precision is the only failure class Pi0.5 will fix for four times the money and twice the latency.
How close these two really are
Both are lerobot-family trainers, so both expose seed and logFreq and both start from a LeRobot v2.1 upload. Both are language conditioned. And, less obviously, both default to the same effective batch: SmolVLA runs batch 2 with 8 accumulation steps, Pi0.5 batch 1 with 16, and both arrive at 16 samples per optimizer step. What differs is model size, the objective, the card, and the length of the schedule. That short list makes the comparison unusually clean: hold everything else fixed and ask one question, whether flow matching at three billion parameters solves the problem you actually have.
Side by side
| Fact | Pi0.5 | SmolVLA |
|---|---|---|
| Vendor | Physical Intelligence | Hugging Face |
| Parameters | About 3 billion, on a PaliGemma backbone | About 450 million |
| GPU tier | A100 80 GB or H100 80 GB | RTX 4090 or any card with 24 GB |
| Estimated run | 3 to 6 hours at 1.20 to 2.00 USD per hour | 2 to 5 hours at 0.30 to 0.60 USD per hour |
| Inference per action step | About 485 ms | About 245 ms |
| Default batch and accumulation | 1 with 16 accumulation steps | 2 with 8 accumulation steps |
| Effective batch | 16 | 16 |
| Default learning rate and steps | 5e-5 over 30 000 steps | 1e-4 over 20 000 steps |
| Exposed knobs | seed, logFreq | seed, logFreq |
| Minimum useful episodes | About 50 | About 30 |
| Language conditioning | Yes | Yes |
| Runs outside the cloud pool | No | Yes, on a 24 GB card you own |
| Dataset format | LeRobot v2.1 | LeRobot v2.1 |
The failure taxonomy that decides this
Run twenty attempts with your current SmolVLA policy and sort the failures into the rows below before renting an 80 GB card. Most people who upgrade too early are looking at a data problem and hoping a bigger model absorbs it. It will not, and the run costs four times as much to say so.
| What the arm does | What it is | Does Pi0.5 address it |
|---|---|---|
| Moves confidently to the wrong location | Reading pixels after the camera moved, or inconsistent data | No. Fix the setup or the dataset. |
| Freezes partway through the motion | The observation is outside anything in the training data | No. Record episodes covering that situation. |
| Succeeds only from demonstrated placements | A generalization gap | Partly. A larger backbone helps, more varied episodes help more per euro. |
| Arrives correctly, closes the gripper early or late | Timing precision around contact | Often yes. This is the class flow matching targets. |
| Grasps, then misses the insertion by millimeters | Contact precision | Yes. This is the case that justifies the upgrade. |
| Jerky through the whole trajectory | Jerky demonstrations, faithfully reproduced | No. Re-record more deliberately. |
Only the last two rows are Pi0.5 problems. Flow matching produces smooth, continuous action trajectories instead of discretized jumps, and that difference becomes visible on the final approach, where a small error in the commanded position separates seating a part from pushing it over.
What the upgrade costs you
Two things, and only one is money. The run moves from about 1 to 3 USD to about 4 to 12, and from a two to five hour estimate to a three to six hour one, with Pi0.5 at the top of its band because batch 1 with sixteen accumulation passes is not a shape that keeps a large card busy. The other cost is permanent: 485 ms against 245 ms means the loop closes roughly twice a second instead of four times. On a deliberate task that is invisible. Where the object can shift after contact, you can spend part of the precision you bought on reacting late.
SmolVLA Pi0.5
batch 2 1
gradient accum 8 16
effective batch 16 16
learning rate 1e-4 5e-5
steps 20 000 30 000
seed set it set it
logFreq set it set it
GPU tier 24 GB 80 GB
Passes through the network: 20 000 x 8 = 160 000 for SmolVLA against
30 000 x 16 = 480 000 for Pi0.5, on a model roughly six times larger.Pick SmolVLA if
- You are on your first or second pass over a dataset. A 450 million parameter model is perfectly capable of telling you your episodes are inconsistent, and it does so for a couple of dollars.
- The task involves motion the arm must keep up with: something rolling, something handed over, anything where half a second of staleness becomes a miss.
- You want the policy on your own hardware. SmolVLA fits a 24 GB card outside the cloud pool; Pi0.5 does not.
Pick Pi0.5 if
- Your task is an insertion, a stack, a lid or a connector. These are the tasks where the last centimeters carry all the difficulty.
- You have fifty or more episodes and a SmolVLA policy that already gets to the right place. Upgrading a policy that works is a different proposition from upgrading one that does not.
- The motion is quasi-static. If the scene holds still until the gripper touches it, 485 ms costs only evaluation patience and the precision comes free.
What SmolVLA still does better, even after you upgrade
Keep it rather than retiring it. Once Pi0.5 is your production policy, the question you ask most often is not whether the architecture is right but whether the episodes you recorded this week are consistent with the ones you had. A SmolVLA run answers that in two to five hours on the same dataset id, which makes it a cheap regression check rather than a second project. It is also the model you can hand to a colleague without a budget conversation.
Set the same seed on both jobs, point both at the same dataset id, change nothing else and evaluate with an identical protocol. There is no excuse for deciding this pair by reputation when the experiment is this clean.
The upgrade, in order
- 1Establish the SmolVLA baseline properly
Defaults, a fixed seed, twenty evaluation attempts written down. Without a baseline you cannot tell an improvement from a different random outcome.
- 2Sort the failures into the taxonomy above
Count contact failures against everything else. If contact failures are the minority, stop and record data for the majority.
- 3Get to fifty episodes if you are not there
Pi0.5 becomes useful at around fifty, twenty above SmolVLA’s threshold. Running it on thirty is paying the 80 GB rate for a comparison that will not mean much.
- 4Start Pi0.5 on the same dataset id
Select Pi0.5 in Training, leave 30 000 steps and 5e-5 alone, and set the same seed you used for SmolVLA.
- 5Re-run the identical evaluation
Same placements, same order, same lighting. Compare contact failures specifically. If those did not drop, the upgrade did not do the job you bought it for.
The dataset is what you actually own
A checkpoint is the output of a few rented hours. Your episodes are hours of your own time and they outlive every model in this catalog. Because both trainers read LeRobot v2.1, moving between them never touches the data: the second job takes the same dataset id and the same task strings, and the first checkpoint stays available for comparison. Plan spending around recording sessions and treat every training run as an experiment you are allowed to discard.
Where to go next
- /policies/pi0-5: flow matching, defaults, and the documented limits
- /policies/smolvla: the 24 GB starting point
- /train/pi0-5-on-so-100: the upgrade run in full
- /train/smolvla-on-so-100: the baseline run in full
- /learn/run-your-first-policy for the evaluation protocol used above
Frequently asked questions
Is Pi0.5 simply a better SmolVLA?▾
No. It is larger and it targets contact precision, but it costs four times as much per run, doubles the latency per action step, needs twenty more episodes before it is useful, and cannot run outside the cloud pool. Those are real losses.
Both default to an effective batch of 16. Does that make the runs equivalent?▾
Only the optimizer view is equivalent. Pi0.5 reaches 16 through sixteen single-sample passes over 30 000 steps, SmolVLA through eight passes of two samples over 20 000, on a model roughly six times smaller. Useful for comparing recipes, not for predicting results.
Can I run Pi0.5 on my own GPU after training?▾
No. Pi0.5 is cloud-only on this platform and needs the 80 GB tier. SmolVLA is the language conditioned model that fits a 24 GB card you own, and ACT is the small one below it.
My policy fails half the attempts. Will Pi0.5 fix that?▾
It depends on how it fails. Wrong location and freezing are data problems no model change repairs, while a gripper that arrives correctly and closes at the wrong moment is exactly what the upgrade targets.
Do I need to change the task strings when I switch?▾
No. Both are language conditioned and both read the strings stored in the dataset, so the same episodes work unchanged. One more reason to write real sentences during recording rather than labels like "run 3".
Once the choice is made, the matrix under /train has the guide for your model and your arm.