Open Source Robotics

A curated collection of high-quality open source robotics projects, tools, and software to propel the robotics community forward.

MolmoBot

Ai2 manipulation policies trained only in simulation, run zero-shot on a DROID Franka

License

  • code (MolmoBot, MolmoBot-Pi0, MolmoBot-SPOC): Apache 2.0
  • MolmoBot checkpoints (incl. MolmoBot-DROID and the RB-Y1 policies): Apache 2.0
  • MolmoBot-Data: ODC Attribution 1.0

Split licensing. Code: Apache-2.0, per LICENSE, the same text in each of the MolmoBot, MolmoBot-Pi0 and MolmoBot-SPOC packages. MolmoBot checkpoints, including MolmoBot-DROID and the RB-Y1 policies: Apache-2.0, per their Hugging Face cards; they are fine-tuned from Molmo2-4B, also Apache-2.0, whose card notes it was trained on third-party datasets limited to academic and non-commercial research. MolmoBot-Pi0-DROID: the Gemma licence, because it builds on PaliGemma. MolmoBot-SPOC checkpoints: licence stated only as other, and the licence file their cards point to does not exist. MolmoBot-Data: ODC-BY 1.0; some scenes use Objaverse objects under non-commercial licences, and a commercial-safe episode list is provided. Ai2 asks that the models and data be used under its Responsible Use Guidelines. Checked 2026-11-08 against LICENSE and the Hugging Face cards.

Overview

MolmoBot is a family of robot manipulation policies from the Allen Institute for AI (Ai2), trained only on simulated data and run on real robots without any real-world data or fine-tuning. Its main checkpoint, MolmoBot-DROID, drives a Franka arm in the DROID configuration from a wrist camera, one external camera and a text instruction such as put the red mug in the black bowl. The training data, MolmoBot-Data, is 1.7 million expert trajectories generated in MuJoCo across more than 94,000 procedurally generated houses, with heavy randomization of objects, lighting and camera placement. Ai2 releases three policy types, nine checkpoints for the Franka and the Rainbow Robotics RB-Y1 mobile manipulator, the training and evaluation code, the dataset and the data generation engine. The paper is presented at CoRL 2026.

MolmoBot is a set of manipulation policies from Ai2, with the University of Washington, UCLA, TU Darmstadt and Princeton, built to test one claim: that a policy trained only in simulation can work on a real robot with no real-world data and no fine-tuning, a strict form of sim-to-real transfer. Its main checkpoint, MolmoBot-DROID, controls a Franka arm set up as in DROID, with a Robotiq 2F-85 gripper, a ZED Mini wrist camera and one ZED 2 camera that can stand anywhere around the table. Given a text instruction such as "put the red mug in the black bowl", it outputs absolute joint positions for the arm and gripper.

The data comes from MolmoBot-Engine, a procedural generator that is now part of the MolmoSpaces repository. It places objects from iTHOR and Objaverse in pre-built MolmoSpaces houses, renders them in MuJoCo, and has scripted experts sample grasps, plan each phase of the motion (motion planning) and start over when a grasp slips. Lighting, textures, friction, masses, the robot's starting pose and every camera's position are randomized (domain randomization). The result, MolmoBot-Data, holds 1.7 million trajectories and 5,704 hours of robot experience across more than 94,000 environments, 11,000 objects and 9,000 receptacles, for 8 task types on two robots: the Franka FR3 for tabletop pick-and-place and the Rainbow Robotics RB-Y1 mobile manipulator for picking and for opening drawers, cabinets and doors. Generating it took about 6,500 GPU-hours.

Three policy types are trained on it by imitation learning. MolmoBot itself is built on the Molmo2-4B vision-language model with a diffusion-transformer action head that reads every layer of the language model and predicts 16-step chunks of joint positions by flow matching; it can take up to 3 recent frames per camera. MolmoBot-Pi0 copies the π0 architecture through the openpi code and starts from PaliGemma, so it can be compared directly with Physical Intelligence's own models. MolmoBot-SPOC is a small transformer policy meant for edge devices and for later reinforcement learning in simulation. Nine checkpoints are on Hugging Face, for the DROID Franka and for door opening and multitask work on the RB-Y1.

