Latest / Embodied AI 101 / MolmoBot: A Vision-Language Model for Zero-Shot Robot Manipulation
Transcript
- MolmoBot: A Vision-Language Model for Zero-Shot Robot Manipulation. Robotic manipulation – grasping, moving, and interacting with objects in the real world – has long been a frontier of AI research. Unlike language or vision systems, which can often be trained on vast static datasets, robots need to act in the world, and training good manipulation policies has traditionally required collecting expensive real-world data from physical robots. The standard approach has been to gather millions of teleoperated trajectories or human demonstrations on actual machines, then train models on that data (for example, Google’s RT-1 required over 130,000 real episodes collected by human operators, and the Open X-Embodiment project aggregated over a million trajectories from many institutions). While such scale has indeed led to impressive generalist manipulation models, it comes at great cost: setting up teleoperation rigs, teaching operators, and running all-day experiments on hardware is time-consuming, expensive, and hard to reproduce. MolmoBot takes a radically different path. Developed by researchers at the Allen Institute for AI, MolmoBot is a suite of robot manipulation policies trained entirely in simulation, with no real-world demonstrations in its training data. Instead of relying on months of human-run experiments, MolmoBot’s training data comes from procedurally generated simulated environments and scripted “expert” trajectories. By massively increasing the diversity of the virtual worlds – objects, scenes, camera angles, lighting, physics parameters – MolmoBot closes the sim-to-real gap, achieving zero-shot transfer to real robots. In recent experiments on real-world tabletop tasks, the best MolmoBot policy achieved a 79.2% success rate on seen-unseen pick-and-place tests, dramatically outpacing a state-of-the-art baseline (Physical Intelligence’s π₀.₅ model) which managed only 39.2% under the same conditions. These results suggest a new direction for robot learning: instead of grinding away to collect ever-more real footage, we can build richer synthetic worlds that capture the diversity of real environments. As Ranjay Krishna (Ai2’s Director of the PRIOR team) puts it, “we took the opposite bet: that the gap shrinks when you dramatically expand the diversity of simulated environments, objects, and camera conditions”. MolmoBot is the proof of concept: a fully open-stack manipulation model, trained purely in MuJoCo-based simulation with aggressive domain randomization, that works on real robots out of the box. In this article we’ll unpack MolmoBot’s ingredients – the MolmoSpaces ecosystem, the synthetic MolmoBot-Data, and the vision-language policy architectures – and walk through its surprising sim-to-real success. The Data Bottleneck in Robot Learning. Training a general-purpose robot vision-and-action model is costly because every training “day” often means running a physical robot. Large efforts like Open X-Embodiment and DROID collected hundreds of thousands to millions of trajectories through teleoperation to achieve modern capabilities. For example, the Open X-Embodiment dataset aggregated over 1 million episodes (hours) of real robot data from 22 different robot platforms, while Google’s RT-1 system ran 130,000 episodes over 17 months of human operation. Even smaller research labs struggle to approach those scales. Meanwhile, state-of-the-art robot manipulators like the Physical Intelligence π-models are built on teleoperated data too (π₀.₅ and π₁ rely on proprietary collections of human demonstrations). In short, the field is bottlenecked by gathering raw experience from hardware: you need robots, you need operators, and you need patience. This is in stark contrast to other AI domains. In vision and language, we simply download huge datasets from the internet. In language, transformer models are pretrained on billions of tokens scraped from Reddit and books. In vision, ImageNet and its successors have millions of images. We’ve seen the “AI scaling law” in those fields: more (quality) data plus more compute yields rapidly improving benchmarks. But robot action has lacked that big “foundational” corpus, because each datum is so expensive to acquire. That is exactly the motivation behind MolmoBot. Instead of treating simulation as just a warm-up phase or an auxiliary booster, the Ai2 team asked: Can we train entirely in simulation, and succeed zero-shot in reality? Conventional wisdom says no – simulators have all sorts of inaccuracies, and policies tend to overfit the quirks of their simulator. Yet if we could sufficiently broaden the simulated training distribution, perhaps a policy could learn robust skills that generalize. The Ai2 researchers decided to gamble everything on sim data: if the policy only ever sees synthetic scenes, can it still handle real ones?. As Ali Farhadi (Ai2 CEO) explains, moving to simulation as the sole data source makes robotics research more reproducible and accessible. If successful, the community only needs open simulators and assets (which anyone can run) instead of closed industrial robot farms hidden in a few companies. MolmoBot is the answer to that challenge: it’s an entire stack – simulated data, training code, and robot benchmarks – released publicly, to test how far sim-only training can go. In effect, MolmoBot reframes the bottleneck: now the hard part is building diverse virtual worlds, not sending human demonstrators to drive robots. MolmoSpaces: A Universe of Scenarios. Underpinning MolmoBot is MolmoSpaces, an open ecosystem of simulation assets and tools. MolmoSpaces integrates a vast variety of indoor scenes and objects, all physics-grounded and ready for robot use. In concrete terms, MolmoSpaces unifies over 230,000 indoor scene layouts, drawn from sources like the Ai2-THOR simulator and the Objaverse object library. It also curates more than 130,000 3D object models (tables, cups, books, lamps, etc.), and annotates them with over 42 million robot grasp poses. In one platform, this is a bigger train/testbed than most of our real-world collections. The scenes include houses with multiple rooms, kitchens, offices, and even hospitals or conference centers – anything the team could randomize. Crucially, MolmoSpaces emphasizes realistic physics and randomness. Early robot simulators (including some of our previous work) might employ “magic grasp” heuristics: for example, if a gripper touches an object it automatically snaps attached. MolmoSpaces instead uses actual physics engines (like MuJoCo) for contact and dynamics. The developers carefully tuned each object’s mass and friction by comparing to real-world measures (even using language models to guess densities, and human-in-the-loop tuning of joints). Thin colliders, convex decompositions, and primitive approximations were applied so contacts behave stably. In short, MolmoSpaces is as physically accurate as feasible. This high-fidelity simulation avoids obvious glue or “pick-up” hacks, making it harder for a policy to cheat. On top of the physics, MolmoSpaces layers massive domain randomization. Each time a scene is used for training, the engine can change the colors and textures of walls and objects, light positions and intensities, camera viewpoints, object sizes, even physical parameters like friction. Robot camera intrinsics and extrinsics are also randomized: the same task might be seen from slightly different heights, angles, or with lens noise. The team explicitly “aggressively” randomized everything it could think of. Rather than fine-tuning a fixed simulation to look photorealistic, they varied it broadly. The intuition is that this breadth shrinks the gap: a real camera is just another unseen random variant among thousands seen in training. MolmoSpaces is released fully open-source along with MolmoBot – including the raw 3D assets and data generation code. Importantly, it is designed to be multi-platform, compatible with MuJoCo, NVIDIA Isaac Sim/Lab, ManiSkill, etc. The idea is to turn simulation into shared research infrastructure. Anyone can download MolmoSpaces, spin up similar scenes, and generate their own robot data following the same protocols. In effect, Ai2 is saying: “we’re sharing the whole virtual world; now anyone can play.”. MolmoBot-Data: Millions of Synthetic Trajectories. Using MolmoSpaces, the team procedurally generated a massive synthetic dataset of robot experiences – MolmoBot-Data. This set consists of millions of “expert” manipulation trajectories in simulation. Each trajectory is a scripted or automatically-executed sequence of controls that accomplishes a task (for example, reach, grasp an object, and place it somewhere). To create these, the researchers used MuJoCo-based controllers or planners to solve each randomized task in simulation, then logged the resulting states, images, and actions. Crucially, no human teleoperation was involved; all demonstrations were generated automatically. The scale of MolmoBot-Data is impressive. Over 1,000 NVIDIA A100 GPU-days of compute were used to produce it, yielding roughly 1.8 million successful manipulation episodes. To put that in perspective, this is almost ten times the size of DROID, but entirely synthetic. The generation pipeline ran very efficiently: in aggregate the system logged over 130 hours of robot motion per wall-clock hour of training time, about four times faster than being limited by real robot speed. In other words, one hour of MolmoBot’s simulation run produces as much data as four hours of teleoperation would. Equally important is how varied that data is. MolmoBot-Data spans random scene layouts, moving or opening cabinets and doors, variable object sets, and countless lighting and viewpoint variations. One batch might train the robot to “open any drawer in a messy kitchen” where the drawers, the cabinet colors, and the camera pose are all different; the next batch might involve “place the red cup on a grid of random tile floor.” By procedurally shuffling object types (drawers, microwave doors, cupboards, etc.) and scene geometry, the dataset includes a wide swath of contact-rich tasks. The designers even randomly scaled object mass and joint friction within realistic bounds on each run. As the official description puts it, MolmoBot-Data was produced by “combining MuJoCo simulation, aggressive domain randomization, and procedural environment generation with variation in objects, placements, viewpoints, lighting, textures, and dynamics”. The only sensing modality used during training was standard RGB images (no depth or force), which makes the success all the more notable. Moreover, MolmoBot-Data deliberately pulls from large public collections to maximize breadth. All the objects — cups, plates, books, knobs, etc. — are drawn from Objaverse and the old AI2-THOR library, ensuring a huge variety of shapes and appearances. The scenes themselves range across many room types. In essence, the policy got to practice in “thousands of different houses.” This stands in contrast to many previous synthetic efforts that involved either a handful of rooms or purely randomized single-room factories. By scaling out to hundreds of scenes, MolmoBot-Data covers a rich distribution. Finally, note that MolmoBot-Data is also released open-source, alongside all the code to regenerate or update it. In line with the project’s philosophy, anyone can inspect the raw trajectories, review the randomization scripts, or generate new training examples. This extreme transparency (data, code, models all open) is intended to encourage replication and stress-testing by the community. The MolmoBot Models: Vision-Language Policies. With this synthetic training set in hand, the next ingredient is the policy architecture. MolmoBot actually refers to a suite of three related multi-modal controllers, all trained by behavior cloning on the same synthetic data. The centerpiece is the MolmoBot policy itself, a vision-language model (VLM) that processes images and instructions. Supporting it are two specialized variants: MolmoBot-SPOC (a lightweight “Tiny-Transformer”) and MolmoBot-Pi0 (an architecture matching the Physical Intelligence baseline). Using these three lets the authors trade off accuracy vs compute and make direct comparisons to existing baselines. MolmoBot (Vision-Language Policy). The main MolmoBot policy is fully multimodal. It is built on a newly developed backbone the authors call Molmo2, a transformer-based vision-language network. At each step, MolmoBot takes as input multiple recent RGB camera frames from the robot (a short history of video) and a textual task command. The language encoder ingests the instruction – which could be a simple keyword like “pick” or a more descriptive phrase – and the image encoder overlaps the visual history. These are fused in a transformer, and the network decodes an action command. In practical terms, the output is typically a continuous movement for the robot’s end-effector plus a grasp on/off signal. (For example, in the Franka arm, the network might output a 3D offset [dx, dy, dz] and a bit to open/close the gripper.). Importantly, MolmoBot is instruction-following. The task can be specified either via natural-language text or via point-command cues. In fact, during training the policies alternate between full-text instructions and simpler “point-based” commands. For instance, one trajectory might be annotated with “pick up the red block”, while another uses a placeholder signal meaning “pick” as the robot tries a point on the table. This flexibility is baked into the model: the same policy can handle a textual instruction like “open the blue cabinet” or a command like “close” if given a point selector. As the documentation notes, “You can specify tasks in natural language or through point-based commands (e.g., ‘pick’, ‘place’, and ‘close’).”. In essence, MolmoBot learns to tie language to action in the context of its visual observations. During training, MolmoBot consumed the MolmoBot-Data trajectories and learned by direct imitation (behavior cloning). Loss is simply how well the predicted control matched the recorded “expert” control at each timestep. There is no reinforcement learning loop or human reward – it’s straight supervised learning. Because the dataset is so large, and the model so powerful, MolmoBot can internalize a great deal of spatial reasoning. In practice, the Molmo2 backbone appears to be implemented similarly to the MolmoAct models (another Ai2 project on 3D reasoning), likely using large transformer layers that fuse CLIP-style vision features with language tokens. The upshot is that MolmoBot learns to parse the environment and instructions holistically: it sees an object-of-interest in the image, hears a “place” command, and immediately outputs the motion to accomplish it. MolmoBot-SPOC (Lightweight Variant). MolmoBot-SPOC is a secondary policy designed for efficiency. The name “SPOC” comes from a prior Ai2 navigation work (“Simulated Proxy for Observation and Control”), which used a smaller transformer for pure image-based tasks. Here, MolmoBot-SPOC is essentially an image-only variant (no language input) taking the same state observations. It offers competitive performance on many tasks but with far fewer parameters, useful if one has limited on-robot compute. In other words, SPOC is there if you can’t afford the full VLM: it’s a distilled “low-bandwidth” version that still imitates the training data, but without the instruction channel. (The system may still rely on point commands as inputs, since no language.). MolmoBot-Pi0 (Real-Data Baseline Variant). MolmoBot-Pi0 is another variant, architecturally matching the Pi₀ series by Physical Intelligence. Pi₀ (and its updated Pi₀.₅) are closed-source policies trained on real data, so to compare fairly the researchers replicated their network architecture. The Pi0-variant uses the “PaliGemma” backbone (the same core network PI used), with an added action head. Since MolmoBot-Pi0 is trained on the same synthetic data as MolmoBot, any performance difference highlights the effect of the architecture (and loss of language capability) rather than the data source. It turns out the VLM MolmoBot network outperforms the Pi0 architecture when both are trained on simulation. Intentionally including this comparison means the authors could do a controlled “apples-to-apples” study: how much do you lose by using synthetic data alone, if the network is constant. Training Details. All three policies – MolmoBot, MolmoBot-SPOC, and MolmoBot-Pi0 – were trained via straightforward imitation on the MolmoBot-Data. Notably, no real images were ever used in training. The entire dataset of 1.8M synthetic episodes (plus any held-out sim test data) was fed into each model with behavior cloning loss. This contrasts with many hybrid approaches that pretrain in sim then fine-tune on a little real data. MolmoBot skipped that final step entirely. The only small concession was evaluation: to test robustness in sim, the team also applied evaluation-time perturbations (like adding extra noise, using a different physics renderer, etc.) to ensure models weren’t simply overfitting one renderer. But when switching to the real test robots, they still did no additional training on any real robot data. It’s pure zero-shot sim-to-real. Because all policies share the same dataset, any comparison is controlled: differences in success will come from model power rather than dataset bias. In practice, MolmoBot (the VLM) turned out to have the highest raw success across tasks, followed by SPOC, then the Pi0 replica. The Pi0 replica essentially replicated known real-world performance when trained on real data, but here it serves as the synthetic-data baseline for comparison. From Simulation to Reality: Zero-Shot Experiments. With the models trained, the researchers set up extensive real-world tests. The targets were exactly those kinds of tasks MolmoBot had practiced in sim: pick-and-place on a table, opening drawers, cabinets, microwaves, and pulling or pushing doors. Two physical robots were used: the Franka Emika FR3 (a 7-DOF tabletop arm) for the pick-and-place tasks, and the Rainbow RB-Y1 (a mobile base with a 6-DOF arm and a gripper) for the articulated-object tasks and door openings. These are standard research platforms; FR3 looks like a Panda arm, and RB-Y1 has a sleek mobile manipulator configuration. Critically, the test objects and environments were unseen during training. The test suite included novel chairs and cups or tools that had not appeared in the synthetic set. Even the rooms were different – for example, the boardroom scene used for door tests had never been part of MolmoBot-Data. This ensured a pure generalization setting. The experiments also varied lighting and camera setups from run to run (for example, moving the robot’s camera to a different height or orientation) to check visual robustness. According to the report, the evaluation protocol matched prior real-robot benchmarks as closely as possible, so that “the same setup” could be used for direct comparison with other methods. On each task, success was defined in the usual way. For pick-and-place, the robot had to grasp a target object and move it into a designated target region (a small area or container) without dropping it. For drawer/cabinet tasks, success meant the latch passed some threshold (fully open beyond a certain angle). These criteria were measured automatically (e.g. via sensors or manual checks). Importantly, no manual resets or human interventions were allowed during an episode – it had to work from scratch. Results: Beating the State of the Art. The headline results are striking: MolmoBot’s policies achieved robust zero-shot transfer, often outperforming much more data-hungry baselines. Here are the key findings:. Zero-Shot Success: Without any real-world fine-tuning, MolmoBot successfully performed all the target tasks on both robots. Even though its training never saw a real object, the VLM policy could pick up and move new real cups, open real drawers, and even swing real doors – all in one shot. Pick-and-Place Benchmark: In the standard tabletop grasping benchmarks on the Franka FR3, MolmoBot’s primary model scored 79.2% success averaged over all trials. This is compared to only 39.2% for the π₀.₅ baseline model (a state-of-the-art policy that was trained on hundreds of thousands of real demonstrations). In other words, MolmoBot nearly doubled the success rate of the prior best model, despite not seeing any real images during training. That margin is massive. To be concrete, if out of 100 shift-agnostic pick tasks the old model got roughly 39 right, MolmoBot gets roughly 79. Other Tasks: On articulated-object tasks and door-opening with the RB-Y1 robot, MolmoBot policies again performed well. For example, policies successfully reached in, grasped, and pulled real fridge and cabinet doors open fully (sometimes handling both the pull and rotational motion). Tray of drawers and microwaves were opened and closed correctly, in many assorted random kitchen setups. While the paper does not quote a single aggregate number for all these tasks, the qualitative verdict is clear: MolmoBot’s performance was competitive with or better than prior methods that had real training data. Notably, in these mobile-manipulation scenarios MolmoBot did not use any vision-language instructions beyond its core “open” or “push” commands; yet it still succeeded. Comparison to Pi0 and Pi0.5: One of the benchmarks was a direct apples-to-apples match against the Pi-series vision (π₀.₅) model under the same protocol. That model – albeit trained on real data – achieved only about 40% on pick-and-place, whereas MolmoBot’s synthetic-only model got 79%. (The Pi0-architecture variant of MolmoBot, trained on the same synthetic data, did worse, showing that the multi-modal design really helped.) Thus, even comparing to state-of-art real-data policy, the simulation-trained MolmoBot was far ahead in these tests. Robustness to Shift: MolmoBot also proved surprisingly robust to perturbations not seen during training. For instance, in evaluation they introduced extra lighting changes or moved the table relative to the camera – conditions never in training. The policy still adapted. This suggests the massive variety in MolmoBot-Data paid off: the zero-shot policy had essentially “seen” a huge spectrum of visuals, so a new lighting condition was just another random draw. In contrast, a policy trained on fixed real images might have failed in a differently lit lab. Overall, the takeaway is that a large, diverse synthetic dataset + a powerful VLM policy can match or beat the previous best manipulation models, all without collecting a single real trajectory. As the authors note, this “suggests that synthetic training with sufficient scale and diversity can approach or match methods that depend on expensive data collection”. In practical terms, MolmoBot achieved near-state-of-the-art pick-place performance zero-shot, which is a milestone: it is the first time (to our knowledge) that a vision-based sim-trained policy so visibly outperforms a curated real-data policy on the real hardware. Interpreting the Success. Why does MolmoBot work so well? Clearly, it is not magic. The secret sauce seems to be scale and variety. By exposing the model to millions of scenes, objects, camera angles, and physics variations, the training distribution literally encompasses much of the manifold that real scenarios occupy. The hope (and what happened) is that instead of overfitting a single simulator model, the network learns the invariant structure of manipulation: what a door looks like, how the geometry of a drawer’s hinge moves, how to execute a grasp on a block. It learns affordances (a “mug” is graspable by the handle, a “button” is pressable) that transfer. The choice of a vision-language architecture also helps. Humans provide instructions in language naturally, and tying that directly into the policy likely improved generalization. The Molmo2 transformer backbone can use the language token to focus attention on relevant objects. In effect, it carries part of the task specification in a clean semantic form, rather than having to infer the goal from rewards (as an RL agent would have to). The experiments suggest that this multi-modal reasoning (image plus text) yields a more robust policy than vision alone. There is also a methodological simplicity at play: by using pure imitation learning in sim, the training never encountered any real-world noise. Some alternative approaches try domain adaptation or RGB-depth fusion, etc., which often require careful tuning at deployment. MolmoBot’s direct approach relies entirely on upstream diversity. If you randomize enough, a real world is just another case of that randomness. That hypothesis – that “if the simulated training set is rich enough, the sim2real gap shrinks” – was confirmed by MolmoBot’s results. This is in line with similar observations in other works (e.g. SPOC for navigation), but MolmoBot pushes it further into complex 3D manipulation. On the other hand, MolmoBot’s success does depend heavily on the choice of tasks and the simulator’s fidelity. All the tasks were pre-defined categories (pick-place, open-door, handle gravity etc.) with automated controllers available in sim. The model may not handle a brand-new task out of left field (like peg insertion or tool use) without retraining. And while the physics were careful, extremely delicate tasks (like pushing a soft object) might still reveal a sim-to-real gap. Furthermore, training such a model is not trivial: generating 1.8M expert episodes required over 100 GPU-days of simulation. This is far cheaper and more open than building a million real episodes, but it still takes serious compute. Nevertheless, these caveats aside, MolmoBot marks a practical proof-of-concept. The fact that it outperforms a leading real-data model on key benchmarks is particularly instructive. It tells us that the quality of data (diverse simulation) can trump the quantity/hardness of traditional data (monolithic real demonstrations). In other words, we might not need more real tractors in factories; we might just need better virtual ones. Implications and Future Directions. The success of MolmoBot has several important implications for embodied AI research:. Democratization of Robot Learning: Since MolmoBot requires only open simulators and assets, any lab can start training on it. You don’t need a fleet of robots or a 13-person teleoperation team to contribute new results. This levels the playing field – academic groups without big robotics infrastructure can potentially reach competitive performance by running MolmoSpaces at scale on compute clusters. As Ali Farhadi stated, “We want to build open models… [make] progress not depend on closed data or isolated systems. It requires shared infrastructure that researchers everywhere can build on”. MolmoBot embodies that ideal. Shifting the Bottleneck: Instead of data collection being the limiting factor, now the challenge is designing better simulators and scenarios. The team explicitly says the new bottleneck is crafting high-quality virtual worlds. This is easier to parallelize (cloud/supercomputer generation) and more reproducible than calibrating robots. Community effort might go into building even more varied scenes (outdoor, messy homes, multi-level buildings) or more dynamic scenarios (walking people, fluids). The modular design of MolmoSpaces suggests the community could plug in new assets or tasks and retrain. Instruction-Following Robots: MolmoBot illustrates the power of instruction-conditioned policies. By including language as part of learning, the same model can handle a family of tasks (pick/place/close) with a single network. This is a glimpse of potentially saving on needing separate controllers for every skill. It also aligns with the trend of “language as interface” in robotics. Future systems might combine MolmoBot with large LLMs or more complex dialog. Right now the language is simple, but it’s a start. Bridging to RL and Simulation Fidelity: MolmoBot used imitation learning only. A natural next step is to incorporate reinforcement learning in sim – train a policy with RL on top of the BC initialization or do self-improving loops. That could refine behaviors beyond the scripted expert, possibly handling edge cases. Additionally, further improving MolmoSpaces’ physics (e.g. deformable objects, wheels for the mobile base, contact-rich grasps) could bring even more tasks on board. One could imagine MolmoSpaces++ covering outdoor terrains, or even fluid dynamics for pouring tasks. Continuous Evaluation and Contributors: Interestingly, MolmoSpaces includes a public leaderboard and benchmark suites. This means outside testers can evaluate their own models (or even other policies) on the same held-out MolmoBot tasks. A positive feedback loop might develop: researchers alter data, architectures, or training and see gains on the shared benchmark. The open nature of MolmoBot’s release (“download the models… generate your own synthetic training data… we’re eager to see where it breaks”), as the authors invite, suggests it’s an ongoing project. The hope is that by crowdsourcing exploration (everyone trying to break MolmoBot), we’ll learn the remaining gaps of sim-to-real. Of course, reality is messy. MolmoBot did not attempt, say, cloth manipulation, deformable object handling, or slippery surfaces. Those remain hard. Also, the policy does not explicitly reason about long-horizon planning – if a task required rearranging multiple objects in sequence, it might struggle. MolmoBot picks up an object, somewhat like following a recipe, but it doesn’t solve multi-step puzzles yet. Nevertheless, the approach is promising because all these new capabilities could in principle be added by data generation. For instance, to handle soft objects, one could simulate cloth or rubber objects in MolmoSpaces and include them during training (once the physics is adequate). In the broader field, MolmoBot aligns with a growing belief in “foundation models” for robotics. Just as GPT-style LLMs have become catch-all solution engines for language, MolmoBot hints at an analogous robot foundation model: a large, pretrained policy that can be fine-tuned or queried for many tasks. Indeed, the authors released MolmoAct a year earlier – a 7B-parameter model for abstract action reasoning in space – and now MolmoBot could be seen as MolmoAct’s sibling for embodied action. As such, one can foresee future research fine-tuning MolmoBot on small real datasets (e.g. a robotics lab could tele-operate 100 examples and quickly adapt the model), or merging it with world models to plan ahead. Conclusion. MolmoBot demonstrates something that was until now largely speculative: a robot policy trained only in synthetic worlds, yet effective in the messy real world. Achieving a 79.2% success rate on real pick-and-place tasks from zero-shot sim training is a remarkable engineering milestone. It shows that with enough scale – 230K scenes, 130K objects, millions of trajectories – the sim-to-real gap can be overcome without traditional fine-tuning tricks. This reorients the field’s intuition: diversity and scale in simulation can substitute for hard-earned real data. For the robotics community, MolmoBot is both a challenge and an opportunity. It challenges skepticism about simulation’s limits, but it also offers an open toolkit and dataset for others to explore. If simulation infrastructure continues to improve (emerging physics engines, better sensors in sim, more environments), we might increasingly see “foundation models” like MolmoBot trained in repurposable ways. In the short term, we expect other teams will take MolmoBot models and test them on even more tasks – perhaps manipulation in cluttered kitchens, or assembly tasks – to see how well this sim-only approach scales. In the end, MolmoBot shifts the conversation: we should no longer ask “Does simulation work?” but rather “How far can we push simulated training?”. The early answer is: very far. As Farhadi says, roboticists can now “focus on designing richer simulated environments” because “progress no longer depends on proprietary datasets”. By moving all data generation into the virtual domain and making it open to everyone, MolmoBot and MolmoSpaces set a new course for embodied AI. The future of robot learning, it seems, will be built in code – even before being built in hardware. References (for context): The key facts above are drawn from the Ai2 MolmoBot and MolmoSpaces technical reports and blog releases. For example, Ai2’s blog notes “MolmoBot is a fully open manipulation model suite trained entirely on synthetic data”, and the detailed success rates are reported in press coverage of the MolmoBot release. We cite these sources to ground the claims on model performance and data volumes. (See link footnotes for exact lines.).