Psi0: Why 80 Trajectories Beat 80,000 in Humanoid Robotics

What if everything you believed about robot training data was wrong?

For years, the robotics community chased an arms race of scale—more demonstrations, more sensors, more compute. Companies burned millions collecting hundreds of thousands of trajectories, convinced that volume alone would unlock general-purpose humanoid intelligence. The result? Bloated datasets, brittle policies, and robots that still stumbled when faced with the slightest variation.

Then came Psi0.

Developed by the Physical Superintelligence Lab at USC, Psi0 (Ψ₀) is an open vision-language-action model that shatters the conventional wisdom. Its secret weapon isn't more data—it's smarter data. By pre-training on large-scale human egocentric videos to learn task semantics and visual representations, then post-training on a remarkably small amount of real-world teleoperated data, Psi0 achieves what seems impossible: acquiring new dexterous loco-manipulation skills with as few as 80 trajectories.

Yes, you read that correctly. Eighty. Not eight thousand. Not eighty thousand. Just eighty carefully curated real-world demonstrations.

This isn't incremental improvement. This is a paradigm shift. And it's completely open-source.

Ready to see how they pulled it off? Let's dive into the architecture, the methodology, and the exact steps you can follow to fine-tune your own humanoid robot today.

What is Psi0?

Psi0 is an open foundation model for dexterous humanoid loco-manipulation—the challenging intersection of locomotion (walking, balancing, moving) and manipulation (grasping, manipulating objects). Presented at RSS 2026, it represents one of the most significant open contributions to humanoid robotics in recent years.

The project comes from the Physical Superintelligence Lab (PSI Lab) at the University of Southern California, led by researchers including Songlin Wei, Hongyi Jing, Boqian Li, and advisors like Marco Pavone (Stanford) and Yue Wang. Their core insight, repeated throughout their work: "Our key finding is that scaling the right data in the right way."

What makes Psi0 genuinely different from the flood of VLA models emerging in 2024-2025?

First, its three-tier architecture explicitly separates cognition from reflex, mirroring human neuroscience:

System-2: A vision-language backbone based on Qwen3-VL-2B-Instruct that handles high-level reasoning, instruction following, and scene understanding
System-1: A flow-based multimodal diffusion transformer (~500M parameters) that predicts future whole-body action chunks, inspired by Stable Diffusion 3's architecture
System-0: An RL-based tracking controller that executes lower-body commands with physical stability

This decoupled design is crucial. Most prior approaches either conflate reasoning and control (leading to slow, unstable behavior) or use entirely separate pipelines that don't share representations. Psi0's System-1 and System-2 are end-to-end trained together, enabling efficient fusion of visual, linguistic, and action representations.

The model is trending now because it solves the data efficiency crisis plaguing humanoid robotics. While competitors like Figure AI, Tesla Optimus, and various closed industrial projects hoard data behind proprietary walls, Psi0 demonstrates that open science with clever pre-training strategies can match or exceed closed-system performance.

Key Features That Make Psi0 Revolutionary

Let's dissect what makes this architecture technically special:

Egocentric Video Pre-Training on Internet-Scale Data

Psi0 doesn't start from scratch on robot data. It first learns task semantics and visual representations from EgoDex—a massive dataset of human egocentric videos—and the Humanoid Everyday (HE) dataset. This gives it prior knowledge about how humans interact with objects, move through spaces, and accomplish goals. The model learns what to do before it ever touches a robot.

Flow-Based Multimodal Diffusion for Action Generation

The action expert doesn't regress single actions. It generates future whole-body action chunks using flow-based diffusion, conditioned on the VLM's vision-language features. This enables:

Temporally coherent motion (no jerky frame-by-frame decisions)
Multimodal action distributions (handling uncertainty by sampling diverse valid actions)
Efficient long-horizon planning through chunk prediction

48 Degrees-of-Freedom Whole-Body Control

