π0.5 RoboCasa

seq init pi05-robocasa gives the stable version, seq init pi05-robocasa@beta the beta, and seq init pi05-robocasa@v<N> any version below that is not withdrawn. A deployment made from this template names the version it runs in seq policy versions and on its page in the console; seq policy upgrade moves it to the newer stable one.

1. v82026-10-13beta

   A deployment of this version runs on one card type, the L4: a worker starts only on an L4, never on an A100.

   Needs sequence-ai 0.34.17 or later.

   • policy.py declares gpu="L4", where v7 listed ["L4", "A100-40GB"]: a deployment names one card type. To run on another card, name that one instead.
   • README.md says so where it spoke of the A100.
   • The image, its frozen files, the weights, the contract and the serving code are v7's.
   Use v8

   pi05-robocasa v8shell

   # start a policy from this version, then deploy it
   seq init pi05-robocasa@v8 my-policy
   seq deploy my-policy/policy.py
   
   # or move a deployment made from this template to it
   seq policy upgrade my-policy --to v8

2. v72026-10-13stable

   The image installs openpi from third_party/openpi, the copy in your folder, and everything else only from this version's frozen files, which the platform keeps: v6's packages, the same on any day.

   Needs sequence-ai 0.34.17 or later.

   • policy.py copies openpi's pyproject.toml, README.md, LICENSE, src/ and packages/openpi-client/ from third_party/openpi into the image and installs them, editable at /opt/openpi as before: change openpi there and deploy again, and your deployment runs your openpi. third_party/README.md lists what goes into the image.
   • Everything else comes from /seq/frozen (.template_files("pi05-robocasa", version=7)), with no index: the base nvidia/cuda:12.2.2-cudnn8-runtime-ubuntu22.04 by digest, the system packages as .deb files, every Python package with its sha256 checked against requirements-policy.lock, and lerobot from its source. frozen.toml says what is frozen.
   • The Python packages are the 209 that v6's image holds (pins-policy.txt), torch 2.7.1 and JAX 0.5.3 among them, and openpi, its client and lerobot from their sources: the build installs nothing from PyPI or GitHub.
   • openpi comes without its two submodules, which the image never used: LIBERO, and ALOHA's own code and hardware files.
   • To add a package or change a version, add your own step after the template's (.uv_pip_install(...)); it installs from PyPI as any image does.
   • The weights, the contract and the serving code are as in v6.
   Use v7

   pi05-robocasa v7shell

   # start a policy from this version, then deploy it
   seq init pi05-robocasa@v7 my-policy
   seq deploy my-policy/policy.py
   
   # or move a deployment made from this template to it
   seq policy upgrade my-policy --to v7

   In the console, Deploy deploys this version: the console deploys the stable one.

