Latest / Embodied AI 101 / MolmoAct2-LIBERO: An Open Vision-Language-Action Model for Robotics
Transcript
- MolmoAct2-LIBERO: An Open Vision-Language-Action Model for Robotics. Robotics is undergoing a revolution driven by large vision-language models that can perceive scenes, understand instructions, and generate robot controls in one integrated framework. MolmoAct2 is a cutting-edge example of such a Vision-Language-Action (VLA) model from the Allen Institute for AI (Ai2). Building on the original MolmoAct model, MolmoAct2 is a 5B-parameter “action reasoning” model pretrained on massive data and fine-tuned for real-world robot control. In particular, the MolmoAct2-LIBERO variant is a version of MolmoAct2 that has been fine-tuned on the LIBERO benchmark tasks – a suite of manipulation challenges requiring a robot to follow natural-language instructions in a realistic household environment. This checkpoint achieves a remarkable 98.25% average success rate on the LIBERO tasks, setting a new bar for open VLA models. In this article we dive deep into MolmoAct2 and the LIBERO fine-tuning: what the model is, how it works, what makes it special, and why its release is significant. We will explain the model’s architecture (the Molmo2-ER backbone, the continuous-action “flow” expert, and the action tokenizer), the data used (including new datasets like BimanualYAM and the LIBERO task data), and the empirical results. We’ll also place MolmoAct2 in context: how it compares to prior work, why an open model matters, and what researchers can do with it. Throughout, we draw on the AllenAI blog, the ArXiv paper, and the official HuggingFace model card for MolmoAct2-LIBERO. Vision-Language-Action Models and the Need for Openness. Traditionally, robot control has been domain-specific: researchers would train one policy for each task in each environment (e.g., pick-and-place, drawer opening, cleaning, etc.). But recent progress in AI suggests the promise of generalist VLA models that can ingest visual input and language instructions and output appropriate actions for a range of tasks and robots. The dream of a general VLA policy – one model to rule them all – is inspired by the success of large vision-and-language models in image captioning, VQA, or text-based reasoning. If a robot could simply be told “load the dishwasher” or “sort the blocks by color” and execute, that would be a major step toward more capable, flexible robotics. However, up to now few VLA systems have met all the requirements for real-world deployment. Many high-performing approaches are closed-source (e.g., some proprietary industry models) or tied to specialized hardware. Open models have lagged behind in capability. Some recent systems inject heavy reasoning modules or use expensive hardware, which raises latency or cost issues. Even the best open-source VLA models have struggled to reach near-perfect success rates on manipulation benchmarks, limiting their reliability. The MolmoAct line of research explicitly addresses these gaps. MolmoAct models are “Action Reasoning Models” that integrate a language-and-vision backbone with a continuous control component in a trainable way. Critically, MolmoAct and MolmoAct2 are fully open: the model weights, code, and data releases (including new datasets of robot trajectories) are all provided under open licenses. This ensures that researchers can reproduce the results, fine-tune the model on new tasks, and even run it on commodity robots. Ai2’s emphasis on “completely open” robotics is a core theme: as the blog writes, MolmoAct2 is not just a high-performing model, but a foundation model for robotics that “outperforms capable proprietary robotics models on industry benchmarks” and can “run up to 37× faster” than its predecessor, all while giving researchers access to every piece of it. MolmoAct2 thus epitomizes the new wave of VLA for robotics: it combines a powerful vision-language backbone, novel ways to handle continuous action generation, and scale, while remaining open and efficient. The LIBERO-fine-tuned version is a concrete showcase of its capabilities. LIBERO (a benchmark introduced in 2023 for lifelong robot learning) contains a variety of shelf/plate stacking and object arrangement tasks specified by language, and it was designed to test a model’s ability to keep learning new tasks over time. Fine-tuning MolmoAct2 on the LIBERO tasks has produced a VLA policy that achieves 98.25% average success across the benchmark suites. This performance exceeds not only prior open models but also beats many closed baselines, which is a testament to the model’s robustness. In summary, MolmoAct2-LIBERO is significant because it demonstrates that an open-source VLA model can achieve nearly perfect performance on complex language-conditioned manipulation tasks. It bridges between the embodied robotics community and the large-model community by providing a complete, state-of-the-art pipeline for embodied control. The MolmoAct2 Architecture. At its core, MolmoAct2 is a transformer-based model that takes in visual observations, a natural-language instruction, and the current robot state, and produces action trajectories for the robot joints. In practice, it is implemented using a vision-language model (VLM) backbone with custom components to generate continuous control. The backbone, called Molmo2-ER, is specialized for embodied spatial reasoning. The full architecture can be summarized as:. Inputs: Multi-view RGB images (an overhead “agent view” and an in-hand wrist view in LIBERO, for example), plus the robot’s proprioceptive state (joint angles, velocities, etc.), along with a task instruction in language. Vision-Language Backbone (Molmo2-ER): A transformer model pre-trained on large-scale multi-modal data, including images, video, and language, with an emphasis on spatial reasoning tasks. Action Output Path: Two parallel outputs are produced: (1) a sequence of discrete “action tokens” via a tokenizer, and (2) a continuous action trajectory via a flow-based expert. During training both outputs are supervised; at inference usually the continuous output is used. Flow-Matching Action Expert: A neural network that generates a continuous control trajectory by denoising latent “flow” variables, where this expert is conditioned on the high-level features of the VLM via per-layer key-value (KV) connections. This lets the control expert see intermediate representations, improving grounding of the action in the scene geometry. OpenFAST Action Tokenizer: A separate Transformer tokenizer that maps continuous trajectories into discrete tokens. The MolmoAct2-FAST-Tokenizer was trained on open datasets to mimic the Pi-FAST strategy, making MolmoAct2’s entire pipeline fully open. (Optional) Depth Reasoning (“MolmoAct2-Think”): A mechanism to predict a coarse depth map discretized on a grid and update it only where the scene changes. This adaptive depth reasoning provides geometrical awareness with much less computation for static parts of the scene. We’ll unpack each of these components. Molmo2-ER: An Embodied Vision-Language Backbone. MolmoAct2’s backbone model, Molmo2-ER (Molmo2 Embodied and Reasoning), is itself a substantial engineering effort. It is a 3.3-million-sample pretrain of a vision-language model, akin to a visual LLM. The backbone is trained with a “specialize-then-rehearse” schedule on a huge diversity of data (synthetic scenes, simulators, web images, and real robot videos) with a focus on spatial understanding. This extensive training makes Molmo2-ER excel at the kinds of 3D reasoning tasks robots need. In fact, on 13 standard embodied reasoning benchmarks, Molmo2-ER achieves an average score of 63.8% – a full 17 points higher than GPT-5 and Gemini Robotics ER-1.5 (two of the latest closed commercial models) on those tasks. To the user, Molmo2-ER functions as an image-text-to-text model: it takes the stacked camera views as images and the textual instruction, and produces multimodal encoder representations. Unlike typical models that only condition an action prediction on the final “CLS” token, MolmoAct2 connects its continuous action expert to every layer of the VLM via a per-layer key-value cache. In other words, when the continuous control network computes an action at each timestep, it cross-attends to all the hierarchical visual-linguistic features—not just the final output’s hidden state. This per-layer conditioning is key to better grounding the actions in detailed geometry and semantics of the scene. Continuous Actions via Flow Matching. Robot control is fundamentally continuous. MolmoAct2 follows a flow-matching approach to produce smooth trajectories. Flow matching is a recent generative modeling technique where the network learns to transform random noise into structured trajectories by a denoising process. In MolmoAct2, this flow-based controller (the action expert) is “grafted” onto the vision-language model. Specifically, the network generates continuous 7D action vectors (for joint velocities and gripper commands) through a learned mapping that the authors term an action expert. During training, random trajectories from the demonstrations are perturbed with noise, and the action expert is trained to denoise them (this is the flow objective) while also occasionally predicting discrete tokens. The effect of the flow-matching expert is to allow MolmoAct2 to output fine-grained continuous motions at run-time. In experiments, continuous inference is the default mode, since it yields the best performance on actual robot control. (MolmoAct2 can also be queried in a “discrete token” mode if one provides a tokenizer, but that is mainly for parity testing or diagnostic purposes. The continuous mode uses the flow expert by default.) The innovation is that this continuous component is fully integrated into the transformer architecture and trained end-to-end. Through the per-layer KV connections described above, the action expert sees a rich contextual representation of the current scene, enabling it to generate actions that respect object shapes, spatial relations, and task goals. In sum, MolmoAct2 handles the continuous action problem by jointly learning a token-based language model of robot behavior and a continuous trajectory generator. This dual approach leverages the strengths of language-model-style training (handling heterogeneity of tasks and sequence modeling) with smooth control outputs suitable for real hardware. OpenFAST: Discrete Action Tokenizer. Alongside continuous flow, MolmoAct2 also uses discrete “action tokens” during training. This is implemented by an action tokenizer based on the FAST algorithm. AllenAI released an “OpenFAST” version of the tokenizer called MolmoAct2-FAST-Tokenizer. The idea is to quantize real trajectories into a vocabulary of tokens, like a language. This enables the model to be trained with standard language-model objectives on any action sequence data (similar to how one might train on image captions or code sequences). Crucially, the MolmoAct2 team deliberately trained their own open-action tokenizer. According to AllenAI staff, this was done “to make the whole model fully end-to-end open-source, so we trained our own action tokenizer entirely on open-source datasets”. The architecture and pipeline mirror Pi-FAST (a previous action tokenizer), but trained on public robotic datasets. By releasing this tokenizer on HuggingFace, they allow anyone to discretize actions in the same way. In practice, MolmoAct2 uses this tokenizer during co-training: when a demonstration trajectory is processed, the model is tasked with both generating the discrete tokens and/or the continuous trajectory. During inference, continuous mode is preferred, but discrete mode can still be run by supplying the tokenizer, e.g. to get a human-interpretable token plan. The presence of discrete tokens mainly serves training and research purposes; the real-world execution relies on the continuous flow output. Thus, MolmoAct2 unifies an action-token model and a continuous model. In everyday use one calls the model to produce continuous actions given the current state, but the underlying training has also shaped the model’s internal representations using the tokenization. This two-pronged strategy proved important for training efficiency and flexibility, according to the authors. Adaptive Depth Reasoning (MolmoAct2-Think). A novel feature of MolmoAct2 is its optional adaptive depth reasoning pipeline, nicknamed MolmoAct2-Think. This is an architectural tweak to reduce inference cost and improve scene understanding. The idea is to discretize the 3D space in front of the robot into a coarse grid (e.g., $10\times 10$ spatial bins). At each timestep, MolmoAct2-Think predicts a per-cell “depth code” that roughly encodes which parts of the scene are closer or farther away. However, scenes in manipulation tasks often have large static regions (like walls or tabletops) and only a few moving parts. So MolmoAct2-Think only recomputes the depth codes in grid cells where it sees new visual changes since the last step. In effect, MolmoAct2-Think reuses most of the old geometrical map and only updates the regions that matter (for example, if the robot’s gripper moved or an object shifted, re-predict depth in that region). This adaptive strategy dramatically cuts down the tokens that need to be processed by the model, keeping the geometric grounding up-to-date at low overhead. The result is a model that can “reason more deeply in 3D” without a big drop in frame rate. In experiments, enabling MolmoAct2-Think gave a further modest success boost: for instance on LIBERO tasks, the Think variant scored 98.1% vs 97.2% for the base model. More importantly, it cut inference time significantly (MolmoAct2 with CUDA optimizations reaches ~56 Hz throughput in simulation, which is fast enough for responsive control). MolmoAct2-Think is not used in the base LIBERO model checkpoint, but a variant called was released for comparison. In summary, MolmoAct2 has been carefully engineered to balance reasoning (depth-aware, keypoint reasoning) with efficiency, so it can be deployed on realistic robot hardware while still being interpretable. Putting It All Together. To sum up the model architecture: MolmoAct2-LIBERO is built on a Molmo2-ER vision-language transformer. Given images + text + state at time $t$, that backbone processes everything into latent features. Those features feed two heads: (a) a discrete output head that emits token probabilities (for which one can use the OpenFAST tokenizer to decode into a sequence of action steps), and (b) a continuous “flow” head that stochastically generates the actual joint trajectories step by step. During training both outputs are learned jointly (with flow-matching and token-loss terms), but at run-time one typically uses the continuous output (the in the LeRobot interface). The model’s parameters are fully differentiable, so it can be fine-tuned end-to-end on new data (as indeed was done for LIBERO, described next). Politely-narrated, one might say: MolmoAct2 treats action generation like language generation. It uses the same attention, memory, and textual understanding mechanisms that make LLMs successful, but with an extra network grafted on to ensure the outputs are valid robot motions. This elegant unity allows it to generalize across a variety of tasks that share visual semantics and structure. Fine-Tuning on LIBERO: Data and Training. The LIBERO benchmark (Lifelong Benchmark for Robotics) is a suite of position-based manipulation tasks introduced in mid-2023. It simulates a Franka Panda arm that can pick up objects and move them around, with four categories of tasks: Spatial (place items in left/right bowls), Object (put objects in bins), Goal (cover objects with lids, etc.), and Long (longer multi-step instructions). Each episode comes with a language instruction, multi-view camera images (one from the robot’s front and one wrist-mounted), and a trajectory of actions to train on. What makes LIBERO challenging is the lifelong aspect: there are many distinct tasks and the model must not forget old tasks as it learns new ones. For MolmoAct2, the team prepared a merged LIBERO dataset. In the official HuggingFace model card, they say: “This checkpoint is fine-tuned on the full LIBERO training mixture, combining Spatial, Object, Goal, and Long suites”. In total this amounts to roughly 1,693 episodes and 273,000+ frames of labeled robot demonstrations (as noted in the release announcement). These demonstrations span the varied tasks that LIBERO contains – for example, putting objects into specific receptacles, arranging colored items in sequences, folding towels, wiping surfaces, and so on. The training is done in simulation (MuJoCo) using the LeRobot framework. Concretely, MolmoAct2-LIBERO was obtained by taking a pretrained MolmoAct2 model (base checkpoint) and further training it for 10,000 steps on the LIBERO data, using 8 NVIDIA H100 GPUs with batch size 32. The training objective includes both the flow-matching loss and the discrete-token loss. During fine-tuning, the model sees each frame’s images, state, and the task language, and is trained to predict the next chunk of actions (10 steps per chunk by default). The LeRobot toolkit handles the data loading and chunking so that MolmoAct2 sees sequences of states and computes gradients accordingly. The HuggingFace model card notes that the MolmoAct2-LIBERO checkpoint includes not only the weights but also the entire policy configuration, preprocessing and postprocessing code, and normalization stats. This means one can instantiate and directly run it on LIBERO or similar data. Indeed, Ai2 provides example code for loading the model, preparing a frame (images + state + instruction as tensors), and calling to get the robot action. In short, fine-tuning MolmoAct2 on LIBERO effectively adapts the generalist model to the specific fine-grained manipulation tasks in that suite. Because MolmoAct2 was already powerful from pretraining, it only needs a single low learning-rate pass (10k steps) to excel on these tasks, rather than training from scratch. This kind of transfer learning – taking a large multimodal model and grounding it with task-structured data – is a hallmark of modern robotics research. Performance and Capabilities on LIBERO Tasks. After fine-tuning, how well does MolmoAct2-LIBERO actually perform? The answer is: extremely well. According to Ai2’s results, MolmoAct2-LIBERO solves virtually all tasks reliably, with a mean success rate of 98.25% on the standard LIBERO benchmark (with continuous action inference). The official model card breaks down success by task suite: 98.4% on Spatial tasks, 100.0% on Object tasks, 98.0% on Goal tasks, and 96.6% on the Long-horizon tasks. These numbers are all near-perfect; the only one below 100% is the hardest Long suite (which involves longer instruction sequences). For comparison, the original MolmoAct2 (pre-fine-tuning) had an average of 97.20% on the same suites. Thus fine-tuning gave a noticeable bump (e.g. Long from 93.2% to 96.6%). The AllenAI blog reports similar figures: “On LIBERO…MolmoAct2 reaches a 97.2% average success rate after post-training while MolmoAct2-Think reaches 98.1%”. (The slight difference from 98.25% is presumably due to rounding or evaluation setup; either way, it confirms the high-90s success rates.) In practical terms, this means the robot almost never fails a task given a valid instruction it has seen during training. These success rates are state-of-the-art for fully open models, and surpass many baselines. For instance, Ai2 notes that MolmoAct2 trained 97.2% on LIBERO exceeds prior fine-tuned baselines by up to 3.8–15%. In their own lab benchmarks, MolmoAct2 also outperformed “$\pi_{0.5}$-DROID”, a leading policy from previous work, by several percentage points. In independent validation by CortexAI on real bimanual tasks, MolmoAct2 achieved the highest score (0.51, out of a normalized 0–1 metric) compared to Pi0.5 (0.32) and several others. Moreover, MolmoAct2 not only succeeds at the tasks it was trained on, but also produces high-quality trajectories. The team reports that trajectories from MolmoAct2 have shorter completion times, smoother joint paths, and lower jerk than baselines, indicating more natural and efficient motions. In sum, MolmoAct2-LIBERO is not just “getting the job done”; it does so gracefully, which is critical for safe deployment on real robots. Crucially, MolmoAct2’s performance on LIBERO tasks is achieved without additional engineering per task. The same model handles placing mugs on plates, sorting blocks, opening drawers, etc., all by changing the language prompt. The HuggingFace examples show the model receiving a frame from LIBERO (with a “put the white mug on the left plate…” instruction) and outputting a continuous velocity/gripper action sequence. This exemplifies how a VLA model can attend to different subtasks via natural language, rather than requiring separate code or models for each scenario. In short, MolmoAct2-LIBERO demonstrates a robust generalist policy for household manipulation. Its 98%+ success rates on widely recognized benchmarks suggest it has “mastered” the LIBERO environment to a degree that previous open systems had not. The fact that this is achieved in simulation at a relatively high fidelity (including realistic collision physics and sensor noise) bodes well for transferring MolmoAct2 to real robots with minimal tweaking. Using MolmoAct2-LIBERO: Tools and Interfaces. Ai2 has made MolmoAct2-LIBERO available through multiple interfaces, reflecting an emphasis on ease of use. The model and its dataset are hosted on HuggingFace. Users can load it via the API in Transformers (with to allow the custom MolmoAct2 code). Inputs are simply PIL or NumPy images in a fixed camera order, plus a NumPy array for robot state, plus a text instruction. The output is a tensor of actions, which one then scales back to real units. The HuggingFace model card even provides Python code templates for “continuous actions” and “discrete actions” examples (though for most users continuous mode is recommended). For those using LeRobot – AllenAI’s robotics framework – there is a LeRobot-specific checkpoint. This wraps the model in the LeRobot class, letting users call familiar and commands. For example, one can do:. Ai2 even provides scripts to continue fine-tuning or fully train new models via , and to run evaluation using real or simulated LIBERO tasks. The entire dataset of LIBERO episodes has been prepared in LeRobot format and published as , so researchers can easily load it into Radiant (AllenAI’s simulation suite) or their own pipelines. In short, MolmoAct2-LIBERO is not a black-box; it is fully documented, with model cards, code examples, and integration with open libraries. This lowers the barrier to adoption. A roboticist with minimal ML experience could feasibly download the model, hook up the sensors, and start running experiments or demos. Comparing to Related Work. MolmoAct2 does not exist in a vacuum – it builds on prior efforts at open robotics models. Let’s situate it briefly among recent work:. MolmoAct (2025): The predecessor MolmoAct model had 10.6K trajectories and 93 tasks in a smaller dataset, and focused on showing that an action reasoning model could beat much larger closed models. It used a 7B transformer and was the first in Ai2’s series of ARM (Action Reasoning Model) releases. MolmoAct2 expands on this by orders of magnitude of data and architecture improvements (the flow expert, new datasets, adaptive reasoning) to target real deployment. Pi-0.5 and others: Open VLA baselines like Pi-0.5 (and extensions like Pi-0.5-DROID) use token-based LLMs for robotics. While they set benchmarks early on, MolmoAct2 outperforms them. For example, in Ai2’s third-party bimanual evaluation, MolmoAct2 averaged 0.51 score versus Pi-0.5’s 0.32. In fine-tuned LIBERO evaluation, MolmoAct2 bested Pi-0.5 based controllers by several points, showing its advantage. Closed models (GPT-5, Gemini, etc.): Many labs have internal sophisticated robots controllers (sometimes using LLMs) that aren’t published. Ai2’s point is that their open model now also surpasses some published proprietary ones. They explicitly note Molmo2-ER beating GPT-5 and Gemini on vision-reasoning metrics, and MolmoAct2 outperforming closed controls on household tasks. This openness vs closed distinction is a central motivation of the project. Other open datasets: The new MolmoAct2 release also advances the data side of things. The Bimanual YAM dataset (720 hours of tele-op data with two arms) is far larger than previous public sets, and other curated trajectory sets (MolmoAct2-DROID, SO-100/101) were added. This means MolmoAct2 benefits from a diversity of robot embodiments – a direction that many in embodied AI find crucial. Compared to pure RL or IL, MolmoAct2’s strength is its multimodal, pretrained foundation. Its performance on LIBERO is higher than typical imitation-only or RL-only policies, likely because it leverages both large-scale pretraining (on vision and language) and the specialized fine-tuning. Its output also seems smoother and faster than many baselines, thanks to the flow control design. Capabilities and Use Cases. What can a user actually do with MolmoAct2-LIBERO? The most obvious is to replicate or extend the LIBERO tasks. One can download the checkpoint and run it in the Radiant simulator’s LIBERO environment (as shown in Ai2’s quick start). The model supports the four LIBERO task suites and can be invoked on any mixture of them. More generally, MolmoAct2-LIBERO can serve as a starting point for related robotic tasks. Because it is a large, pretrained policy, fine-tuning on a new but similar task should require relatively little data. For instance, if a user has a new object or a variant of one of the Libero tasks, they could collect a few dozen demonstrations and fine-tune MolmoAct2 instead of building a network from scratch. MolmoAct2 also highlights how language can flexibly specify tasks. In usage, one would send a variety of instructions (some with multiple steps) to the model. Because the language encoder is large and well-trained, it can understand complex, compositional instructions that might include object names, colors, spatial prepositions, and conjunctions. The successful performance on long-horizon tasks suggests it can handle multi-step plans like “Move the red block to the left side, then place the blue block on top of the green block”, all specified as one string. In real-world deployment, MolmoAct2’s continuous outputs can (after possible integration) command a Franka arm or similar. The released setup even includes reference hardware (two Yaskawa YAM arms with cameras) so that researchers can try MolmoAct2 in their own labs under humidity conditions. Even if one only has a single-arm system, MolmoAct2-LIBERO can be partially used by ignoring the second-view input and limiting itself to one arm’s actions. In that sense, it is a generalist policy for tabletop manipulation. Beyond direct control, MolmoAct2 has interesting interpretability hooks (e.g. the adaptive depth map it computes). Researchers could inspect the predicted depth or the discrete tokens to get insight into the model’s reasoning. This bridges to other interests like explainable AI for robotics. Finally, MolmoAct2’s release encourages meta-scientific work: because data and code are open, people can analyze why it works so well, or port its ideas to new platforms. For example, the MolmoAct2-FAST-Tokenizer is an open replacement for Pi’s code, so one can study how action quantization affects learning. The depth reasoning code is available as an example of conditional computation. This kind of transparency is itself a capability for the community. Significance in Robotics and AI. MolmoAct2-LIBERO embodies several significant trends and achievements in the field:. State-of-the-Art Open VLA Model: Achieving ~98% success on a complex benchmark is a clear new high for open robotics models. It demonstrates that large-scale pretraining plus careful architecture (flows, depth reasoning) can indeed yield near-perfect performance. Bridging the Gap to Closed Systems: By outperforming baselines and rivaling closed models, MolmoAct2 shows that an open model can keep pace with the best industry solutions (or even exceed them in some aspects). This is a big step for democratizing robotics AI. Generalist Robot Reasoning: MolmoAct2 can handle multiple tasks and robot views in one policy, illustrating progress toward a universal robot controller, analogous to how GPT-4 serves many text tasks. The inclusion of continuous control means it is directly applicable to real motions, not just high-level planning. Open Research Culture: The release of MolmoAct2 comes with full datasets, code, and pre-trained weights. This open approach invites scrutiny and reuse, a notable contrast to much robotics research (which often keeps data and weights proprietary). The AllenAI blog emphasizes that researchers can “study and build on” MolmoAct2’s approach. This sets a new standard for reproducibility in embodied AI. Dataset Contributions: The accompanying datasets (720h bimanual, filtered DROID, etc.) are major contributions. They provide ground truth data for training and evaluating future models. The sheer scale of these datasets is a resource that will likely drive many follow-on projects. Perception and Reasoning Advances: Molmo2-ER’s performance on spatial reasoning tasks indicates a maturation of vision-language models for embodied agents. Surpassing GPT-5 on a standard embodied task suite suggests that purpose-built VLA models can outperform even the largest general-purpose LLMs in the embodied domain. Inference Efficiency: MolmoAct2’s inference optimizations (caching, CUDA graph) achieving >50 Hz show that even large transformers can control robots in real time, making them practical beyond just simulation experiments. In broader AI terms, MolmoAct2 represents the continuing convergence of language-model techniques with robotics. It leverages concepts from NLP (tokenizers, transformers, incremental attention, caching) and applies them to the physical domain. The result is a hybrid system where natural language instructions are effectively “compiled” by the model into motor commands, all in one neural network. This is a powerful paradigm that may carry on to more complex tasks (mobile manipulation, multi-agent coordination, etc.). Another significance is the demonstration of transfer learning in robotics. MolmoAct2 starts from a vision-language model and then adapts to a concrete embodied control domain. This workflow (pretrain on generic data, fine-tune on task data) is standard in NLP/CV but relatively new in robotics. The success suggests future robotics models will increasingly use foundation-model pretraining. Conclusion. MolmoAct2-LIBERO is a milestone in embodied AI: it is a fully open Vision-Language-Action model that achieves near-perfect performance on a challenging suite of manipulation tasks. Technically, it combines a spatially-aware VLM backbone (Molmo2-ER), flow-based continuous control, an open PandI action tokenizer, and adaptive depth reasoning. Practically, it comes as a ready-made policy (with code and data) that researchers can use out of the box or fine-tune further. It outperforms established baselines and even competes with proprietary models, showing the power of scale and integration. For the robotics community, MolmoAct2-LIBERO offers a new tool and a new benchmark for what open-source can do. For the AI community, it provides an example of how language-model technology can be grounded in the real world of physical control. And for future work, it lays a foundation: one can imagine extending MolmoAct2 to other robot platforms, adding more reasoning modules, or building on its released datasets. The release of MolmoAct2-LIBERO, checkpoint and data included, underscores the shift towards reproducible and collaborative research in robotics. It invites other scientists to push the envelope further, perhaps toward even more complex tasks or toward combining MolmoAct2 with new modalities (like tactile sensing or voice). It is an exciting time when a researcher can download a 5B “robot brain” in minutes and start experimenting. Overall, MolmoAct2-LIBERO is more than just a high score on a benchmark – it is a concrete demonstration that generalist, vision-language action policies can approach the reliability needed for real-world robotics, and that this can be achieved in the open. As the AllenAI team phrases it, MolmoAct2 is “an open foundation for robots that work in the real world”, and with MolmoAct2-LIBERO we see the first fruits of that foundation in a tangible way. References: The details above are based on the MolmoAct2 ArXiv paper and official resources (AllenAI blog, HuggingFace model cards, etc.). Key points are from Fang et al. (2026) “MolmoAct2: Action Reasoning Models for Real-world Deployment” and the associated HuggingFace models release, among other cited materials.