AIRoA-0

AIRoA-0 (A-0) model weights: the pre-trained model, plus three post-trained checkpoints as examples of the post-training recipe. Weights only: no training state, data or inference server.

Post-trained folders contain EMA weights after 20k post-training steps.

Each folder contains:

Download

# pre-trained weights only (about 12 GB)
hf download airoa-org/AIRoA-0 --include "pretrained/*" --local-dir AIRoA-0

# one post-trained example
hf download airoa-org/AIRoA-0 --include "examples/orange_pyramid/*" --local-dir AIRoA-0

# everything (about 50 GB)
hf download airoa-org/AIRoA-0 --local-dir AIRoA-0

cd AIRoA-0/pretrained && sha256sum -c SHA256SUMS

Fine-tune on your own task (from pretrained/)

Use the AIRoA-0 post-training code, github.com/airoa-org/AIRoA-0. Its default configuration expects the pretrained weights at checkpoints/airoa-0_pretrained, so download pretrained/ there:

git clone https://github.com/airoa-org/AIRoA-0.git && cd AIRoA-0
python3.11 -m venv .venv && . .venv/bin/activate
python -m pip install -e '.[train,test]'

hf download airoa-org/AIRoA-0 --include "pretrained/*" --local-dir checkpoints/AIRoA-0
mv checkpoints/AIRoA-0/pretrained checkpoints/airoa-0_pretrained
cp configs/post_training.toml configs/local.toml

Edit configs/local.toml:

• Initial weights: init_params = "../checkpoints/airoa-0_pretrained" is the default; either this folder or its params/ works.
• Dataset: data.repo_id, the state and action keys and dimensions, and the camera mapping. Your data must be in LeRobot v3.0 format; convert LeRobot v2.1 datasets first with LeRobot's convert_dataset_v21_to_v30 (see the repository's data guide). The post-trained checkpoints here use an 11-dimensional state and a 20-dimensional action; the repository README shows the layout.
• Labels: labels.task_instruction, the stage texts and labels.pa_to_stage. These map each subtask label in your data to a stage; any number of stages (two or more) is supported.
• Hardware: training.batch_size and training.fsdp_devices for your GPUs.

Then run:

./run.sh inspect --config configs/local.toml                # check the dataset and one example
./run.sh norm    --config configs/local.toml                # compute normalization statistics
./run.sh train   --config configs/local.toml --run trial01  # post-train

• What is loaded: the pre-trained backbone, the action expert and the visual-budget gate. The task's stage head and the proprioceptive memory are created fresh.
• Default optimization: batch 64, 20k steps, learning rate 5e-6 after 500 warm-up steps, EMA 0.99. The post-trained checkpoints here used the same optimization settings.
• Requirements: Linux, an NVIDIA GPU with CUDA 12 and Python 3.11. The default uses 8 GPUs and needs at least 32 CPU cores for data loading.
• Data conventions: see the repository README and docs/data.md for units, coordinate frames and the action convention.
• Plain openpi: it can load the shared core weights, but not the visual-budget gate.

Load

With openpi, or the AIRoA-0 code (github.com/airoa-org/AIRoA-0), after downloading:

import jax.numpy as jnp
from openpi.models import model as _model

# jax.Array on the visible accelerators (GPU/TPU), replicated on each device
params = _model.restore_params("AIRoA-0/examples/orange_pyramid/params", dtype=jnp.bfloat16)
print(sorted(params))
# ['PaliGemma', 'action_in_proj', 'action_out_proj', 'proprio_memory_compressor', ..., 'stage_classifier', ...]

restore_params arguments:

• sharding=: pass your own jax.sharding.Sharding to shard the weights instead of replicating them, for example for FSDP.
• restore_type=np.ndarray: loads host-memory numpy arrays instead, for inspection without an accelerator.

With Orbax only:

import jax, jax.numpy as jnp, orbax.checkpoint as ocp

path = "/abs/path/to/AIRoA-0/examples/orange_pyramid/params"
mesh = jax.sharding.Mesh(jax.devices(), ("x",))
sharding = jax.sharding.NamedSharding(mesh, jax.sharding.PartitionSpec())  # replicated
with ocp.PyTreeCheckpointer() as ckptr:
    item = {"params": ckptr.metadata(path)["params"]}
    args = jax.tree.map(lambda _: ocp.ArrayRestoreArgs(sharding=sharding, dtype=jnp.bfloat16), item)
    params = ckptr.restore(path, ocp.args.PyTreeRestore(item=item, restore_args=args))["params"]

• Memory: 3.36 B parameters, about 6.7 GB per device in bfloat16 when replicated, or 13 GB in float32 (leave out dtype).
• Building the model: in the AIRoA-0 code, Pi0Config(**model_fields) with the model_fields from model_config.json (JSON lists converted to tuples) builds the matching architecture. Fields not listed keep their defaults.
• Extra modules: the post-trained checkpoints add a stage head (stage_classifier) and a proprioceptive memory (proprio_memory_*). They are implemented in the AIRoA-0 code, not in upstream openpi.

Origin

AIRoA-0 builds on the pi0.5 vision-language-action model and the openpi code of Physical Intelligence (openpi, Apache-2.0). Its vision-language backbone is Google's PaliGemma.

License

Copyright 2026 AI Robot Association (AIRoA).

The weights are a Model Derivative of Gemma and are distributed under the Gemma Terms of Use (LICENSE_GEMMA.txt); use is subject to the Gemma Prohibited Use Policy. The pi0.5 model and openpi are licensed by Physical Intelligence under the Apache License 2.0 (LICENSE). The AIRoA-0 code is Apache-2.0 (github.com/airoa-org/AIRoA-0). See NOTICE.

Use restrictions (Gemma Terms of Use, Section 3.2). You must not use these weights, or any Model Derivatives of them, for the restricted uses set forth in the Gemma Prohibited Use Policy, or in violation of applicable laws and regulations. If you redistribute them or a Model Derivative, you must include these use restrictions as an enforceable provision in your terms, notify recipients that they are subject to them, provide a copy of the Gemma Terms of Use, and include the NOTICE file.

Modifications. These weights have been modified by AI Robot Association (AIRoA) through further training (pre-training and post-training).

Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms.

Contact

Questions about AIRoA-0: ext-oss@airoa.org

Citation

@techreport{airoa0,
  title         = {{AIRoA-0}: Long-Horizon, Precise, Cross-Embodiment
                   Manipulation from Handheld Data},
  author        = {Yueh-Hua Wu and Kei Ota and Hanlong Li and
                   Hayata Yuasa and Jason Wang and Kengo Ikeuchi and
                   Kensuke Chiyoma and Makoto Sugiura and
                   Masafumi Takahashi and Masatoshi Tateno and
                   Naoaki Kanazawa and Nicola Scianca and
                   Petr Khrapchenkov and Satoshi Otsubo and
                   Takehiko Ohkawa and Takuya Okubo and
                   Tatsuya Matsushima and Yuki Noguchi and Yuma Shin and
                   Zixuan Zhong},
  institution   = {AIRoA},
  year          = {2026},
  month         = nov,
  eprint        = {2611.03815},
  archivePrefix = {arXiv}
}