3. v62026-10-13

   The source the image builds from comes with the template: openpi at the commit the image pins, in third_party/, with its licenses; LICENSE and NOTICE come with the template too.

   Needs sequence-ai 0.31.0 or later.

   • third_party/openpi/: https://github.com/Physical-Intelligence/openpi at commit 215abfb217dbac7d5f1273282331b9b1866c0479, with its submodule third_party/aloha (MIT). Left out, as third_party/README.md says: the LIBERO submodule (its assets include objects under non-commercial terms and with no license given) and ALOHA 2's hardware files (102 MB); this template uses neither.
   • LICENSE (Apache-2.0, for the template's own files) and NOTICE (the checkpoint's terms - Gemma's notice first - and where the code comes from) come with the template.
   • The image, its weights and what it installs are as in v5.
   Use v6

   pi05-robocasa v6shell

   # start a policy from this version, then deploy it
   seq init pi05-robocasa@v6 my-policy
   seq deploy my-policy/policy.py
   
   # or move a deployment made from this template to it
   seq policy upgrade my-policy --to v6

4. v52026-10-10

   The README says to declare cpu and memory for all the copies when a worker runs several copies of the model.

   Needs sequence-ai 0.31.0 or later.

   • Each copy is a process of its own, with its own host memory: two pi05-libero copies on one L4 used up to 20.4 GiB, where one copy uses about 10 (measured on the platform).
   • For two copies, declare cpu=2.5, memory=24. The price shown at deploy counts the CPU one robot uses, and a worker with a robot on every copy is billed at the greater of request and use.
   • README only: the code and the image are v4's.
   Use v5

   pi05-robocasa v5shell

   # start a policy from this version, then deploy it
   seq init pi05-robocasa@v5 my-policy
   seq deploy my-policy/policy.py
   
   # or move a deployment made from this template to it
   seq policy upgrade my-policy --to v5

5. v42026-10-10

   A worker that runs several copies of the model starts in about the time of one: the copies share one bf16 copy of the params and warm a lone request only.

   Needs sequence-ai 0.31.0 or later.

   • With @seq.concurrent(replicas_per_gpu=N) under @seq.policy, the first load leaves the params as bf16 (about 6.7 GB) in the deployment's compile cache, and every later load maps them from there instead of each copy restoring the checkpoint into its own memory.
   • On such a worker the warmup compiles a lone request only. Each copy compiles a batch size the first time a batch of that size comes (an eval's): about 5 s each on a B200, once an earlier worker has compiled it.
   • Eight pi05-libero copies on one B200 went from start to ready in 69-82 s, against 153-185 s before and 62 s for one copy alone (measured on the platform).
   • The shared copy is billed as storage, like the rest of the compile cache. A worker of one copy keeps none, warms every batch size and loads as before.
   Use v4

   pi05-robocasa v4shell

   # start a policy from this version, then deploy it
   seq init pi05-robocasa@v4 my-policy
   seq deploy my-policy/policy.py
   
   # or move a deployment made from this template to it
   seq policy upgrade my-policy --to v4

6. v32026-10-09

   The image installs openpi at one fixed commit and its dependencies as PyPI had them on 2026-10-03, so a rebuild on any day installs exactly the same packages.

   Needs sequence-ai 0.31.0 or later.

   • policy.py checks out openpi at 215abfb (openpi's main of 2026-08-24), installs uv 0.12.22, and resolves openpi's dependencies with --exclude-newer 2026-10-03T03:32:00Z.
   • Earlier versions build openpi's latest commit with whatever PyPI has that day: on 2026-10-09 that was pyarrow 26.0.0, which needs NumPy 2, beside openpi's NumPy 1.26.4. pi05-libero no longer loaded, and this policy loaded with newer packages than it was published with.
   • To take newer versions, move _OPENPI_COMMIT and _PYPI_AS_OF forward together.
   • The model and its weights are v2's.
   Use v3

   pi05-robocasa v3shell

   # start a policy from this version, then deploy it
   seq init pi05-robocasa@v3 my-policy
   seq deploy my-policy/policy.py
   
   # or move a deployment made from this template to it
   seq policy upgrade my-policy --to v3

7. v22026-10-08

   The policy has no batch wait of its own: an eval's acts are gathered until they stop coming, where a 5 ms wait cut a round into small padded batches. It declares cpu=1.25 and memory=12.

   Needs sequence-ai 0.31.0 or later.

   • @seq.batched(max_batch_size=16) declares no wait: the platform gathers an eval's acts until none comes for 20 ms, 250 ms at most. v1's 5 ms cut a round into small batches, each padded up to a compiled size.
   • cpu=1.25 and memory=12 (GiB), where v1 declared 1 and 11. This is pi05-libero's model with a third camera to decode, and pi05-libero serving one robot used 1.05 cores and 10.25 GiB (measured on the platform), so the price shown at deploy is the price billed.
   • Its files no longer carry the notes v1's carried for our own records.
   Use v2

   pi05-robocasa v2shell

   # start a policy from this version, then deploy it
   seq init pi05-robocasa@v2 my-policy
   seq deploy my-policy/policy.py
   
   # or move a deployment made from this template to it
   seq policy upgrade my-policy --to v2

8. v12026-10-07withdrawn

   The first version: the RoboCasa team's pi0.5 (pi05_pretrain_human300) as a policy, three cameras and a 16-D state in, RoboCasa's 12-D actions at 20 Hz out, built as their own eval server builds it.

   Withdrawn on 2026-10-08: its files carried notes written for our own records. v2 is the same policy without them, with no batch wait of its own and cpu=1.25, memory=12 declared.

   • seq deploy policy.py deploys it on an L4, or an A100 40 GB when no L4 is free, as one worker (max_gpus=1) with cpu=1 and memory=11. The weights are the official template weights pi05-robocasa v1: the RoboCasa team's checkpoint and norm stats, with openpi's PaliGemma tokenizer.
   • Through the adapter robocasa-openpi (in the robocasa template) it takes the left, wrist and right agent views at 224x224, the 16-D state and the instruction, and returns RoboCasa's 12-D actions at 20 Hz, 5 a call (replan_steps), as RoboCasa's openpi client runs them.
   • The model is pi0.5 with a 50-step action horizon, prompts of up to 200 tokens and the state as discrete tokens, wrapped in the RoboCasa team's transforms.
   • Its noise comes from the request's seed and the state it carries: new at every act, the same when an episode is replayed. --param policy.fresh_noise=true draws it unseeded.
   • Acts that reach a worker together run as one forward pass, up to 16; an eval's are gathered for up to 5 ms.
   • It scored 24 of 54 episodes (44.4%) on robocasa-cpu, 3 seeds a task, measured on the platform; RoboCasa365 reports 39.6% for this checkpoint.