Physical AI Studio helps teams train, benchmark, and deploy robot policies from demonstrations.

Studio UI • Python API • CLI • Policies • Install • Documentation

---

Studio UI

Collect demonstrations, train policies, and run inference through a visual interface.

Start Studio with Docker · Native setup

Copy Docker start commands

git clone https://github.com/open-edge-platform/physical-ai-studio.git
cd physical-ai-studio/application/docker
cp .env.example .env
./setup-devices.sh --cpu # or --xpu or --cuda
docker compose up -d

Open http://localhost:7860. See the Docker guide for hardware options and setup. Configure HF_TOKEN in application/docker/.env for Hugging Face-backed policies; see Hugging Face integration.

Native development commands

Native setup is for contributors and requires OS-level libraries, uv, and Node.js v24. See the prerequisites.

In one terminal, from the repository root:

cd application/backend
uv run --extra xpu physicalai-studio serve # or --extra cpu / --extra cuda

In a second terminal, also from the repository root:

cd application/ui
npm install
npm run start

Open http://localhost:3000. For native Hugging Face setup, use Settings > General > Hugging Face.

Python API

Train, benchmark, and export policies programmatically.

The library also supports LIBERO and RoboCasa benchmarks; see the benchmarking guide for suite-specific setup and checkpoint requirements.

Copy the Python example

from physicalai.benchmark.gyms import PushTBenchmark
from physicalai.data import LeRobotDataModule
from physicalai.inference import InferenceModel
from physicalai.policies import ACT
from physicalai.train import Trainer

datamodule = LeRobotDataModule(repo_id="lerobot/pusht", num_workers=0)
policy = ACT()

trainer = Trainer(max_epochs=100)
trainer.fit(model=policy, datamodule=datamodule)

benchmark = PushTBenchmark(num_episodes=50)
results = benchmark.evaluate(policy)

policy.export("./exports/act", backend="openvino")
runtime_policy = InferenceModel("./exports/act")

A PushT-trained policy is not directly usable on a physical robot; use a policy trained for that robot with a matching Runtime config. See the robot deployment guide.

CLI

Run Studio training, benchmarking, and export from Runtime's physicalai CLI; Runtime also provides the run command for deployment.

Copy the CLI commands

The example configs live in library/configs; run these Studio commands from library/ in a cloned repository:

# From the repository root
cd library

# Train on PushT
physicalai fit \
  --config configs/physicalai/act/pusht/default.yaml

# Benchmark the trained checkpoint
physicalai benchmark \
  --config    configs/benchmark/pusht.yaml \
  --policy    physicalai.policies.ACT \
  --ckpt_path experiments/lightning_logs/version_0/checkpoints/last.ckpt

# Export for deployment
physicalai export \
  --policy     physicalai.policies.ACT \
  --ckpt_path  experiments/lightning_logs/version_0/checkpoints/last.ckpt \
  --backend    openvino \
  --output_dir exports/act

From your Runtime project, run a robot policy with:

physicalai run --config runtime.yaml

Use the Runtime config example as runtime.yaml; it is separate from the PushT training config above.

Policies

Native policy families include ACT, Pi0.5, SmolVLA, MolmoAct2, RLDX-1, XR0, and Cosmos3; see the library’s supported policies.

Install

Use the library for Python API and CLI workflows, or follow the Studio UI setup above. The library supports Python 3.12–3.14.

See the library installation guide for source installs and optional dependencies.

Copy the Python install command

# Choose one hardware extra:
pip install 'physicalai-train[cpu]'    # CPU
# pip install 'physicalai-train[cu128]' # NVIDIA GPU
# pip install 'physicalai-train[xpu]'   # Intel GPU

Documentation

Library · Application · Contributing