Humanoid robots like the Unitree G1 have extraordinarily complex kinematics. Psi0 predicts 48 DoF actions covering arms, legs, torso, and gripper simultaneously. Most prior VLA models focused on upper-body manipulation only; Psi0 tackles the full loco-manipulation problem—walking while manipulating, balancing while reaching.

Decoupled Whole-Body Control with RL Tracking

The System-0 controller is critical for physical reliability. While the diffusion transformer generates desired poses, a dedicated reinforcement learning-based tracking controller handles the low-level motor commands. This separation means Psi0 can generate ambitious motions while the RL policy ensures the robot doesn't fall over.

Complete Open-Source Ecosystem

Unlike fragmented research releases, Psi0 provides:

Full model weights on HuggingFace
Complete training and evaluation data on HuggingFace Datasets
The SIMPLE simulator for benchmarking without hardware
Baseline implementations for GR00T, π₀.5, InternVLA-M1, H-RDT, and more

Use Cases: Where Psi0 Shines

1. Rapid Skill Acquisition for New Tasks

The headline use case: you have a Unitree G1 and need it to perform a new warehouse task. Instead of collecting thousands of demonstrations, you record 80 teleoperated trajectories, fine-tune Psi0 for a few hours, and deploy. The pre-trained visual semantics handle object recognition and spatial reasoning; the post-training adapts dynamics to your specific embodiment.

2. Research on Data-Efficient Robot Learning

Psi0 is a scientific instrument for studying generalization. Researchers can ablate pre-training datasets, test transfer between simulation and reality, or probe how few trajectories different skills require. The released ablation checkpoints (EgoDex-only, HE-only, 10% EgoDex variants) enable rigorous analysis.

3. Simulation-to-Reality Transfer Development

With the SIMPLE simulator (built on MuJoCo physics and Isaac Sim rendering), teams can iterate in simulation before any hardware investment. The simulator supports both motion-planning generated data and human teleoperation, with three levels of domain randomization for robustness testing.

4. Comparative Benchmarking of VLA Architectures

Psi0 ships with six major baselines fully integrated: GR00T N1.6, OpenPI π₀.5, InternVLA-M1, H-RDT, EgoVLA, Diffusion Policy, and ACT. This isn't just a model release—it's a benchmarking platform for the entire field. Researchers can directly compare architectural choices on identical tasks.

5. Low-Resource Robotics Labs and Startups

Not every team has Figure AI's budget. Psi0 enables small teams with limited data collection infrastructure to compete. The 80-trajectory requirement means a single operator with a teleoperation setup can generate a training dataset in a day, not months.

Step-by-Step Installation & Setup Guide

Ready to run Psi0 yourself? Here's the complete setup:

Clone and Prepare Environment

# Clone the repository
git clone git@github.com:physical-superintelligence-lab/Psi0.git
cd Psi0

# Install uv for Python^{↗ Bright Coding Blog} dependency management
curl -LsSf https://astral.sh/uv/install.sh | sh

Create Psi0 Virtual Environment

# Create isolated environment with Python 3.10
uv venv .venv-psi --python 3.10
source .venv-psi/bin/activate

# Install core dependencies with specific groups for serving, visualization, and Psi0
GIT_LFS_SKIP_SMUDGE=1 uv sync \
  --group serve \
  --group viz \
  --group psi \
  --index-strategy unsafe-best-match \
  --active

# Flash Attention is required for efficient attention computation
uv pip install flash_attn==2.7.4.post1 --no-build-isolation

Optional: Full Installation with SIMPLE Simulator

# Initialize simulation submodule
git submodule update --init --recursive

# Install all dependency groups including SIMPLE
GIT_LFS_SKIP_SMUDGE=1 uv sync --all-groups --index-strategy unsafe-best-match --active
uv pip install flash_attn==2.7.4.post1 --no-build-isolation

# Install CuRobo for motion planning (replace pwd with actual path)
UV_PROJECT_ENVIRONMENT=$(pwd)/.venv-psi ./scripts/install_curobo.sh