On a DROID robot the policy runs as a server on a GPU PC, while the robot and gripper run under Polymetis; a setup guide covers the cameras, the configuration and the client script. A demo notebook builds a simulated scene, loads a checkpoint and rolls out an episode without any hardware, and the training commands that reproduce MolmoBot-DROID from the public data are in the repository.

In the paper each policy was run 120 times on real DROID robots: 4 rooms with 10 pick-and-place tasks each and 3 trials per task, on 3 robots at 2 institutions. MolmoBot succeeded in 79.2% of trials, against 39.2% for π0.5-DROID, trained on real demonstrations, and MolmoBot-Pi0 reached 46.7% with π0's architecture and only simulated data. Mobile work is less mature: on three real pull doors, the RB-Y1 opened the door in 2 of 9 trials. These are the authors' own results; the project page has recordings of the real DROID trials.

Why it matters

Open VLA policies such as π0.5 in openpi learn from more than 10,000 hours of real robot demonstrations, data that is not public and that outsiders cannot regenerate. MolmoBot replaces that with simulated data that anyone can download or generate again with the released engine, and in the authors' tests it beat π0.5 on the same DROID hardware without seeing a single real demonstration. For a lab with a DROID-style Franka, that means a policy to try without collecting any data, and a full recipe, from scene generation to training, for adding new tasks or robots. It is the counterpart to MolmoAct2, Ai2's action-reasoning VLA: MolmoAct2 ships foundation checkpoints meant to be fine-tuned for each robot on real demonstrations, such as DROID, while MolmoBot learns only from simulation and is meant to run as it is. The catch is its reach: the tasks are rigid pick-and-place and opening, and anything other than a DROID Franka or an RB-Y1 needs its own simulated data and training.

Problem it solves

Training a manipulation policy usually needs large amounts of real robot demonstrations, which are slow and costly to collect and mostly closed. MolmoBot shows that procedurally generated simulation data, randomized widely enough, can train policies that work on real robots zero-shot, and it releases the data, the generator and the training code so others can reproduce or extend the result.

Key takeaways

  • Manipulation policies trained only on simulated data, run on real robots with no real-world fine-tuning
  • MolmoBot-DROID runs on a DROID Franka with a wrist camera and one external camera placed anywhere
  • Trained on MolmoBot-Data: 1.7 million simulated expert trajectories across more than 94,000 houses
  • Three policy types: a Molmo2-based VLA, a π0 replica and a small transformer for edge devices
  • Code, most checkpoints and the data generation engine are open; the dataset is ODC-BY
  • 79.2% success on real pick-and-place against 39.2% for π0.5-DROID, in the authors' tests

Who it is for

  • Labs with a DROID-style Franka setup that want a pick-and-place policy without collecting data
  • Robot learning researchers studying sim-to-real transfer and synthetic training data
  • Teams building simulation data pipelines for new robots or tasks
  • Rainbow Robotics RB-Y1 owners working on mobile manipulation

Limitations

  • The released checkpoints run only on a DROID-style Franka (Robotiq 2F-85 gripper, ZED Mini wrist and ZED 2 external camera, Polymetis) or on a Rainbow Robotics RB-Y1; other robots need new simulated data and training
  • Tasks are limited to rigid pick, pick-and-place and opening articulated objects; the authors name insertion, deformable objects and fluids as out of reach for now
  • Mobile manipulation is early: the RB-Y1 opened a real pull door in 2 of 9 trials
  • MolmoBot-Pi0-DROID is under the Gemma licence, and the three MolmoBot-SPOC checkpoints state only other with no licence file, so not every checkpoint is Apache-2.0
  • MolmoBot-Data is about 10 TB and includes Objaverse objects under non-commercial licences; a list of commercial-safe episodes is provided
  • Training needs multi-GPU clusters: the README reports 8 to 64 H100 GPUs for MolmoBot-DROID and 32 for MolmoBot-Pi0-DROID, and the MolmoBot-DROID checkpoint is about 20 GB
  • All results are the authors' own, on their robots and their own simulation benchmarks

This website requires JavaScript to function properly. Please enable JavaScript to explore our collection of open source robotics projects.