MolmoAct2: Action Reasoning Models for Real-world Deployment

MolmoAct2 is Ai2's open family of action reasoning models for robot control and real-world deployment. It builds on the Molmo2-ER embodied-reasoning vision-language backbone, adds robot state and action modeling, and connects the VLM to a flow-matching continuous action expert for closed-loop manipulation. The release includes base checkpoints for continued training, fine-tuned robot policies for evaluation and deployment, and the datasets used to build MolmoAct2 and Molmo2-ER.

Updates

• [2026/06/13] 🔥 We have released pre-training and post-training code and full experimental details for MolmoAct2, get started Here.
• [2026/06/10] 🔥 We have setup zero-shot evaluation for MolmoAct2 (DROID and Bimanual YAM) on Maniskill simulation, get started Here.
• [2026/05/28] 🔥 MolmoAct2 has been fully integrated into Huggingface, LeRobot official repo at MolmoAct2.
• [2026/05/19] 🔥 We've also released MolmoAct2-Cortex evaluation rollouts on YAM bimanual setups (useful for failure annotation and reward model training) at Policy Rollouts.
• [2026/05/17] 🔥 We have released FastAPI inference servers for MolmoAct2 using DROID and YAM setups at Inference Servers (implemented by Jie Wang).
• [2026/05/14] 🔥 We have released MolmoAct2 lerobot workflow for fine-tuning and inference. Check it out.
• [2025/05/06] 🔥 Detail implementation and setup for Franka, SO-100/101, and bimanual YAM have been released at Real-world Deployment.
• [2026/05/05] 🔥 MolmoAct2 has been released!

1. Models

Base Models

We provide base checkpoints at every training stage for continued MolmoAct2 training and robot fine-tuning. These are foundation checkpoints rather than one-size-fits-all deployment policies.

Finetuned Models

We also provide fine-tuned checkpoints for common robot platforms and benchmarks. These models are intended to run directly in their target setting, or to serve as a stronger starting point for closely related robots. As with any robot policy, performance depends on hardware, cameras, calibration, action conventions, and language/task distribution.

2. Datasets

Note that all of the robotics datasets for pre-training and post-training are in LeRobot v3.0 format, paired with extra language annotations.

3. LeRobot Integration

MolmoAct2 is integrated into LeRobot as a policy implementation, so users can train, evaluate, and deploy MolmoAct2 with standard LeRobot datasets and workflows. This repository includes the LeRobot integration as a Git submodule at lerobot/, pinned to the branch allenai/lerobot:molmoact2-policy.

For training, although all of our experiments start from the base checkpoint allenai/MolmoAct2, we recommend starting from the fine-tuned checkpoints listed in the Finetuned Models section above if your embodiment is similar to Bimanual YAM, DROID Franka, or SO-100/SO-101, as they can provide better initialization and downstream performance. For generic use, use the base checkpoint.

After cloning this repository, initialize the submodule from the repo root:

git submodule update --init --recursive
cd lerobot

For training, evaluation, and deployment instructions, see the MolmoAct2 LeRobot documentation at docs/source/molmoact2.mdx. To reproduce the original LIBERO benchmark results exactly with the v0.5.1 evaluation stack, use the pinned inference branch allenai/lerobot:molmoact2-hf-inference with instructions in MolmoAct2 README.

We also open-source the original MolmoAct2 experiment scripts under experiments/. These cover training and evaluation replication, depth annotation, Hugging Face checkpoint conversion, and fine-tuning on new LeRobot datasets. See experiments/README.md for setup and commands.

4. Real-world Deployment

[!WARNING] Disclaimer: Out-of-the-box deployment is intended for simple tasks within the training task distribution (e.g., Pick-and-Place, opening, closing and etc). Performance has only been empirically verified on the SO-100 and Franka DROID embodiments. Results on other embodiments and tasks are not guaranteed.

MolmoAct2 supports out-of-the-box deployment on three robot embodiments:

• SO-100
• Bimanual YAMs
• Franka DROID setup

SO-100/101 Setup

For the best performance, we recommend using an SO-100 with the standard wrist configuration and a third-person camera. Here is an open implementation by Irene Grace. Code

Bimanual YAM Setup

For the best performance, please build your Bimanual YAM setup following the reference design below:

All required components can be purchased using this Bimanual YAM parts list.

Implementation code for setting up, data collection, and inference for Bimanual YAM is here

Standardize evaluation implementation for zero-shot by Cortex AI here

Franka Setup

For the Franka setup, we recommend following the official DROID implementation for best results.

5. Inference Servers

This repository ships two FastAPI inference servers under examples/, one per fine-tuned checkpoint. Each server exposes the same /act wire protocol — json_numpy-encoded request/response — but with an embodiment-specific schema (camera count, state dimension, normalisation tag).

1. Install uv

curl -LsSf https://astral.sh/uv/install.sh | sh
exec $SHELL          # reload PATH so the `uv` binary is picked up
uv --version

2. Create the project environment

The pinned dependencies (CUDA-12.1 PyTorch wheels, transformers, fastapi, json-numpy, …) live in pyproject.toml. From the repo root:

uv sync                  # creates .venv/ and installs all deps
uv run python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"
# expected: True NVIDIA RTX A6000

uv reads .python-version (3.11) and downloads a matching interpreter if needed. Re-run uv sync after pulling new commits.

3. Download the checkpoint (~22 GB each)

export HF_HUB_ENABLE_HF_TRANSFER=1                       # fast parallel download
uv run hf download allenai/MolmoAct2-DROID               # for the DROID server
uv run hf download allenai/MolmoAct2-BimanualYAM         # for the YAM server

To put the cache on a different disk, set HF_HOME=/path/to/cache before the download (and when starting the server).

4. Start a server

# DROID (Franka)
uv run python examples/droid/host_server_droid.py --host 0.0.0.0 --port 8000 --dtype bfloat16

# Bimanual YAM
uv run python examples/yam/host_server_yam.py --host 0.0.0.0 --port 8202 --dtype bfloat16

Useful flags (both servers):

• --dtype bfloat16|float16|float32 — default bfloat16. The DROID model card uses float32 (~88 GB), which only fits on ~96 GB of free VRAM. The YAM model card reports float32 at ~26 GB (fits on a single A6000), bfloat16 under 16 GB. bfloat16 is the safe default for both.
• `-