Verify Installation

# Core Psi0 import test
python -c "import psi; print(psi.__version__)"

# SIMPLE simulator verification (if installed)
python -c "import simple; print(simple.__version__)"

# Verify shared LeRobot data stack
python -c "from psi.data.lerobot.compat import LEROBOT_LAYOUT; print(LEROBOT_LAYOUT)"

Environment Configuration

# Copy sample environment file
cp .env.sample .env

# Edit .env with your credentials:
# HF_TOKEN=<YOUR HUGGINGFACE READ TOKEN>
# WANDB_API_KEY=<Weights & Biases API key>
# WANDB_ENTITY=<your wandb entity>
# PSI_HOME=<path for checkpoints, cache, and data>

# Load environment variables
source .env
echo $PSI_HOME

REAL Code Examples from the Repository

Let's examine actual code from the Psi0 repository, with detailed explanations of what each section accomplishes.

Example 1: Data Pre-Processing Pipeline

Before training, raw teleoperation data must be converted to LeRobot format. Here's the exact workflow:

# Download pre-collected real-world task data from HuggingFace
export task=Hug_box_and_move

hf download USC-PSI-Lab/psi-data \
  g1_real_raw/$task.zip \
  --local-dir=$PSI_HOME/data/real_teleop_g1 \
  --repo-type=dataset

# Extract the downloaded archive
unzip $PSI_HOME/data/real_teleop_g1/g1_real_raw/$task.zip \
  -d $PSI_HOME/data/real_teleop_g1/g1_real_raw/$task

The expected folder structure after extraction:

g1_real_raw/
└── Hug_box_and_move/
    ├── episode_0/
    │   ├── color/              # RGB camera frames
    │   │   ├── frame_000000.jpg
    │   │   └── ...
    │   └── data.json           # Joint states, actions, timestamps
    └── ...

Why this matters: Psi0 uses the LeRobot dataset format—an emerging community standard for robot learning data. This ensures interoperability with other tools and models. The data.json contains the raw robot states, while color/ holds synchronized visual observations.

Example 2: Task Description and Conversion to Training Format

# Edit task descriptions for natural language conditioning
vim scripts/data/task_description_dict.json

{
  "Hug_box_and_move": "Hug box and move."
}

# Convert raw data to LeRobot format with robot-specific parameters
python scripts/data/raw_to_lerobot.py \
  --data-root=$PWD/data/real_teleop_g1/g1_real_raw \
  --work-dir=$PWD/data/real \
  --repo-id=psi0-real-g1 \
  --robot-type=g1 \
  --task=$task

# Compute normalization statistics for stable training
python scripts/data/calc_modality_stats.py \
  --work-dir=$PSI_HOME/data/real \
  --task=$task

# Create Psi0-specific stats file (currently a copy, may extend in future)
cp $PSI_HOME/data/real/$task/meta/stats.json \
   $PSI_HOME/data/real/$task/meta/stats_psi0.json

Critical insight: The task_description_dict.json enables language-conditioned policy learning. During training, the model sees both visual observations and natural language instructions, learning to ground linguistic commands in physical actions. The statistics computation ensures proper normalization across different sensor modalities.

Example 3: Launching Fine-Tuning on Real Robot Data

# Apply critical fix for real data loading (known issue #3)
python scripts/data/patch_lerobot_meta.py $PSI_HOME/data/real/$task

# Download and extract pre-collected demonstration data
export task=Pick_bottle_and_turn_and_pour_into_cup

hf download USC-PSI-Lab/psi-data \
  real/$task.zip \
  --local-dir=$PSI_HOME/data \
  --repo-type=dataset

unzip $PSI_HOME/data/real/$task.zip -d $PSI_HOME/data/real

# Launch fine-tuning with the provided script
scripts/train/psi0/finetune-real-psi0.sh $task

