Latest / Embodied AI 101 / MotionWAM: Towards Foundation World Action Models for Real-Time Humanoid Loco-Manipulation

Transcript

MotionWAM: Towards Foundation World Action Models for Real-Time Humanoid Loco-Manipulation · Embodied AI 101

• MotionWAM: Towards Foundation World Action Models for Real-Time Humanoid Loco-Manipulation. Humanoid robots are slowly inching closer to the day when they can move and manipulate the world as fluidly as people do. But today’s systems often fall short at tasks that require true whole-body coordination – imagine having a robot that can both walk and pick up objects at the same time. In most current setups, locomotion (walking, balancing, stepping) is handled separately from manipulation by hierarchical controllers. A high-level planner might tell the arms what to do, while a low-level controller keeps the legs moving or balancing. This decoupling means the legs often play only a passive balance role, and can’t help much with tasks that actually need footwork or full-body movement. For example, standing in place to lift something differs greatly from squatting down into a cabinet, kicking a soccer ball, or pressing a trash bin pedal. In those cases, the legs and torso need to act together based on the task, not just on balance alone. A new approach called MotionWAM (Motion World-Action Model) aims to break free of that limitation by learning a truly integrated policy for humanoid loco-manipulation. MotionWAM treats the robot as a single system, using one unified latent representation that encodes the “whole-body intent.” It ties together vision, language goals, and world dynamics into a single model that can run fast enough for a balancing humanoid to use in real-time. In experiments on a Unitree G1 humanoid robot doing tasks like kicking a soccer ball, loading a laundry machine, or stepping on a pedal, MotionWAM achieved an overall success rate of 76.1% – an absolute 32% improvement over the strongest prior method – while running in closed-loop at about 4.9 Hz. In short, MotionWAM demonstrates that a “video-pretrained” world model can be adapted into an actual working controller that drives coordinated walking and manipulation. In this article we’ll unpack MotionWAM’s ideas. We’ll start by reviewing why traditional humanoid control is limited, and how “world-action models” (WAMs) have been used in simpler robots. Then we’ll dive into MotionWAM’s architecture and training: how it uses a diffusion-based video model (“DiT”) to imagine the future, and how it encodes actions in a mixed continuous/discrete “motion latent” space that covers legs, torso, and arms all together. We’ll discuss the three-stage training pipeline (video pretraining, cross-embodiment grounding, and task-specific fine-tuning) that lets this model handle full-body tasks on a real robot. Finally, we’ll look at the results, including the real-world tasks MotionWAM was tested on and how it compares to baselines like the recent generalist humanoid model GR00T. Along the way, we’ll highlight why this work is an important step toward general humanoid “foundation models” – unified models that can drive future robots to move with the flexibility and fluidity of humans. The Limits of Decoupled Control. Nearly all today’s humanoid systems use a hierarchical control paradigm. Conceptually, you have a “brain” that plans or commands a manipulation task (e.g. “pick up that box” or “push the cleaning cloth”), and a separate low-level controller that handles walking or balancing. In practice this often means one algorithm (like a vision-based policy or planner) outputs high-level commands for the upper body (arms, torso) as if the robot were fixed in place, while another controller handles the lower body (legs, feet) to stabilize or follow very coarse velocity commands. The result is inconsistent action spaces: the arms get rich instructions, but the legs are only given simple “move forward/back” signals to keep balance. This separation severely limits what the robot can do. If the legs are “just for balance,” tasks that require active foot or whole-body interaction become impractical. For example, imagine a task where the robot must kick a soccer ball (one of the benchmarks used in the MotionWAM paper). In a decoupled scheme, the arm policy has no responsibility for the legs, so the robot would have to awkwardly shuffle or stand in place, and the legs wouldn’t know to swing out and kick with force. Or consider squatting to reach into a low shelf – that requires precise alignment of the torso and legs together, not separate commands. Similarly, tasks like stepping on a pedal, stabilizing while carrying something heavy with arms, or even simply walking to a goal location while holding an object demand that the whole body act as one. The MotionWAM authors point out that because of this hierarchy, current humanoid systems often “reduce the legs to balance-preserving locomotion”. In other words, a robot’s legs only move enough to keep it upright or follow a given base velocity, rather than actively assisting with the task. This is a fundamental mismatch: in the real world, human tasks frequently involve using our legs and Torso as part of the solution, not just for balance. If we want humanoids to operate in human-designed environments on human-scale tasks, we need task-driven legs and body movement. At the same time, simply adding a separate machine learning policy for locomotion and one for manipulation doesn’t fully solve the problem. These policies often have conflicting or limited views of the world, and they can’t easily coordinate. What if the manipulation policy wants the torso to lean forward while the locomotion policy wonders if it should step to the right? Without a common language or joint reasoning, these layers stay disjoint. MotionWAM proposes a different way: unify the entire robot’s motion into a single policy with a consistent action space. Instead of one policy for arms and another for legs, there is one “action latent” that drives everything together. The robot then interprets that latent through its own internal controller into actual joint commands. This means an instruction can result in, say, leaning, stepping, reaching, and wrist-rotating in concert, all derived from one integrated plan. World-Action Models: Video Prediction Meets Control. To achieve unified whole-body control, MotionWAM builds on the idea of World-Action Models (WAMs). A WAM is basically a robot policy that incorporates a generative model of the world’s dynamics – usually a video prediction model – alongside the action generation. In other words, the policy is coupled with a “world model” that can imagine how the scene will evolve. Classic world-model approaches in robotics and reinforcement learning have used learned dynamics to plan or to form latent states (think of models like “planet” or “dreamer” in RL, which predict future states). MotionWAM takes this into the visual domain: it uses a video diffusion model to predict future visual frames, and then figures out actions that will bring about those future frames. This idea isn’t entirely new. For tabletop manipulation tasks, researchers have started using video-based diffusion models to plan or sample actions. The WAM concept is to have a video dynamics prior – a pretrained network that models “how images change over time” – and then to condition the robot policy on that. Early works found this helpful: the video model provides a strong prior of physics and causality, and the policy just learns to steer that predicted future towards the goal. However, there’s a catch: most existing WAMs in the literature have been too slow for real-time, especially on humanoids. The typical way to use a diffusion model is iterative denoising, which means running many passes to gradually refine a predicted video. That can look something like: propose a random latent, gradually “denoise” it in multiple steps to generate a whole sequence of images, and then decode the actions. This process is computation-heavy. On a tabletop setup or in offline planning, maybe it’s fine to spend seconds on each planning step – but a balancing humanoid needs to react in real time. The authors note that such iterative pipelines made prior WAMs “too slow for real-time closed-loop control on dynamically balancing humanoids”. Put simply, if your model takes 5–10 seconds to think of an action, your humanoid will have fallen down or missed the ball by then. MotionWAM overcomes this by designing a one-shot diffusion strategy. Instead of running the full diffusion out from random noise to full video, MotionWAM runs a single forward pass through a large pretrained video transformer model (they refer to it as a “Video DiT”) and then stops partway, grabbing intermediate features. These features already capture a plausible future of the scene (an “imagination”), without the heavy cost of producing a final pixel video. Then a second network (“Motion DiT”) takes those imagined features, along with the robot’s current proprioceptive state and the (textual) goal, and directly outputs whole-body motion commands. By interrupting the diffusion early and skipping the final generation, MotionWAM achieves a control loop around 4.9 updates per second, which is fast enough to run online on the robot. In other words, MotionWAM conditions the policy on latent video-model features. The video model provides a spatio-temporal context – “what the future might look like if I act” – and the policy network uses that context to decide how to move. This has a pleasing metaphor: the humanoid “imagines” the scene forward one step, and then decides what to do. And crucially, it does this in one shot rather than in a long chain of sampling, so the thinking is quick. MotionWAM Architecture: One Latent, Two Transformers. MotionWAM’s core consists of two coupled transformer-based modules (hence “dual-DiT”). The first is a Video DiT (Diffusion in Transformers), which is a pretrained video-generation model. The second is a new Motion DiT that produces actions. Let’s break down their roles:. Video DiT as a Visual “Imagination”. The Video DiT is a large model trained to predict future video frames from past frames (and optionally actions). Typically, such models would take the current image, maybe some steps of prior images, and then iteratively denoise to generate a sequence of future frames. MotionWAM uses a pretrained DiT (the authors mention it’s large, though they don’t specify exactly which). For each control step, MotionWAM does a single forward pass through the Video DiT, but stops short of full sampling. It intercepts the network at a late layer (denoising a few steps) and extracts the intermediate features. These features form a kind of high-level “latent imagination” of what could happen next in the camera’s view, without actually rendering pixels. In effect, the Video DiT has internalized a physics prior from all the video it saw during pretraining. It “knows” how objects move and interact. By pausing it mid-generation, MotionWAM cheaply gets an abstracted sense of future dynamics. Motion DiT for Whole-Body Action. The Motion DiT is the policy network. It takes as input the extracted features from the Video DiT, along with the robot’s own proprioceptive state (joint angles, velocity, balance metrics, etc.) and a language-goal (a text or semantic goal describing the task). Using all that, it outputs a unified motion latent $m_t$ for the whole robot. This latent is split into two parts: continuous channels and discrete tokens. The continuous channels might control things like gripper position or smooth arm motion. The discrete tokens (a 64-dimensional vector of “motion codes”) represent coarse whole-body behaviors: walking, turning, squatting, stepping, kicking, etc. In other words, the Motion DiT predicts action tokens in that same domain of video-diffusion latents (they call them “whole-body motion tokens”). These tokens encompass locomotion (step forward, turn, etc.), torso orientation (tilt forward/back), height regulation (crouch/squat levels), and foot interactions (e.g. step-on vs none). Because they are learned, a single token can encode a complex quick action like “take one big step” or “shift weight to left leg.” Finally, these tokens and channels are consumed by the robot’s low-level controller (they use a “SONIC” whole-body controller) to produce the actual joint torques and positions. The key is that this single latent $m_t$ uniformly drives arms, legs, torso – everything. Contrast that with a split system: previously, you might have to separately fire off an arm-motion policy and a leg-motion gaits. Here, a motion like “kick ball” can naturally involve moving the leg and torso in tandem as a single coherent intent. As the authors put it, this lets the robot “command a ‘kick’ or a ‘squat’ as a single coordinated intent, rather than trying to synchronize separate arm and leg commands”. Because the Motion DiT is attached to a strong video model, it effectively learns “if I see the scene moving this way, what whole-body movement should I do?” The coupling of vision, proprioception, language, and action in the same transformer is what makes it powerful. Another critical detail: this process remains real-time. By using the technique of halting diffusion early (a “one-shot imagination”), MotionWAM’s loop runs at about 4.9 Hz. In robotics, “real-time” often means on the order of 10 Hz or faster. For a humanoid, anything slower and the robot will walk away from optimal or even topple. The MotionWAM architecture, with heavy vision models, still manages under 5Hz because it avoids heavy iterations. The experiments confirm that this is enough for closed-loop control in tasks like wiping a whiteboard or tossing garbage into a bin, where the robot needs to adjust mid-motion if the target moves. In fact, one of MotionWAM’s achievements is proving that large video world models can be trimmed to real-time speed if they inject denoising features rather than full video output. Progressive Training: From Videos to Robots. Training MotionWAM is done in three stages. The reason for this multi-stage approach is that they want the model to benefit from massive video data (to learn general physics) while also specializing to the actual robot and tasks. Learning all of that at once purely from the final task data would be impossible with typical dataset sizes. So instead, they “progressively” grow the model’s knowledge:. Stage 1 – Egocentric Video Pretraining. First, the Video DiT is trained on loads of action-free video. In MotionWAM, they fed it about 2,136 hours of egocentric footage. This is video shot from cameras on humans or robots, looking out at the world (often called egocentric or first-person video). The key is that these videos contain dynamics and physics of objects: things move, fall, get pushed – but usually without the camera doing something particular. By training on this data (likely with a standard video diffusion objective), the Video DiT learns general visual patterns of how objects move naturally. For example, if you see a ball in frame and no one touched it, the model might learn that often it stays put; or if you see a soccer ball with a leg approaching (if any such data existed), the model might encode how it would roll. These learned features form a “physics prior” or a “latent world model”. Importantly, the egocentric data doesn’t have associated actions – it’s just passive observation. That’s fine: stage 1 is just trying to make the video model good at predicting future frames from sequences of images. The vast scale (thousands of hours) is meant to capture a wide variety of human-like scenarios. Stage 2 – Cross-Embodiment Action Grounding. Once the Video DiT has a solid visual imagination capability, they hook on the Motion DiT and start training on actual robot data – but not yet the final tasks. Instead, they gather data from multiple robots or arm setups doing various actions. For instance, they could use datasets from robotic arms or teleoperated tasks that involve pushing, grasping, locomotion, etc. The paper says they train on “a variety of robot datasets with different arm configurations and setups”. The aim here is to teach the Motion DiT how the video features correspond to actions across different embodiments. In practice, this stage uses a joint loss: they continue training the video model on video frames (so it doesn’t forget its world knowledge), while also training the Motion DiT to predict the robot’s action tokens that actually produced those frames. If the dataset has pairs of (video frame sequence, robot joints/actions, language goal), then the Motion DiT learns to reconstruct the actions. The combined loss (video loss + motion loss) ensures the DiT doesn’t drift away from its world-model roots while it begins to learn actionable outputs. This “cross-embodiment” training means the same network starts seeing humans, different arm robots, and (likely) wheeled robots too, mapping all that into a unified motion latent space. Stage 3 – Whole-Body Fine-Tuning. Finally, the system is fine-tuned on the specifics of the target humanoid (Unitree G1) and final tasks. For this, they use high-quality demonstrations collected via teleoperation. Human operators in VR essentially “drive” the real humanoid through the desired tasks: e.g. telling it to walk up and kick the soccer ball, or squat and pick object, etc. These demonstrations are recorded as egocentric video plus action latents for Stage 2 networks to learn from. This final stage adapts the model from the general knowledge of stages 1 and 2 into executing precisely the tasks the authors care about. Each stage boils down the “search space”. Stage 1 gives the model rules of physics for daily life; Stage 2 connects those rules to how robots move; Stage 3 hones it on exactly the humanoid’s body and the tasks it must do. The paper’s ablations show this progression is crucial: skipping Stage 1 (no video pretraining) drops success by ~11%, while skipping Stage 2 (no cross-embodiment grounding) drops success by ~28%. In other words, Mr. Robot’s performance suffers badly if it can’t rely on the broad visual priors or if it isn’t grounded in actual robotic motion. This multi-stage recipe is reminiscent of how we train large language models: pretrain on general text then fine-tune on end tasks. In the robotic setting, MotionWAM treats the robot policy as a “foundation model” that starts from Internet-scale (or at least multi-robot-scale) video and then narrows in. The authors note this as well: “scaling from general video to cross-robot data and then to specific tasks is a robust way to train generalist humanoid policies.”. Unified Action Space: Encoding an Entire Body. A key innovation in MotionWAM is how it encodes the robot’s action at each timestep. Rather than outputting raw joint torques or separate limb commands, the network predicts a latent action vector $m_t$ that represents the whole-body movement intent. This is reminiscent of “motion primitives” or “behavior tokens,” but learned automatically. The latent $m_t$ has two parts:. Continuous Channels: These are real-valued outputs for fine-grained control of parts that need precision. For example, the grippers (the robot’s hands) are controlled by continuous channels. If the robot needs to gently grasp an object, the exact finger positions matter, so a continuous output can handle that nuanced control. Continuous channels can also fine-tune smooth motions of arms or torso. Discrete Motion Tokens: This is a 64-dimensional vector of discrete values (essentially categorical codes). Each dimension corresponds to a part of the whole-body plan. For instance, one dimension might encode footstep patterns, another might encode torso lean, another squat height, etc. The paper specifically mentions tokens that cover “locomotion (walking), torso orientation, height regulation (squatting), and foot interaction intent.” Intuitively, you can read one dimension as “is the robot stepping forward or standing still,” another as “how tall is the robot standing,” and so on. The combination of all 64 tokens fully describes the big-picture movement of the entire robot in that moment. These continuous and discrete parts together form the unified latent $m_t$. After the Motion DiT outputs $m_t$, an underlying whole-body controller (they use a proprietary Unitree “SONIC” controller) takes $m_t$ and converts it into actual ankle, knee, hip, torso, arm, and hand joint commands. That controller knows the robot’s kinematics and dynamics; it’s effectively a differentiable step that can translate high-level motion codes into low-level actions. This design allows the model to think in terms like “walk forward two steps while leaning right” and “reach forward with my right hand,” encoded compactly, and then let the controller implement it. The result is a truly integrated action space: all parts of the robot are controlled by one latent, so coordinated movements come naturally. As the authors say, this removes the “upper-lower split” where earlier systems had separate leg and arm policy spaces. Now the legs and arms live in the same space, so there’s no mismatch. In practical terms, this means the model can do things like “kick” or “squat” as single commands. The figure in the paper (Figure 2) illustrates this nicely: it shows how abstract tokens correspond to a swing of a leg or a height adjustment. Because these tokens are learned, they automatically capture complex patterns of whole-body coordination, without the designers having to manually define them. It’s essentially letting the data determine what the basic motions should be. Experiments: Simultaneous Loco-Manipulation Tasks. To demonstrate MotionWAM, the authors tested it on a real Unitree G1 humanoid robot in a series of challenging tasks. Unitree G1 is a walking quadruped (actually more like a humanoid/animal hybrid - it has a torso and two legs, not arms). This robot is relatively small, but it’s a stepping stone toward bigger bipedal humanoids. Despite being only two-legged, it can still do interesting loco-manipulation like pushing, pulling, kicking, and reaching with its front appendage. They designed nine real-world tasks that specifically require integrated whole-body control. These tasks include:. Kick Soccer: The robot approaches and kicks a free soccer ball. Success means sending the ball to a target zone. This obviously needs coordinating a full step and swing of the leg with body balance. Load Laundry: The robot must reach down, open a drawer (or door), squat, and place an object inside. This uses a lot of vertical motion and torso-lean while balancing on one foot, plus arm movement. Retrieve from Drawers: Similar to laundry, the robot pulls an item out of a drawer or low shelf. It may need to shift weight into a squat and use a gripper. Open Doors / Cart loading: Possibly tasks like opening a hinged box or pushing on a cart using shoulder height. Wipe Board / Toss Garbage: These involve potentially dynamic targets – e.g. a moving board cleaner or an object thrown for catching – requiring the robot to adjust mid-action (which is feasible only if the policy is running in a loop reacting to new vision input). Trash Pedal: Stepping on a foot pedal to open a bin. This is a good test of active foot use. Deep Squat: Crouching down fully to reach low. This tests extreme thigh squat control. etc. (A technical detail: the Unitree G1 may not have an actual “trash pedal” or “soccer plane” in the lab, but the experimenters likely simulated these with simple boards and balls. The key is that these tasks all require the legs, torso, and sometimes arms to move together.). Each task was evaluated by whether the robot successfully completed it under continuous closed-loop control. They measured success rates over many trials. Baselines. MotionWAM was compared to several baselines. The most important comparison is to the state-of-the-art Vision-Language-Action (VLA) baselines. VLA refers to policies that take an image and a language instruction and output actions. A prominent example is NVIDIA’s GR00T (Generalist Robot 00) model series, which is a transformer-based foundation model for robots that can be conditioned on language. In fact, MotionWAM is directly compared to “GR00T-N1.7”, a version of GR00T. The authors note that GR00T-N1.7 achieved only 43.9% success overall on these tasks, versus MotionWAM’s 76.1%. They stress this is the “strongest state-of-the-art VLA baseline” they could find. They also compare to some prior WAMs adapted to humanoids (if any existed), and to simpler policies. One referenced approach is Cosmos Policy, which is another recent idea for using pretrained video models for robot vision-action. However, Cosmos Policy was primarily demonstrated on manipulation and is known to be computationally heavy (in their terms, “search takes 4.9 seconds on 8 H100 GPUs”, so clearly not real-time by comparison). In short, the baselines are: (1) existing vision-language or world-model approaches not specifically tailored to whole-body tasks, and (2) hierarchical control or learned policies from imitation, etc. MotionWAM outperforms all of them by a wide margin on this test suite. Results. Here are the headline numbers from the MotionWAM experiments:. Overall success rate: 76.1% averaged over all nine tasks. The best baseline (GR00T-N1.7) only got 43.9%. That’s a 32.2% absolute improvement. Task-by-task: MotionWAM beat every baseline on every individual task. The gains were especially large on tasks needing active footwork. For example, in “Kick Soccer”, MotionWAM’s success was about 40 percentage points higher than any other method. This underscores that its unified approach really helps when the legs must do something meaningful. Ablations: If they remove training Stage 1 (no video pretrain), success drops by 11%. If they remove Stage 2 (no cross-embodiment), drop is 28%. This confirms that the large-scale priors matter hugely. Inference speed: MotionWAM runs at around 4.9 Hz in closed-loop on the robot. (This is measured end-to-end.) In comparison, as mentioned, the Cosmos Policy approach ran planning at ∼0.2 Hz (4.9 seconds per decision) on multiple GPUs. So MotionWAM is orders of magnitude faster and suitable for real-time. (The exact hardware they ran on isn’t explicitly stated, but likely a powerful GPU offboard the robot.). The difference in speed matters a lot. In one ablation context, they note: “many state-of-the-art vision models are too slow for robots, but MotionWAM’s one-shot ideas let it run in closed loop” so it can adjust on the fly. They even call out tasks like “Wipe Board” or “Toss Garbage” where the target could move mid-action, which only works if the robot is seeing and reacting at several Hz. Year-over-year performance: (Not explicitly in the text, but by inference.) This paper is dated June 2026, so compared to late 2025 baselines, MotionWAM seems clearly ahead in these scenarios. Overall, the results strongly support the claim that a unified world-action model can dramatically improve loco-manipulation. The performance margins cited are whole-body oriented. It’s worth noting that the baselines were “fine-tuned on the same demonstrations,” meaning even the GR00T-style model saw the same VR teleop data, possibly with language labels. So the improvement isn’t from more data, but from the architecture and training strategy itself. Finally, they did highlight one limitation: MotionWAM currently uses only a single camera on the robot’s head. If the robot looks away from the task, the view might be occluded or out of frame. This is a real drawback of fully egocentric policies. The authors acknowledge it, noting that a 3D-aware or multi-camera version would be future work. But even single-camera, their system worked well enough on these tasks. What This Means: Towards Fluid Humanoid Movement. MotionWAM is an encouraging step toward the kind of integrated, fluid control we expect from a general-purpose humanoid. Here are some takeaways about why it matters:. Unified Whole-Body Control Works. MotionWAM’s big win is demonstrating that a single action space for the entire robot yields better coordination. Instead of telling the arms one thing and the legs another, it commands the robot as one unified system. This coherence clearly improves performance on tasks that involve dynamic balance or foot use. For roboticists, this suggests that even when engineering a control stack, giving the robot a “center of gravity” in software pays off. It may motivate others to rethink control architectures: less fragmentation, more backbone. Video World Models Are Practical. It has often been thought that fancy diffusion-based world models are too heavy for real robots. MotionWAM proves the opposite: with the right tweaks, these models can run at usable speeds. The trick of one-shot denoising is particularly clever: it shows a path for others to make generative models practical. It aligns with other recent findings (e.g. Tseng et al. used a pre-trained video model for policy evaluation, and Kim et al.’s Cosmos Policy fine-tuned a video model directly for control – but needed expensive planning loops). MotionWAM’s architecture suggests that if you treat the video model as a feature extractor rather than the final pixel predictor, you can keep the big picture but avoid the time sink. Progressive Training is Key. Training directly on a few hours of robot data would never have worked. By pretraining on thousands of hours of human/robot vid and then gently adapting through multiple stages, the authors essentially built a “foundation model” for movement. It’s reminiscent of how large language models work, and in fact other works (like GR00T) also call their models “foundation models” for robots. MotionWAM shows that this concept extends to visuomotor skills. The fact that visual priors and multi-robot grounding were crucial (ablation drops of 11% and 28%) underlines that we should leverage large general corpora (here, videos) before fine-tuning on specific tasks. Broader Landscape. MotionWAM is part of a flurry of “world-action modeling” research. Around the same time, others released related ideas: DSWAM (Dual-System WAM) for fine manipulation, EgoWAM using egocentric human videos, DIM-WAM with memory, WAM-TTT (test-time translation of video models), TouchWorld (tactile model), etc. MotionWAM’s focus is specifically on loco-manipulation, which is less studied. It complements these efforts by tackling the challenge of locomotion. The trend is clear: robotics is moving toward transformer-based generative models as the core of policies. Each paper addresses a piece of the puzzle (fine finger movements, long-term memory, tactile sense, etc). MotionWAM’s niche is integrating walking and reaching. Open Questions and Next Steps. This work also highlights what’s next. The single-camera view is an obvious limitation – adding more sensors or performing explicit 3D reasoning could help. Extending from Unitree G1 (a small, under-actuated biped) to more human-like robots would be exciting. Another question is generalization: can MotionWAM handle tasks it hasn’t been tele-operated on at all, just by naturalizing new language goals? The paper suggests it could, given enough video priors, but they only tested on the set of 9 trained tasks. Making it truly “generalist” would be the foundation-model vision. There’s also the matter of efficiency: 4.9Hz is a win, but humanoid dynamics could allow faster cycles if needed. Optimizing inference or distilling the model might improve that further. In summary, MotionWAM shows that the “embodied AI” community’s trend of using large pretrained models can apply not just to vision or language, but to controlling a moving robot in real time. By combining video prediction and action generation in one model and training it as a foundation, we can get unprecedented results on tasks that used to be very hard for robots. The robot in MotionWAM’s experiments begins to behave more like a coherent human: it plans with the whole body, not as fractured parts. That’s a promising direction for future humanoids. Overall, MotionWAM is a step toward the day when robots truly move with the grace and coordination of a person – learning from watching the world, then doing it in action. It tells us that imagining the future (via a video model) and acting on those imaginations (via a unified policy) is a viable strategy for complex control. For researchers and engineers, it offers a recipe: build a video world model, connect it to a motion policy, and train carefully. The result: robots that can kick, squat, balance, and reach all at once, all under a single learned umbrella model. References: This write-up is based on the ARXIV report “MotionWAM: Towards Foundation World Action Models for Real-Time Humanoid Loco-Manipulation” by Jia Zheng et al. (2026). Key baselines include the GR00T humanoid model and Cosmos Policy; for context, works like Cosmos Policy also use video diffusion for action, but at slower speeds. The approach relates to other world-model methods such as Tseng et al.’s action-conditioned video world models. MotionWAM’s results demonstrate that with the right architecture, large video models can control real robots in real time.