MolmoAct-7B-D
Allen Institute for AI, USA · August 2025
Allen Institute for AI (Ai2)
- Parameters
- 8.1 B
- The allenai/MolmoAct-7B-D-0812 checkpoint reports 8,119,417,808 F32 parameters in its safetensors index (Hugging Face model...
- GPU memory
- 15 GB
- weights at bf16, computed. Fits a 24 GB card
- Inference latency
- not published
- per action step
- Weights
- Apache-2.0
- downloadable checkpoint
What it is
MolmoAct-7B-D is the first Action Reasoning Model (ARM) from Ai2, a class of policies that route perception through an explicit intermediate plan instead of mapping observations directly to control. It runs a three-stage pipeline: encode observations and instructions into depth-aware perception tokens, emit a mid-level spatial plan as an editable trajectory trace, then predict discrete low-level actions over 256 bins. The trajectory trace is the practical differentiator because an operator can edit it to steer behaviour, and the model reports top human-preference scores for open-ended instruction following and trajectory steering. It is fully open: weights, training code, the pretraining mixture, and the MolmoAct Dataset of 10,000 trajectories on a single-arm Franka across 93 manipulation tasks, all under Apache-2.0. Its practical weakness is speed, since Ai2 later measured the original MolmoAct at 6,700 ms per action on LIBERO with an H100, and it has been superseded by MolmoAct2 in May 2026.
Architecture
- Backbone
- Qwen2.5-7B language model with SigLIP2 so400m-patch14-384 vision encoder, initialized following Molmo's pre-training approach
- Action head
- Autoregressive discrete action tokens as the third stage of a three-stage pipeline (depth perception tokens, then editable trajectory traces as 2D integer coordinates bounded to [0, 256), then actions). 256 action bins, configurable during preprocessing. Actions are normalized 7-dimensional vectors: 3D position, 3D rotation, gripper state.
- Action chunk
- 8 steps per forward pass
- Parameters
- The allenai/MolmoAct-7B-D-0812 checkpoint reports 8,119,417,808 F32 parameters in its safetensors index (Hugging Face model API, checked 11.08.2026); the model card labels this 8B despite the 7B in the name. Weights are stored in F32 but the card documents bfloat16 inference casting.
- Pretraining data
- Pre-trained on the MolmoAct Pre-training Mixture, then mid-trained on the MolmoAct Dataset, plus a subset of Open X-Embodiment. The MolmoAct Dataset contains 10,000 high quality trajectories of a single-arm Franka robot performing 93 unique manipulation tasks in home and tabletop environments, formulated into 1M action reasoning samples plus 1M trajectory-conditioned action samples. Mid-training ran 50k gradient steps at batch size 128 on 128 H100 GPUs for roughly 2,304 GPU hours.
- Embodiments
- Franka Emika Panda single-arm (MolmoAct Dataset, real-world fine-tuning), Google Robot (SimplerEnv), Bimanual setup for real-world fine-tuning, Franka Panda in LIBERO simulation
What hardware it needs
This is the section most people came for, so it is worth being precise about which numbers are measured and which are arithmetic.
| Precision | Weights | Note |
|---|---|---|
| fp32 | 30 GB | Training master weights, rarely used for inference |
| bf16 or fp16 | 15 GB | The usual way these checkpoints are served |
| int8 | 7.6 GB | Quantised, expect some loss of precision on fine motions |
| int4 | 3.8 GB | Aggressive quantisation, verify success rate before trusting it |
Smallest real card that fits the bf16 weights plus a 40 percent runtime allowance: 24 GB. That is an estimate for inference, not for fine tuning. Full fine tuning also holds optimiser state and gradients, which typically costs several times the weights unless you use LoRA or a comparable adapter.
No inference VRAM figure is published. Training compute is documented instead: pre-training on 32 nodes times 8 GPUs at global batch size 512, mid-training on 16 nodes times 8 GPUs at global batch size 256, LoRA post-training on 8 nodes times 8 GPUs at global batch size 128. Mid-training used 128 H100 GPUs for about 2,304 GPU hours. Inference dependencies are pinned to vllm 0.8.5 and transformers 4.52.
The authors publish no memory or latency figure for this model. Everything above is computed from the parameter count.
Reported results
Grouped by what the evaluation actually asked. Values from different suites are not comparable with each other, so each one keeps its suite and split.
Simulation
Reproducible benchmark suites. Everyone runs the same episodes, so the numbers can be compared inside a suite.
- LIBERO Object95.4%
- LIBERO Average over 4 suites86.6%success ratePaper Section 5. Per split: Spatial 87.0, Object 95.4, Goal 87.6, Long 77.2. Includes a 6.3 percent gain over ThinkAct on long-horizon tasks. Independently reproduced in the MolmoAct2 paper Table 8 with identical values.source
- LIBERO Long77.2%success rateWeakest split. Well behind pi-0 at 85.2 percent, so the reasoning pipeline does not compensate on long-horizon tasks at this model generation.source
- SimplerEnv (Google Robot) Visual Matching, zero-shot70.5%success ratePaper Table 1, MolmoAct-7B-D-Pretrain checkpoint. Surpasses closed-source pi-0 and GR00T N1.5.source
Real world
No results in this category are published for this model.
Fine tuned tasks
No results in this category are published for this model.
On real hardware
Real-world fine-tuning gives an additional 10 percent task progression on a single-arm setup and an additional 22.7 percent on a bimanual setup over pi-0-FAST. The model also achieves an additional 23.3 percent over baselines on out-of-distribution generalization, and top human-preference scores for open-ended instruction following and trajectory steering.
Fine tuning it yourself
MolmoAct-7B-D-0812 is the checkpoint recommended for fine-tuning on custom datasets. Any dataset in LeRobot format works after preprocessing through the action reasoning pipeline, which generates depth perception tokens and visual reasoning traces. Action chunk size 8 and 256 action bins are set at preprocessing time. LoRA post-training is supported. The repository warns against --pin_memory because of OOM during loading.
Where it helps, where it does not
Strengths
- Fully open blueprint: weights, training code, pretraining mixture, the 10k-trajectory MolmoAct Dataset and the action reasoning dataset, all Apache-2.0
- The editable trajectory trace makes behaviour steerable and explainable at inference time, which no direct perception-to-control policy offers
- Zero-shot SimplerEnv Visual Matching of 70.5 percent beats closed-source pi-0 and GR00T N1.5
- Strong out-of-distribution generalization, an additional 23.3 percent over baselines
- Training on the MolmoAct Dataset yields an average 5.5 percent improvement over the base model, which quantifies the dataset's own contribution
Limits
- Very slow: Ai2 later measured 6,700 ms per action on LIBERO with a single H100, which rules out reactive control
- Superseded by MolmoAct2 (arXiv 2605.02881, May 2026), which reports 97.2 percent LIBERO average versus 86.6 percent and roughly 37 times faster inference
- LIBERO average of 86.6 percent is well behind current models; LIBERO-Long at 77.2 percent is the weak point
- Weights ship in F32, so checkpoints are large and bfloat16 casting is the user's responsibility
- No inference VRAM figure and no control frequency are published
- Model card states the model is intended for research and educational use
- The 7B in the name does not match the 8.12B parameters in the checkpoint index
Sources
Everything on this page was taken from these documents. Where they disagree with what you read here, they win.
- https://arxiv.org/abs/2508.07917
- https://arxiv.org/pdf/2508.07917v4
- https://huggingface.co/allenai/MolmoAct-7B-D-0812
- https://github.com/allenai/molmoact
- https://allenai.org/blog/molmoact
- https://allenai.org/blog/molmoact2
Entry last checked 2026-08-11.
Try a policy on a real arm
A physical SO-100 is online and free to drive in the browser, and five of the models in this arena can be fine tuned on a dataset you record with your own.