# Or specify GPU devices explicitly
CUDA_VISIBLE_DEVICES=0,1,2,3 scripts/train/psi0/finetune-real-psi0.sh $task

Training configuration note: The team emphasizes maintaining global batch size = 128 across all experiments. This equals device_batch_size × num_GPUs × gradient_accumulation_steps. Don't ignore this—the model's convergence properties depend on this specific batch scale.

Example 4: Real-Time Deployment Serving

# Terminal 1: Start the Psi0 server in RTC (Real-Time Communication) mode
bash ./scripts/deploy/serve_psi0-rtc.sh

# Terminal 2: Start the client that connects to physical robot
bash ./real/scripts/deploy_psi0-rtc.sh

Architecture insight: The deployment uses a client-server architecture where the heavy VLA inference runs on a GPU server, while a lightweight client handles robot I/O. This separation is essential for real-time performance—the diffusion model's inference isn't instantaneous, so the server pre-computes action chunks that the client executes with precise timing.

Example 5: Simulation-Based Evaluation with Domain Randomization

# Set evaluation parameters
export task=G1WholebodyXMovePickTeleop-v0
export dr=level-0  # Options: level-0, level-1, level-2

# Select appropriate evaluation entrypoint based on data collection method
# For teleoperation-collected tasks:
export entry=eval_decoupled_wbc.py
export agent=psi0_decoupled_wbc

# For motion-planning-generated tasks:
# export entry=eval.py
# export agent=psi0

# Launch evaluation in SIMPLE simulator
python src/simple/cli/$entry \
  simple/$task \
  $agent \
  $dr \
  --host=localhost \
  --port=9000 \
  --sim-mode=mujoco_isaac \
  --no-headless \
  --data-format=lerobot \
  --data-dir=data/evals/simple-eval/$task/$dr

Domain randomization levels: level-0 tests exact training conditions; level-1 varies textures and lighting; level-2 adds object geometry and dynamics perturbations. This progressive difficulty reveals true generalization versus memorization.

Advanced Usage & Best Practices

Memory Optimization for Limited GPUs

If your GPU has constrained VRAM, add this training flag:

--train.optimizer-foreach=false

This trades some optimization speed for reduced memory usage during optimizer steps.

Multi-GPU Training Strategy

The global batch size of 128 is non-negotiable for reproducing results. With fewer GPUs, increase gradient accumulation:

# 4 GPUs × batch 8 × accumulation 4 = global 128
CUDA_VISIBLE_DEVICES=0,1,2,3 scripts/train/psi0/finetune-real-psi0.sh $task --gradient-accumulation-steps=4

Pre-Training from Scratch

For researchers building variants, the full pipeline is:

VLM Pre-Training: EgoDex (200K steps) → Humanoid Everyday (30K steps)
Save backbone: Extract Qwen3-VL weights with learned visual representations
Action Expert Post-Training: Initialize from frozen VLM, train diffusion transformer on HE data
Fine-Tuning: Your task-specific 80 trajectories

Data Collection Quality Over Quantity

The 80-trajectory result assumes high-quality teleoperation. Key principles:

Demonstrate the full task completion, not partial attempts
Maintain consistent speed—jerky demonstrations confuse dynamics learning
Include diverse initial conditions when possible
Use the provided visualization tools to verify data before training

Comparison with Alternatives

Feature	Psi0	GR00T N1.6	π₀.5 (OpenPI)	InternVLA-M1	H-RDT
Open Source	✅ Full	⚠️ Partial	✅ Full	✅ Full	✅ Full
Pre-training Data	EgoDex + HE	Video + Sim	Video + Robot	Video	EgoDex
Real Trajectories for New Skill	80	Thousands	Hundreds	Hundreds	Hundreds
Whole-Body Control	✅ 48 DoF	Upper body	Upper body	Upper body	Upper body
Loco-Manipulation	✅ Native	❌ No	❌ No	❌ No	❌ No
Diffusion Action Model	✅ Flow-based	❌ No	✅ Diffusion	❌ No	❌ No
Built-in Simulator	✅ SIMPLE	❌ No	❌ No	❌ No	❌ No
Baseline Comparisons	✅ 6 methods	Self only	Self only	Self only	Self only
RL-Based Tracking	✅ System-0	❌ No	❌ No	❌ No	❌ No

