Latest / Embodied AI 101 / Flex-π: One Robot Policy, Three Futures, Fifty-Six Ways to Run It

Transcript

Flex-π: One Robot Policy, Three Futures, Fifty-Six Ways to Run It · Embodied AI 101

• Flex-π: One Robot Policy, Three Futures, Fifty-Six Ways to Run It. Flex-π: A Multi-Stream World-Action Model with Compute Flexibility • Ge Yan, Jinghao Liu, Yuzhi Fan, Lei Cai, Minwen Liao, Jesse Zhang, and Dieter Fox • University of Washington and Allen Institute for AI • arXiv preprint • 2026. Research note: The supplied URL, arXiv:2608.10915, points to an unrelated paper titled ComBodied Agents: a New Paradigm of Human-Centric Agentic AI. The Flex-π paper is arXiv:2608.10860, submitted on August 11, 2026. This episode reviews the latter. The central idea: richer futures, optional imagination. Flex-π begins with a simple criticism of current world-action models. If the purpose of predicting the future is to improve manipulation, why should the future be represented exclusively as RGB video?. RGB reconstruction rewards a model for preserving color, texture, lighting, shadows, and every other visible detail. Some of those details matter for manipulation, but many do not. Conversely, the quantities that determine whether a grasp or insertion succeeds—relative depth, free space, contact geometry, object identity, and part structure—are only indirectly represented in pixels. A model can produce plausible-looking video while still being wrong about whether a gripper is in front of an object, whether two parts are aligned, or which patch belongs to the zipper pull. Flex-π therefore trains one world-action model to jointly predict four streams: robot actions, future RGB latents, future 3D pointmaps, and future DINO features. RGB supplies appearance and the motion priors inherited from video generation. Pointmaps provide an explicit image-aligned representation of 3D geometry. DINO features provide object-centric perceptual structure. All four streams are denoised inside a roughly six-billion-parameter Mixture-of-Transformers model. The more interesting part, however, is not merely adding modalities. Flex-π separates the richness of the training objective from the compute required at deployment. During training, the model learns from all streams and is repeatedly forced to reconstruct modalities that have been hidden from its input. At inference, an operator can choose which visual streams are available as observations and which future streams the action decoder is allowed to use. The same weights can therefore behave like a fast action-only policy, a full world-action model, or a hybrid that imagines only RGB, DINO features, or geometry. This is the paper’s real contribution: treating the inputs and predictive outputs of a robot foundation model as runtime configuration rather than permanent architectural commitments. Why RGB-only futures are an awkward target for manipulation. World-action models occupy an increasingly important middle ground between reactive vision-language-action policies and classical world-model-based control. A conventional VLA maps images, language, and robot state directly to actions. A WAM also predicts some representation of the future. That auxiliary prediction can improve the representation learned during training, or the predicted future can be consumed directly during action generation. Earlier systems such as Unified World Models coupled action and video diffusion in one transformer. DreamZero scaled joint video-action modeling with a pretrained video diffusion backbone. LingBot-VA similarly used a shared latent architecture to predict visual dynamics and actions. These approaches inherit useful priors from internet-scale video generation. A video model already knows a great deal about persistence, motion, articulated objects, occlusion, and how scenes tend to change. But a video VAE is optimized to reconstruct pixels, not to produce the state representation a controller would have designed from first principles. This distinction becomes acute in precise manipulation. Consider inserting a screwdriver bit into a socket with a fraction of a millimeter of clearance. Pixel-level fidelity is not enough. The policy needs the relative pose between the bit and socket, the object boundaries, and a stable estimate of scene geometry. Or consider manipulating a soft pouch. The relevant variable is not simply whether the predicted image looks like a pouch, but where its opening and zipper have moved after each interaction. Flex-π’s answer is multi-view supervision of the same underlying event. The model sees the world simultaneously as appearance, geometry, and object-centric features. The three representations do not need to agree at the level of decoded pixels. Instead, they constrain the shared transformer to encode a future that is useful across all three descriptions. This is closely related to multi-task representation learning, but with an important twist: the auxiliary tasks are future prediction tasks, and actions can attend directly to the visual futures while they are being generated. The model is not just learning three encoders for the present. It is learning a shared predictive representation of what comes next. Inside Flex-π. Three streams, one predictive backbone. Flex-π is initialized from the five-billion-parameter Wan-2.2 video generation model. The visual side retains a 30-block transformer at a hidden width of 3,072. A separate action expert adds roughly another billion parameters. It has the same depth and attention-head geometry as the visual backbone, allowing its queries, keys, and values to participate in shared attention, but its residual width is reduced to 1,024. Because the dimensions do not match, the action expert is initialized by interpolating and rescaling the corresponding Wan weights rather than copying them directly. The RGB stream is processed by the frozen Wan-2.2 VAE. Pointmaps are sent through exactly the same frozen VAE, using a separate copy of the trainable patch embedding and output projection around the shared transformer. DINOv3 supplies a third set of visual tokens. Language is encoded by Wan’s frozen umT5 encoder, while current proprioception is projected into one additional token and appended to the language sequence. For the DINO stream, Flex-π retains the spatial patch tokens rather than reducing the image to a global embedding. A DINOv3 ViT-B/16 produces a 14-by-14 grid of 768-dimensional features for each view. The model applies an invertible space-to-channel operation: every two-by-two group becomes one 3,072-dimensional token. This reduces the DINO sequence length by four while retaining all feature values. Because the resulting tokens are unusually high-dimensional, the DINO head predicts the clean feature directly and then converts that estimate into the velocity required by the common flow-matching objective. Cross-stream communication occurs only in the middle 16 of the 30 transformer blocks. The early blocks remain stream-specific, giving each modality room to perform its own encoding. The middle trunk fuses appearance, semantics, geometry, and action information. The late blocks again specialize toward the corresponding outputs. This is a sensible compromise: fully independent towers would weaken cross-modal learning, while concatenating everything from the first layer would force low-level RGB, DINO, pointmap, and action tokens into an unnecessarily homogeneous representation. Each training example spans 33 robot timesteps and produces a chunk of 32 continuous actions. The visual window is sampled at a stride of four, yielding nine frames over the same horizon. Wan’s temporal compression converts those into three latent frames: one present anchor and two future latent frames. The DINO features are taken at the corresponding timestamps. Thus the action chunk and visual prediction describe the same interval rather than unrelated short- and long-term horizons. Actions are not discretized. Each timestep becomes one action token, so the action expert jointly denoises 32 continuous action vectors. The model uses a canonical 32-dimensional layout for both state and action, with slots for two end-effector poses, two grippers, and two sets of joint positions. Unused dimensions are padded and masked for embodiments with smaller state spaces. On the real robot, actions are represented relative to the pose observed at the beginning of the chunk, avoiding the integration drift that would result from expressing each target relative to the preceding predicted target. The pointmap “free lunch”. The paper’s most surprising engineering observation is that the RGB-trained Wan VAE can reconstruct pointmaps without any pointmap-specific pretraining. A pointmap is an image-shaped tensor in which every pixel stores a three-dimensional coordinate rather than a red, green, and blue value. It remains spatially smooth and edge-aligned, so many of the convolutions and compression priors learned for natural images remain useful. The project page reports a reconstruction PSNR of 31.1 decibels, normalized mean-squared error of (3.1\times10^{-3}), and depth-axis RMSE of 4.9 centimeters when a pointmap is passed through the frozen VAE. That is strong enough to make the latent space practically useful, but the result should be interpreted carefully. It does not prove that an RGB VAE inherently understands projective geometry. A more conservative interpretation is that an image VAE is also a competent compressor for smooth, three-channel coordinate fields. Flex-π’s trainable transformer and pointmap-specific adapters still have to learn how those latent fields evolve during robot interaction. The 4.9-centimeter decoded depth error also does not place a corresponding lower bound on control precision. The robot never needs to decode the generated pointmap to choose its action. The action expert reads the evolving latent tokens directly, and those latents can preserve task-relevant relative structure even when their pixel-space reconstruction has metric error. The “no new sensors” claim likewise needs nuance. During AGIBOT pretraining, pointmaps are generated offline from RGB with Depth Anything 3 and lifted using camera intrinsics. In simulation, the authors can render depth. On their real YAM platform, however, the three stereo cameras provide sensed depth, which is converted into pointmaps for the full-input configuration. The method can operate without a depth sensor by dropping the pointmap input, but the headline real-world deployment does have depth available. The pointmap representation is also image-aligned rather than a globally fused 3D scene. The three camera views are tiled into one composite canvas, and their pointmaps are tiled in the same way. This avoids global extrinsic calibration and allows all views to pass through one VAE call, but it is not an SE(3)-equivariant map or a persistent world-coordinate point cloud. Geometry is explicit, but still organized around the camera images. Actions read the future. The attention pattern reveals an important detail about what kind of world model Flex-π actually is. Action tokens can attend to current observations and to whichever future visual streams are active. Visual tokens do not attend to the action stream. Consequently, the generated visual future is not a conventional action-conditioned counterfactual simulation in which the model asks, “What happens if I execute this candidate action?” Instead, it is closer to a language- and observation-conditioned latent plan: the visual streams imagine a plausible task-consistent future, and the action stream predicts commands that realize that future. This distinction matters if one wants to use Flex-π for model-predictive control. It does not expose a forward model into which arbitrary candidate action sequences can be inserted and evaluated. Its joint distribution is directed from predicted visual futures toward actions. That is well suited to imitation learning and goal-conditioned generation, but it is different from an explicit dynamics model such as PointWorld, which takes proposed robot actions and predicts the resulting 3D scene motion. The one-way structure may also help explain why visual generation improves action prediction. The future streams function as a dense intermediate plan. RGB describes what task completion should look like, DINO stabilizes which objects and parts are involved, and the pointmap constrains where those entities should move in 3D. The action expert then translates that plan into a control chunk. How one checkpoint becomes 56 deployment configurations. Flex-π samples two independent masks during training. The input mask determines which of RGB, DINO, and pointmap streams are available at the current timestep. Each is independently retained with probability one half, subject to at least one stream remaining. Missing inputs are zeroed while retaining the fixed sequence layout. The output mask determines which predicted visual futures the action tokens can read. Crucially, it is an attention mask rather than a loss mask. During training, every future stream is still denoised and supervised, even if the action expert cannot attend to it in that sample. Because the two masks are independent, the model is regularly asked to generate a future modality that was absent from the input. It might have to infer future geometry from RGB and DINO, or future DINO features from RGB and geometry. The authors call this cross-modality forcing. There are seven nonempty subsets of three possible input streams and eight subsets of future visual outputs, including generating no visual future at all. Actions are always present. That gives 56 visual input-output configurations from one checkpoint. At inference, a future stream that the action expert does not read can be removed from the sequence rather than merely masked. The main operating points are therefore:. Action-only: Observe any chosen inputs but denoise only the 32 action tokens. Hybrid: Generate actions together with one or two visual future streams. Full joint: Generate actions, RGB latents, DINO features, and pointmaps together. The action-only setting can behave operationally like a VLA when given RGB and asked only for actions, but it is worth avoiding an architectural overstatement. Flex-π is not a conventional VLM-based VLA in this mode. It remains a video-generation-derived model with an umT5 language encoder and an action expert; the difference is that its visual future tokens are omitted during sampling. “Action-only” also describes the outputs, not necessarily the inputs. The reported 60-millisecond fast path is measured with the full RGB, pointmap, and DINO input stack. It suppresses future visual denoising but can still benefit from present-time geometry and semantic features. A genuinely RGB-only deployment is supported, and the cross-modality objective is specifically intended to make it viable, but it should not be conflated with every action-only result. This design naturally suggests an adaptive controller that runs action-only during easy free-space motion and activates geometry or full visual generation near contact, under distribution shift, or when uncertainty rises. Flex-π does not implement such a scheduler, but it supplies the architectural prerequisite: switching modes does not require loading different weights or retraining the policy. Training and systems engineering. Flex-π is pretrained on roughly 500 hours drawn from 100 tasks in AGIBOT World-Beta. The authors take up to the first 285 episodes of each task and re-segment long demonstrations at language-annotation boundaries, ensuring that each training window is paired with an instruction describing the local motion rather than only the entire task. Depth Anything 3 is run offline over all three camera views to provide pointmap targets. The Wan VAE, umT5 encoder, and DINOv3 encoder remain frozen. Training updates the visual transformer, action expert, modality adapters, and output heads. All four stream losses receive equal weight. The authors report that the extra modalities and cross-modality forcing slow convergence; real-world fine-tuning requires at least ten epochs. Sampling uses four Euler steps. On RoboTwin, the action-only model peaks at four steps, with two steps remaining within roughly one success point. One-step sampling reduces latency to 49 milliseconds but collapses success from approximately 94.6% to 52.9% in the randomized condition. This indicates that Flex-π is a few-step model, not a distilled one-step policy. The latency figures also rely on substantial deployment engineering. Full joint generation processes 1,193 tokens per denoising step, while action-only mode caches 387 observation tokens and repeatedly updates only 32 action tokens. The optimized full-joint path uses TensorRT, a prefill/decode split, host-side memoization, and encoder CUDA graphs. The action-only path benefits most from compiling the entire denoising loop. At four steps on an RTX 5090, the resulting latencies are about 193 milliseconds for full joint generation and 60 milliseconds for action-only inference. These are useful system numbers, but not a controlled architecture-only comparison. The paper explicitly measures each baseline in its deployed configuration rather than applying equal optimization effort. Fast-WAM is additionally compiled by the authors, while Flex-π receives a more extensive custom inference stack. The claim that action-only Flex-π is faster than all tested baselines is therefore valid for the reported systems, not necessarily for every equally optimized implementation. On the real robot, the model runs at 30-hertz action resolution but replans only once every 32 actions, or approximately every 1.07 seconds. All 32 targets execute open-loop before the next observation is processed. The synchronous client pauses at chunk boundaries during inference. This makes 193-millisecond full-joint sampling deployable for the reported tasks, but the setup should not be confused with a 30-hertz visual feedback policy. What the experiments actually show. Real-world bimanual manipulation. The real-world evaluation uses a stationary bimanual YAM robot with two six-degree-of-freedom arms, parallel grippers, one overhead camera, and two wrist cameras. The five tasks are deliberately more demanding than standard pick-and-place: putting plates into a rack, sorting utensils under contact, long-horizon kitchen organization, manipulating and zipping a deformable pouch, and repairing the robot’s own gripper with an electric screwdriver. Self-Repair Gripper is the most memorable. It contains eight sequential stages, including placing a replacement gripper into a holder, inserting a screw, picking up the powered driver, and seating a four-millimeter bit in a 4.5-millimeter socket. The tightest stage therefore permits only about a quarter millimeter of lateral error. Soft-Bag Zipping requires opening a deformable pouch, spreading it, inserting one or more pens, reacquiring the zipper, and closing it. The reported metric is usually task completion, meaning partial-credit rubric points divided by the maximum attainable score. The paper separately reports binary completion for the sequential tasks. This distinction is important: an 83% result does not mean that 83% of all rollouts completed every stage. Averaged across the five tasks, full-joint Flex-π reaches 83.0% rubric completion and action-only Flex-π reaches 76.4%. ManiFlow reaches 58.0% and π0.5 reaches 52.1%. Fast-WAM averages 31.7%, but it was evaluated on only the three easier tasks after failing to reach a useful level on the first group; it was not run on Self-Repair or Soft-Bag Zipping. The action-only setting beats every baseline on every tested task despite being the faster Flex-π mode. Full joint generation then adds about 13% average success relative to action-only deployment. On Self-Repair, full-joint Flex-π completes all eight stages in 11 of 20 rollouts, while the best baseline does so once. Averaged across the real-world suite, the paper reports 2.3 times the binary success rate of the strongest baseline. The distribution-shift results are also strong. Under unseen objects and clutter, full-joint Flex-π averages 76.1% task completion across three evaluated tasks, compared with 43.2% for π0.5 and 31.5% for ManiFlow. On an unseen soft bag, full-joint Flex-π falls from 70.0% to 63.3%, while π0.5 falls from 42.8% to 17.2% and ManiFlow from 31.9% to 6.9%. Still, “demonstration-efficient” is relative. The real-task datasets range from 152 to 802 episodes, and Self-Repair adds 570 DAgger correction episodes. The hardest tasks contain roughly ten to seventeen hours of task-specific data when corrections are included. Flex-π extracts more value from those demonstrations than the baselines, but this is not yet a ten-demonstration adaptation result. Simulation, scaling, and generalization. On the 50-task RoboTwin comparison, action-only and full-joint Flex-π both average 94.6% across clean and randomized evaluations. The benchmark appears close to saturation at full data, so the more informative result is the scaling curve. With 50 demonstrations per task, Flex-π reaches 78.8%, versus 41.9% for Fast-WAM, 31.4% for π0.5, and 17.2% for LingBot-VA. At 100 demonstrations, Flex-π reaches 87.0%, retaining a substantial lead. On standard LIBERO, the flexible checkpoint obtains 98.4% in action-only mode and 98.5% with full joint generation. A version fine-tuned without stream dropout—therefore sacrificing flexibility for task fitting—reaches 98.7% action-only and 99.2% full joint, matching Qwen-RobotManip. These numbers are impressive but come from a heavily saturated benchmark without a conventional train-test task split. LIBERO-Plus is more sobering and therefore more informative. Under its seven categories of camera, robot, language, lighting, background, noise, and layout perturbation, flexible Flex-π scores 78.3% action-only and 80.9% full joint. That is stronger than Fast-WAM’s 65.3%, but below π0.5 at 84.7% and Qwen-RobotManip at 91.4%. The authors attribute this gap to the stronger VLM backbones and much larger robot pretraining corpora used by those systems. The overall picture is consequently more nuanced than “WAMs beat VLAs.” Flex-π is especially strong in data-limited, geometric, and physically precise settings. Strong VLM-based policies can retain an advantage under language and visual perturbations. A compelling future model may combine Flex-π’s predictive geometric supervision with a substantially stronger vision-language backbone. The ablations that matter most. The input-stream ablation provides the cleanest evidence for the multi-stream thesis. In a five-task, low-data RoboTwin setting, adding DINO features to RGB raises success by 6.8 points. Adding pointmaps on top of RGB and DINO provides another 20-point improvement. Explicit geometry is not merely a decorative visualization head; it makes a large contribution when demonstrations are scarce. The output ablation uses a single checkpoint with RGB-only input. Action-only inference obtains 40.2% success at roughly 60 milliseconds. Generating RGB futures as well raises success to 60.4%. Adding DINO and pointmap futures reaches 63.8% at approximately 193 milliseconds. This particular experiment is deliberately difficult and low-data, so its absolute numbers should not be compared with the full 50-task RoboTwin results. Its purpose is to show that one set of weights spans a 24-point success range and more than a threefold latency range. Cross-modality forcing is equally important. Removing it reduces success by 21 absolute points in the reported ablation—roughly a 47% relative improvement when forcing is restored. The gain is too large to explain only as robustness to a missing sensor. It suggests that making geometry, semantics, and appearance mutually predictable prevents the shared backbone from decomposing into weakly coupled modality-specific channels. These experiments support two separate claims. Multi-stream prediction produces a better policy even if visual futures are disabled at deployment. And, in demanding settings, allowing the action expert to consume those futures can provide another performance increment. Flex-π therefore validates Fast-WAM’s argument that much of world modeling’s value comes from training, while qualifying the stronger claim that test-time imagination is unnecessary. Sometimes it is unnecessary; sometimes it buys enough performance to justify the latency. How Flex-π fits into the WAM landscape. Unified World Models established an early version of the joint-diffusion idea: independent video and action diffusion processes inside one transformer could be configured as a policy, forward model, inverse model, or video generator. Flex-π narrows that flexibility toward deployment and broadens the predicted world representation from one visual modality to three. DreamZero represents the scaling route. It builds a 14-billion-parameter WAM on a pretrained video diffusion backbone, emphasizes heterogeneous data and cross-embodiment transfer, and reaches closed-loop operation through aggressive model and systems optimization. Flex-π is smaller and more task-fine-tuning-oriented, but its multi-stream design could in principle be applied to the same large-scale WAM recipe. LingBot-VA is architecturally close because it also combines video and action through a Mixture-of-Transformers design. LingBot-VA 2.0 takes a different response to the weakness of RGB-reconstruction VAEs: rather than adding separate DINO and pointmap prediction streams, it trains a semantic visual-action tokenizer and a video-action model from scratch for embodiment. Flex-π instead reuses an off-the-shelf video model and attaches complementary targets. The former seeks a better native tokenizer; the latter seeks more supervision around an existing one. Fast-WAM removes visual future prediction at test time while keeping video co-training. Flex-π generalizes that binary choice into a continuum. It can reproduce the action-only philosophy, run the traditional full-joint path, or occupy intermediate points. This is perhaps Flex-π’s clearest conceptual advance over prior WAMs: future generation becomes a budget that can be allocated per modality. PointWorld is the closest comparison on explicit geometry, but its objective is fundamentally different. PointWorld represents scene state and robot actions as 3D point flows and uses the learned dynamics model inside model-predictive control. Flex-π treats pointmaps as one predictive supervisory stream inside an imitation policy. PointWorld is closer to a controllable 3D simulator; Flex-π is closer to a geometry-regularized latent planner and action generator. ManiFlow, meanwhile, shows why simply providing 3D input is not the same as predicting 3D futures. It is a fast action-flow policy that can condition on RGB, language, proprioception, and geometric observations, using consistency training to reach one- or two-step action generation. Flex-π’s advantage over ManiFlow on the authors’ real tasks suggests that the future-prediction objective contributes something beyond access to depth at the present timestep. What a roboticist should take from it. The first practical lesson is that derived perceptual targets may be an inexpensive way to strengthen a WAM. A laboratory with RGB-only demonstrations does not necessarily need to recollect data with depth cameras. Pointmaps can be produced offline with a monocular geometry model, while DINO features can be cached. The expensive part is additional training and storage, not additional teleoperation. The second lesson is to distinguish training modalities, input modalities, and generated modalities. They need not be the same set. A pointmap can serve as a training target without being available as an input at deployment. DINO features can regularize the shared backbone even if the DINO encoder is later removed. Visual futures can be generated only for episodes or phases where their performance benefit exceeds their cost. The third lesson is that hybrid output modes deserve more attention. Most WAM papers compare only full imagination with no imagination. Flex-π suggests a more granular question: which future representation is useful for this control phase? Geometry might matter near insertion, DINO near object selection, and RGB during large articulated motion. An adaptive compute policy could learn to activate these streams based on contact phase, ensemble disagreement, or predicted failure risk. The fourth lesson is that generated futures can be useful even when never decoded. Flex-π’s actions consume latent RGB, DINO, and pointmap trajectories directly. Decoding is mainly a diagnostic tool. For deployment, this means the quality metric that matters is not photorealism but whether the latent trajectory supplies action-relevant information. Conventional video metrics may be poorly aligned with that purpose. Finally, Flex-π offers a general recipe beyond these exact three streams. Tactile images, optical flow, affordance maps, segmentation features, force trajectories, or occupancy predictions could be added as streams, then independently masked during training. The key requirement is not that every modality be present at runtime, but that the shared model learn to translate among them. Limitations and open questions. The phrase “free lunch” should not be read literally. Flex-π avoids training a geometry-specific VAE and does not mandate new sensors, but it still requires offline depth annotation, DINO extraction, additional storage, more prediction heads, and longer optimization. Full joint generation triples reported latency relative to action-only mode. The real contribution is avoiding a compulsory inference cost, not eliminating cost altogether. The visual future is not conditioned on proposed actions, limiting counterfactual planning. If the goal is to compare multiple candidate action sequences under one learned dynamics model, Flex-π’s directed attention pattern does not provide that interface. Adding action-to-world conditioning without destabilizing the latent-plan behavior would be an important extension. The geometry representation remains camera-centric and temporally short. There is no persistent global map, no explicit multi-view consistency loss, and no temporal observation history. Each real-robot chunk is conditioned on one observation and then executed open-loop for just over a second. Long-horizon success therefore comes from repeated chunk-level replanning and the learned task prior, not a recurrent belief state. The strongest simulation benchmark is close to saturation, while the more difficult LIBERO-Plus benchmark still favors the strongest VLM-based baselines. This suggests that predictive geometry and semantics do not replace broad language grounding. They solve a different part of the generalization problem. The real-world study is compelling but remains relatively small: ten to twenty trials per task, human partial-credit scoring, one bimanual platform, and task-specific fine-tuning datasets containing hundreds of episodes. The hardest task also uses DAgger corrections. Broader multi-embodiment evaluation would be needed to establish whether the canonical action representation and multi-stream pretraining transfer as cleanly as the architecture suggests. Reproducibility is another immediate limitation. As of August 12, 2026, the public repository contains the release announcement but not the promised training code, inference code, pretrained weights, or checkpoints. The authors state that these are being cleaned up for release. Until they appear, reproducing the custom attention masks, multi-stream adapters, and optimized deployment stack requires substantial independent implementation. The bottom line. Flex-π’s headline is that one WAM predicts RGB, DINO features, pointmaps, and actions. Its deeper contribution is the separation of what the model learns to predict from what it must compute when deployed. That separation creates a useful new abstraction for embodied models. Rich world prediction can be a training signal, an optional inference tool, or both. Geometry can be learned from offline labels without becoming a permanent sensor dependency. Semantic and spatial futures can act as latent plans without being decoded. And one checkpoint can move along the speed-performance frontier without distillation or retraining. The results suggest that RGB-only world-action modeling leaves useful supervision on the table. More importantly, Flex-π shows that exploiting richer supervision does not have to lock a robot into maximum-compute inference forever. For practitioners, that may be the most durable idea in the paper: train the robot to imagine more than it will usually need—and let deployment decide how much of that imagination to use.