Physical Intelligence (π): The Models, openpi on GitHub, and the New Pi API

Published: by

Physical Intelligence, which writes its name as π, is a robotics AI company building one model that can control many kinds of robots. Its models are called π0, π0.5, π*0.6 and π0.7. As of October 19, 2026, you can download three of them for free: π0, π0-FAST and π0.5 are in the openpi GitHub repository under the Apache-2.0 license. The newer models are not open. Since October 13, 2026, Physical Intelligence offers its latest models through the Pi API beta, which you join through a waitlist.

If you searched “physical intelligence” for the general idea of AI that acts in the real world, that is usually called physical AI, and our guide to physical AI covers it. This page is about the company.

What Physical Intelligence is building

The company describes its goal on its homepage as general-purpose AI for the physical world: learning algorithms for a model that can control any robot to perform any task. In practice that means vision-language-action (VLA) models. A VLA model takes camera images and a text instruction such as “fold the towel” and outputs the motor commands a robot arm should execute next.

Physical Intelligence does not sell robots. Its business is the model layer. In a February 2026 post, The Physical Intelligence Layer, it named two companies deploying robots on its models: Weave, which builds home robots that fold laundry at businesses in the San Francisco Bay Area, and Ultra, which builds warehouse robots for e-commerce order packaging.

The π models, from π0 to π0.7

Each model below links to the company’s own announcement and notes whether its weights are open, which decides whether you can run it yourself today.

  • π0 (October 31, 2024): the first generalist policy, a flow-based VLA. Open since February 4, 2025 (π0 announcement).
  • π0-FAST (January–February 2025): an autoregressive version built on the FAST action tokenizer. Open. The company says its inference cost is roughly 4–5 times higher than π0 (Open Sourcing π0).
  • π0.5 (April 22, 2025): built for new environments. A mobile robot running it cleaned homes that were not in its training data, though the company notes it “does not always succeed on the first try.” Open since September 2025 (π0.5 announcement).
  • π0.6 and π*0.6 (November 17, 2025): π0.6 refines π0.5; π*0.6 adds a training method called Recap that learns from demonstrations, human corrections and the robot’s own attempts. Physical Intelligence reports it more than doubled throughput on some of the hardest tasks. No released weights (π*0.6 announcement).
  • π0.7 (April 16, 2026): a “steerable” model that accepts more than text as a prompt, including speed and quality labels and subgoal images. The company showed it folding laundry on a dual-arm UR5e robot for which no laundry data had been collected. No released weights (π0.7 announcement).

All demonstrations above are the company’s own results. We have not found independent tests that reproduce the π*0.6 or π0.7 numbers.

What openpi includes

openpi is the GitHub repository most people mean when they search “pi github.” According to its README as of October 19, 2026, it contains:

  • Base models for fine-tuning: pi0_base, pi0_fast_base and pi05_base, pre-trained on more than 10,000 hours of robot data.
  • Ready-to-run checkpoints: versions tuned for the DROID robot (a single Franka arm), for ALOHA dual-arm tasks such as folding a towel or uncapping a pen, and for the LIBERO simulation benchmark.
  • Code for inference and fine-tuning in JAX, plus a PyTorch version of π0 and π0.5 added in September 2025. The PyTorch version does not yet support π0-FAST, LoRA training or mixed precision.

The checkpoints were trained on specific robots. The company’s own release post warns that π0 “may or may not work for you,” and that the demo checkpoints may not work on a different robot without fine-tuning on your own data. In its experiments, 1 to 20 hours of task data was enough for fine-tuning, with results that varied.

Hardware you need to run openpi

The README lists single-GPU memory needs:

  • Running a model (inference): more than 8 GB of GPU memory, for example an RTX 4090.
  • Fine-tuning with LoRA: more than 22.5 GB, for example an RTX 4090.
  • Full fine-tuning: more than 70 GB, for example an A100 80GB or H100.

Ubuntu 22.04 is the only operating system the team has tested. Multi-GPU training on one machine is supported; training across several machines is not.

How to start with openpi

  1. Clone the repository with its submodules: git clone --recurse-submodules https://github.com/Physical-Intelligence/openpi.git
  2. Install uv, the Python package manager the project uses.
  3. In the repository folder, run GIT_LFS_SKIP_SMUDGE=1 uv sync and then GIT_LFS_SKIP_SMUDGE=1 uv pip install -e . The prefix is needed so LeRobot installs as a dependency. A Docker setup is also documented in the repository.
  4. Pick a checkpoint. Checkpoints download automatically to ~/.cache/openpi the first time you load one.
  5. Run a checkpoint that matches your setup first (DROID, ALOHA or LIBERO), then fine-tune a base model on your own robot’s data if your robot is different.

If you plan to run the model on a separate GPU server and send it observations from the robot, our note on openpi remote inference covers where image and state transforms should run.

How the Pi API beta works

The Pi API is for teams that want the newer models without training them on their own GPUs. According to the October 13, 2026 announcement, the flow is:

  1. Join the waitlist and describe what you want to build.
  2. Once admitted, upload your robot’s demonstration data.
  3. Fine-tune a π model on Physical Intelligence’s compute.
  4. Run the fine-tuned model on your robot through hosted, cloud-based inference.
  5. Use the robot’s failures and evaluation data to decide what to collect next, and repeat.

The announcement does not say how applicants are selected, what it costs, which robots are supported, or which model version the API serves beyond “the latest.” It also mentions that some early deployments ran into network connectivity problems, which matters because hosted inference means the robot depends on a connection to Physical Intelligence’s servers.

openpi or the Pi API?

  • Choose openpi if you need to run offline, inspect and change the code, or avoid sending robot data to a third party. You supply the GPUs and do the fine-tuning work yourself, and you are limited to π0, π0-FAST and π0.5.
  • Join the Pi API waitlist if you want the newest models and managed training, and you can accept cloud inference, data upload and terms that have not been published yet.

For how π compares with other robot model approaches, see our explainers on world models versus VLA systems and on Figure AI’s Helix, a VLA that Figure builds for its own robots rather than releasing to others.