Why Psi0 wins: It's the only open model designed for the full loco-manipulation problem, with explicit architectural support for stable walking while manipulating. The data efficiency isn't magic—it's the result of proper pre-training on human egocentric video before any robot data touches the model. Competitors either skip this step or use less relevant pre-training data.

FAQ

What hardware do I need to fine-tune Psi0?

For fine-tuning on real robot data: 4× NVIDIA A100/H100 (40GB+) or equivalent. For inference/deployment: 1× RTX 4090 suffices. The SIMPLE simulator requires an NVIDIA GPU (3090/4090/5090 recommended) for IsaacSim rendering.

Can I use Psi0 with robots other than Unitree G1?

The released checkpoints target G1 kinematics. For other humanoids, you'd need to re-collect data and potentially adjust the action space dimensions. The architecture itself is embodiment-agnostic—the VLM backbone doesn't care about robot morphology.

Is 80 trajectories really enough for any task?

The 80-trajectory result applies to skills within the pre-training distribution—tasks involving object manipulation, locomotion, and human-like interactions. Highly novel physical skills (e.g., juggling, precise assembly) may require more data. The key is that Psi0's pre-training captures generic human affordances.

How does Psi0 handle safety during deployment?

The System-0 RL controller provides physical stability guarantees for lower-body motion. However, as with any learned policy, deployment requires human supervision, workspace boundaries, and emergency stop mechanisms. The repository includes real-world deployment guides with safety protocols.

What's the difference between Psi0 and π₀ (pi-zero)?

π₀ from Physical Intelligence is a closed, commercial system with undisclosed training details. Psi0 is fully open, academically documented, and specifically optimized for humanoid loco-manipulation rather than general manipulation. The architectural choices (flow-based diffusion, explicit System-0 controller) differ significantly.

Can I contribute to Psi0 or build commercial applications?

Yes! Psi0 is Apache 2.0 licensed. You can modify, distribute, and commercialize. The team encourages community contributions, especially for additional robot platforms, task domains, and baseline comparisons.

Where do I report issues or get help?

Use the GitHub Issues page. The troubleshooting section in the README covers common installation problems, including CUDA version mismatches, evdev compilation failures, and libtorchcodec issues.

Conclusion

Psi0 represents something rare in today's AI landscape: genuine scientific insight packaged as usable open-source infrastructure. The revelation that 80 trajectories can suffice isn't a trick—it's the payoff from scaling the right data in the right way, specifically pre-training on human egocentric video before touching any robot data.

For researchers, Psi0 is a platform to study generalization, data efficiency, and embodiment. For practitioners, it's a viable path to deployable humanoid skills without industrial-scale data collection. For the field, it's proof that open science can compete with closed commercial labs when the methodology is sound.

The architecture choices matter: the System-2/System-1/System-0 decomposition, the flow-based diffusion for action generation, the explicit RL-based tracking controller. These aren't arbitrary—they solve specific problems that prior VLA models ignored, particularly the stability of whole-body humanoid motion.

My assessment? Psi0 is the most important open humanoid robotics model of 2026. Not because it's the biggest, but because it changes the economics of the field. When 80 trajectories replace 80,000, suddenly every robotics lab, every startup, every curious engineer can participate in humanoid intelligence.

Get started today: Clone the repository at github.com/physical-superintelligence-lab/Psi0, download the pre-trained weights from HuggingFace, and fine-tune your first humanoid skill. The future of general-purpose robotics is open—and it's here.

Found this analysis valuable? Star the Psi0 repository and share your experiments with the community.