Pi0 vs Pi0.5: What Actually Changed in the VLA

What actually changed, in one paragraph

Pi0 and Pi0.5 look like a version bump and are not. The Pi0 paper (arXiv 2410.24164, v1 posted 31 October 2024) introduced a vision-language-action model that bolts a continuous action expert onto a pretrained VLM and trains the whole thing with flow matching. The Pi0.5 paper (arXiv 2504.16054, 22 April 2025) keeps that architecture almost unchanged and rewrites how it is trained. The action expert's gradients are cut off from the backbone, the backbone learns from discretised action tokens instead, and the training mixture grows to include web data and subtask labels. The claimed payoff is not dexterity. It is generalisation to environments the robot has never seen.

This article separates three things that get blurred together: what the papers changed, what the open implementations ship, and what you get when you press train on your own LeRobot dataset. Those answers differ, and the gap is the useful part. The VLA overview and the older Pi0 flow-matching write-up cover the ground this one assumes.

Pi0, briefly, because Pi0.5 is a diff against it

Pi0 takes PaliGemma, a 3 billion parameter open vision-language model, and adds "300M parameters for the action expert (which is initialized from scratch) for a total of 3.3 billion parameters". The expert emits a chunk of H = 50 future actions at once, which is ordinary action chunking, produced by integrating a flow field over 10 steps rather than by sampling tokens. Pretraining ran on over 10,000 hours of robot data across 7 robot configurations and 68 tasks, plus the Open X-Embodiment collection.

One number to ignore: the Hugging Face model-size badge reads "4B params" for both lerobot/pi0_base and lerobot/pi05_base, because it rounds. The safetensors index behind those pages gives 3,501,372,176 and 3,616,757,520. There is no 4 billion parameter Pi0.5.

Change 1: the gradient cut, also called knowledge insulation

The problem is stated bluntly in the follow-up paper, Knowledge Insulating Vision-Language-Action Models (arXiv 2505.23705, 29 May 2025): adding a continuous action expert naively harms both training speed and the semantic knowledge the VLM arrived with. A freshly initialised 300 M expert emits large, noisy gradients onto a backbone that spent its whole pretraining budget learning to read scenes and follow language.

1. The action expert attends to the backbone's keys and values, but equations 5 and 6 of the paper wrap those tensors in a stop-gradient operator, written sg(). Information flows forward, error signal does not flow back.
2. The backbone is trained instead with a next-token loss over FAST-tokenised actions, alongside ordinary vision-language data.
3. The expert keeps its own flow-matching loss, weighted by a factor called alpha. Because the stop-gradient makes the two losses touch disjoint weights, that paper sets alpha = 1; Pi0.5's post-training used alpha = 10.0.
4. Timestep conditioning inside the expert uses adaptive RMSNorm. In lerobot that is literally use_adarms=[False, True]: off for the backbone, on for the expert.

The reported effect is a training-cost collapse. Figure 6, a generalist model trained across many embodiments and evaluated on table bussing, states that Pi0 "trains significantly slower, requiring 7.5 times as many training steps to reach a similar performance". You get discrete-token training speed and continuous-action inference speed at once. That second half matters: the same paper puts an autoregressive Pi0-FAST at roughly 750 ms for a one-second chunk on an RTX 4090, citing the FAST paper for that measurement.

Change 2: discrete tokens do the representation learning

Pi0.5 does not discard discrete actions, it promotes them. FAST (arXiv 2501.09747, 16 January 2025) compresses an action chunk with a discrete cosine transform, quantises the coefficients and runs byte-pair encoding over the result. Combined with Pi0, the authors report matching diffusion VLAs "while reducing training time by up to 5x". Pi0.5 uses that tokeniser for 280k pretraining steps, then adds the flow-matching expert for 80k post-training steps on a joint next-token plus flow-matching objective.

A second, smaller token change is the one you notice in a config file. Pi0.5 discretises the robot state into 256 bins and writes it into the language prompt, where Pi0 fed state in continuously. That is why the lerobot prompt budget jumps from 48 tokens to 200.

# lerobot main branch, files read 2026-08-23
# src/lerobot/policies/pi0/configuration_pi0.py
class PI0Config(PreTrainedConfig):
    paligemma_variant: str = "gemma_2b"
    action_expert_variant: str = "gemma_300m"
    chunk_size: int = 50
    n_action_steps: int = 50
    num_inference_steps: int = 10
    tokenizer_max_length: int = 48
    normalization_mapping = {
        "VISUAL": NormalizationMode.IDENTITY,
        "STATE":  NormalizationMode.MEAN_STD,
        "ACTION": NormalizationMode.MEAN_STD,
    }

# src/lerobot/policies/pi05/configuration_pi05.py
class PI05Config(PreTrainedConfig):
    paligemma_variant: str = "gemma_2b"        # same
    action_expert_variant: str = "gemma_300m"  # same
    chunk_size: int = 50                       # same
    n_action_steps: int = 50                   # same
    num_inference_steps: int = 10              # same
    optimizer_lr: float = 2.5e-5               # same
    tokenizer_max_length: int = 200            # four times the prompt budget
    normalization_mapping = {
        "VISUAL": NormalizationMode.IDENTITY,
        "STATE":  NormalizationMode.QUANTILES,  # q01 / q99, not mean / std
        "ACTION": NormalizationMode.QUANTILES,
    }

# src/lerobot/policies/pi05/processor_pi05.py, lerobot main branch
# State arrives already normalised to [-1, 1] by the normalizer step.
discretized_states = np.digitize(state_np, bins=np.linspace(-1, 1, 256 + 1)[:-1]) - 1
...
state_str = " ".join(map(str, discretized_states[i]))
full_prompt = f"Task: {cleaned_text}, State: {state_str};\nAction: "

Change 3: hierarchical inference, and why you probably will not get it

The headline behaviour in the Pi0.5 paper is a two-stage rollout: the model predicts a semantic subtask in language, something like "pick up the pillow", then conditions the expert on it. Physical Intelligence describes a kind of chain of thought, where the model "first produces a high-level action expressed in language" and then "selects the motor commands using its flow matching action expert".

Change 4: the data, which is most of the generalisation story

It is tempting to attribute all of Pi0.5 to the gradient cut. The paper does not. Models trained without the full recipe are "significantly worse", and Physical Intelligence's own summary is that web data "makes the biggest difference for generalizing to out-of-distribution objects, while data from other robots (ME and CE) is important across all evaluation conditions".

Read the last two columns. Dropping web data costs one point of in-distribution success and twenty on out-of-distribution objects; dropping the other robots' data costs everything, everywhere. Proportions matter as much: 97.6 percent of the first-phase examples are not mobile manipulators doing household tasks. The scaling curve trains on 3, 12, 22, 53, 82 and 104 locations, and a control trained directly on the test homes "attains similar performance as the final 104-location model". Evaluation ran in three kitchens and three bedrooms never seen in training, on tasks of about 2 to 5 minutes.

To see where the two sit against everything published in the same eighteen months, the arena has a row for Pi0, Pi0-FAST and Pi0.5, and each number links out to its source instead of asking you to trust a summary table.

What the benchmark numbers actually say

Neither paper gives a clean scalar for "Pi0.5 is N percent better than Pi0", and you should distrust anyone quoting one. The comparison is a figure caption: the full model "significantly outperforms both Pi0 and Pi0-FAST+Flow in the mock home test environments". The reproducible number is LIBERO, where the lerobot team fine-tuned the LIBERO base model for 6k extra steps against the openpi reference.

So which one do you fine-tune today

The summary for someone with an SO-100 on the desk: pick Pi0.5, not Pi0. To decide whether this family is right at all, the comparisons that matter are GR00T N1.7 against Pi0.5 and Pi0.5 against SmolVLA, because those decide the GPU bill and the control loop.

Fine-tuning Pi0.5 on your own recordings

Where this does not help

Pi0.5's selling point is open-world generalisation across homes. One SO-100 doing one task on one desk is not that problem. Knowledge insulation still buys faster convergence and better language grounding, but the 104-location scaling curve is not something a hobby dataset reproduces. If a policy fails, the failure mode pages beat a bigger model, because most first-run failures are imitation learning data problems, not architecture problems.

Read that as a control-loop budget, not a quality ranking. ACT at 20 ms is not better than Pi0.5. It is a from-scratch policy with no language grounding, which is why it is fast. SmolVLA at 245 ms and 30 minimum episodes is the middle option on a 24 GB card. If inference latency is killing you, moving down that table beats tuning the model you have.

What came after Pi0.5

Physical Intelligence did not stop in April 2025. Pi-star 0.6 (17 November 2025) adds a reinforcement learning stage called RECAP on top of demonstrations and corrections. MEM (arXiv 2603.03596, 4 March 2026) adds mixed-modal memory for tasks up to fifteen minutes, and its switches already sit in the lerobot pi05 config as use_visual_memory and use_proprioceptive_memory, both False by default. The arena entry for Pi-star 0.6 and Pi0.7 track the rest.

None of it changes today's answer. As of August 2026 the fine-tunable, openly released, dataset-compatible member of the family is Pi0.5, which is the one on the training matrix. Never trained a VLA at all? Train your first policy and the training docs are the shorter way in, and the fine-tuning glossary entry defines the terms above.