Latest / Embodied AI 101 / mimic-video: Video-Action Models for Robot Learning
Transcript
- mimic-video: Video-Action Models for Robot Learning. The dominant paradigm in recent years has been to treat robotic control as a Vision-Language-Action (VLA) problem: train a policy end-to-end to map observations (images and sometimes language commands) to actions, typically using massive pretrained vision–language backbones. However, these backbones are themselves trained on large, static image datasets (for example, CLIP or visual transformers on internet pictures). The VLA approach therefore relies on the robot policy to infer the physics of the world – often very complex dynamics – from nothing more than example trajectories it has seen. As Pai et al. note, “Vision-Language-Action Models (VLAs) for robotic manipulation are built upon vision–language backbones pretrained on large-scale, but disconnected, static web data. As a result… the policy must implicitly infer complex physical dynamics and temporal dependencies solely from robot trajectories”. In practice this means that the system has to repeatedly re-learn everyday physics from scratch. The team argues this is unsustainable: without an inherent sense of causality, the VLA “creates an unsustainable data burden, necessitating continuous, large-scale expert data collection… to compensate for the lack of innate physical understanding”. In short, VLAs can learn what needs to be done (semantics) but not how the world behaves when you do it. The mimic-video approach (dubbed a Video-Action Model, or VAM) takes a radically different tack. Instead of leaning on static image models, it builds directly on a pretrained video foundation model – one that has seen millions of internet videos and thus carries rich priors about visual dynamics. In particular, the authors ground the robot’s policy in an off-the-shelf video prediction/generation model (Nvidia’s Cosmos-Predict2) and attach a small action decoder on top. The video model produces an imagined future video (a latent “plan”), and the action decoder (an inverse-dynamics network) learns to realize that plan in terms of robot controls. In effect, the model separates the “what happens if” (imagine the future) from the “what do I do” (execute actions), letting the large pretrained network handle world physics. As the authors put it, vision-language pretraining “remains blind to physical causality,” and a better paradigm is to use video pretraining “to jointly capture semantics and visual dynamics” so that the remaining task is mainly low-level control. The result is dramatic: in both simulation and real-world tests, mimic-video (their VAM) matches or exceeds state-of-the-art performance with roughly 10× less training data than a comparable VLA approach, and converges about 2× faster. In one simulated benchmark, they can drop almost all but one expert trajectory and still solve tasks 77% of the time, where traditional methods fail completely. On a real bimanual pick-and-place setup, mimic-video learned to sort packages and stow measuring tape much more efficiently than a standard diffusion-policy baseline, despite using the exact same small action datasets. In short, grounding the policy in a video world-model “isolate[s] the remaining task of low-level control” and shifts most of the heavy lifting – semantics and physics – into the pretrained network. In this post, we’ll unpack how Video-Action Models work, why they offer such a leap in efficiency, and what it means for future robot learning. We assume familiarity with modern approaches like diffusion policies, inverse dynamics, large pretraining, etc., and will stress intuitions and implications rather than mathematical details. Vision-Language-Action Models: Semantics without Physics. Let’s set the stage by recalling how traditional “vision-language-action” systems operate. In a typical VLA pipeline, you have a vision-language backbone (for example, a ViT or CLIP model, possibly with a language encoder for instructions). You fine-tune or attach a small action module on top of this to predict the robot’s next control outputs. During pretraining, the backbone learns from web-scale image-text pairs, capturing a wealth of semantic information (object names, affordances, scene categories, etc.). But crucially, the backbone has never seen a moving video – only static shots. It has never been trained to predict inertia, friction, how objects move when pushed, etc. It learns that a can is food, or that “mustard” is something on a table, but not how to pick it up, or how it responds to being grasped. When you then train the VLA on robot data, the system must discover all the physical rules from scratch by observing examples. If it sees a trajectory of a robot arm pressing forward, then gripper closing, then object lifting, it has to implicitly encode the underlying dynamics in its weights. This is a really tough learning problem. Indeed, Pai et al. point out that the standard VLA approach leads to a heavy dependence on large, task-specific datasets: because the model didn’t know the physics ahead of time, it needs reams of demonstrations to catch up. The authors write that this reliance creates “an unsustainable data burden” due to “the lack of innate physical understanding” in the backbone. This concern has motivated several recent innovations. For example, the “FAST” tokenization method by Pertsch et al. (2025) gives a more compact way to discretize continuous actions for sequence models, making high-DOF tasks tractable. Others have introduced techniques like knowledge-insulation, which change how you train the action head so that you don’t overwrite the semantic knowledge in the visual backbone. (Intuitively, knowledge-insulation means you try to shield or decouple the pretrained vision features from the new random parameters of the controller, so the vision model’s world-knowledge isn’t “wiped out” by the finetuning.) In fact, recent work from the same team notes that naively adding continuous action layers to a large VLM can “significantly harm both training speed and knowledge transfer,” and proposes insulating the vision model from the action module to mitigate that. But even with all these improvements, the VLA approach still wars with the fundamental problem: the entire dynamics model must be learned through the slow slog of robot data. Contrast this with the new idea of Video-Action Models (VAMs). A video foundation model, by definition, has seen moving scenes and learned to simulate future frames. Even without robotics data, a model like Cosmos-Predict2 has internalized many physical regularities – e.g. how objects drop when gravity acts, how jars open, how scenes change when something moves. The authors’ key insight is to ground the policy in this knowledge: rather than asking the model to infer dynamics from scratch, let it explain them, and just learn the final step. Concretely, mimic-video wraps a large pretrained video generation model (Cosmos-Predict2) around the robot’s perception. Given the current camera view (and possibly a task goal), the video model can be run to produce an imagined future sequence. This latent video plan captures what should happen in the next few moments in terms of visual change. Then, a smaller “action decoder” network treats that latent plan as a target and figures out the motor commands needed to achieve it (essentially an inverse dynamics). During training, the system simply learns from a handful of real trajectories: for each chunk of an episode, the video backbone imagines what happens, and the action decoder is trained (via conditional generative training) to map from the starting state plus that imagined video, to the actual next actions taken by the expert. In other words, the heavy lifting of “what happens next” is handled by the frozen (or lightly finetuned) video model. The lightweight policy only needs to learn “how do I make that happen in reality.” Once trained, at test time the robot can actually follow the video plan. This clean separation means the robot essentially inherits years of internet-scale learning about physics, which vastly reduces how much it must learn itself. As Pai et al. describe, this approach allows decoupling “semantics + visual dynamics (learned by the video model)” from “control”, yielding greater sample efficiency. Summarizing: VLAs attempt to learn both world understanding and control simultaneously from robot data, even though their pretrained anchor knows nothing about time. VAMs buy in pretrained physics and semantics upfront, reducing the problem to inverse control. This fresh paradigm – grounding policies in video prediction – is the crux of mimic-video’s contribution. Cosmos-Predict2: A World Model Backbone. The core “backbone” in this approach is Nvidia’s Cosmos-Predict2 (the authors specifically used the 2B and possibly 14B variants). Cosmos-Predict2 is part of Nvidia’s Cosmos Lab world model project (which includes image and video generation components). Unlike CLIP or other vision models, Cosmos-Predict2 is explicitly trained to simulate the future state of a scene as video. In its own description, Nvidia calls it “the latest version of the Cosmos world model, designed for simulating and predicting the future state of the world as video”. It has two major capabilities: text-to-image (making single images from text prompts) and “video-to-world” (given an initial video or frames, generate a video that predicts the future). In practice this means it’s learned a rich spatiotemporal prior over physics: it knows that gravity pulls objects downward, rigid bodies move smoothly, collaborative tasks (like one arm stacking blocks) have predictable temporal structure, and so on. For example, in the Cosmos-Predict2 demo benchmark, the model convincingly handled lab scenes with multiple robot arms and objects. One showcased case had a yellow bottle on a tray: the model correctly predicted a robotic arm reaching out, grasping the bottle, and placing it on a base. The generated video carried dynamic details like the motion of the arm and the bottle’s translation, without any explicit physics code. Such behavior hints that large video models indeed capture causal dynamics, not just static semantics. (Nvidia’s own evaluation table even gave Cosmos-Predict2 better “domain score” and “quality score” than its predecessor, meaning it learned to model these physical scenes at scale.). It’s worth noting that Cosmos-Predict2 is huge (billions of parameters) and trained on massive data. In principle, any sufficiently powerful video-prediction model could serve as the backbone. The authors chose Cosmos-Predict2 likely because it’s expressly aimed at physical scenes (“Physical AI”) and easily accessible. When mimic-video was trained for actual robot tasks, they fine-tuned the video backbone on videos of their environment. In the real-world demo, they captured video snippets of a Franka Panda robot with hands performing the tasks and used that to adapt Cosmos’s outputs to the specific setup. However, because the model starts with such broad knowledge, it only needed a light tuning. The fine-tuning ensures the latent plans align better with the actual robot’s visual context (e.g. specific object appearances or lighting), but the core physics understanding already comes baked-in. Because Cosmos-Predict2 is diffusion-based (using latent diffusion to generate frames), the authors had to adapt it into a controller. They did this with a clever “partial denoising” trick. A standard diffusion model gradually transforms noise into a coherent image through many small steps; intermediate layers contain partly denoised detail. For a video diffusion, at some intermediate time τ_v you have a latent representation of a plausible future scene, but not the final crisp video. The mimic-video pipeline runs the video model partway down the diffusion path – enough to extract a plan without fully sampling every frame. These halfway-denoised latents (for the entire planned sequence) serve as the features of the predicted video. They still encode the high-level structure of “what will happen” (like “the arm is moving forward”) but are computationally light to handle, since we don’t decode them to full RGB frames yet. Intuitively, this “latent video plan” is the bridge between vision and action. From Latent Plans to Actions. Once the video model has produced a latent summary of the future (at the designated partial noise level), the job falls to a second component: the action decoder, also called an inverse dynamics model (IDM). This is essentially a network that looks at the current robot state (joint positions, velocities, maybe object poses) and the latent video plan, and outputs the sequence of low-level actions needed to cause the world to follow that video plan. In other words, it tries to invert the world model. Training this network is analogous to imitation learning, but formulated as a conditional generative model. The authors train the action decoder using Conditional Flow Matching (CFM), a diffusion-like generative technique. Without getting into all the math, flow matching is an alternative to standard diffusion training that encourages the model to learn the “flow” of probability from noise to data. Concretely, the action decoder is trained on the same demonstration trajectories used for a regular control policy: the inputs are (state, latent-plan, target state change or final state) and the outputs are the true actions taken by the expert. Over many trajectories, the decoder learns a stochastic mapping: given a state and a desired latent outcome, it outputs the distribution of actions that realize that outcome. Because it’s flow-based, sampling actions at test time also happens by gradually denoising, but with a dedicated schedule (denoted τ_a) independent from the video model’s schedule τ_v. A key detail is that the video backbone and the action decoder have separate diffusion schedules. That is, we decide at which noise level τ_v to stop the video model, and separately at which level (τ_a) to run/stop the action model, during training and inference. The video model might run only partially (large τ_v, meaning lots of noise still in it) to get coarse plans, whereas the action model might go (by design) down to low noise to accurately reproduce the discrete actions. By decoupling these, the system can be optimized modality by modality: the video model focuses on generating plausible trajectories (and can stay relatively noisy and abstract), while the action model focuses on fine detail control. Altogether, the rollout works like this: at each planning step, the system captures the current scene and any language goal. The pretrained video model is seeded with the current image (and possibly a language prompt if used) and run forward partially to produce a latent predicted sequence of future frames (the “plan”). Then the action decoder, conditioned on that latent plan and the robot’s initial proprioceptive state, generates a sequence of actions. These actions are executed open-loop for a short chunk of time. After execution, the process repeats: the robot observes the new state, the video model imagines the next chunk of future, and the controller does it. The authors emphasize that the video generation happens before executing the actions. The controller uses the latent plan as a kind of subgoal: “Make the next few frames look like this predicted sequence.” Importantly, the video frames themselves are not fed back frame-by-frame to the robot (that would be an explicit tracking loop). Rather, the latent is a chunk-level target. (For real-time execution they only use the latent – generation to actual pixels is done afterward just for visualization of the plan.). In training, both parts go through imitation: the video model is fine-tuned on videos of the task trajectories, and the action decoder is trained on the matching action sequences. However, note a core advantage: the video model already knows about general physical dynamics. It doesn’t need to learn from scratch that “pushing tends to move things.” So training of the controller can happen with far fewer demonstrations. The action module must still learn the specific kinematics and dynamics of the robot (for instance, how joint torques map to object motion in its grippers), but only in the context of already-planned motions. It’s effectively learning an inverse physical model, but aided by a very good guess of what the result should look like. The high-level design can be summarized:. Video-Action Model (VAM): Pair a large pretrained video generator (the world model) with a small action decoder (the inverse model). The video model imagines plausible future scenes (given the task), and the action decoder learns to mimic or “ground” those imaginations into real motor commands. Real-World Bimanual Manipulation. One of the most striking claims in the paper is how well VAM works in the real world, with dramatically better sample efficiency than conventional methods. The team built a physical robot rig with two Franka Panda arms equipped with 16-DOF anthropomorphic hands (the “mimic” hands) – essentially a very flexible bimanual manipulator. They defined two tasks:. Package sorting: the robot must pick up items (like small boxes or packages) from a bin and place them into a designated container. Tape stowing: the robot must pick up a measuring tape (a curved object), unfold or orient it if needed, and stow it into a box. Both tasks require fine control of the hands and careful coordinate control between arms. Think of it as a mini-warehouse scenario (package sorting) and a more delicate object-oriented task (tape stowing). The authors collected a small “expert” dataset for each task: a few human or scripted demonstrations (on the order of dozens of hand-labeled trajectories). For each chunk of action, they recorded the video of the scene and the corresponding robot states and actions. This became the training data. The action sequences involve multiple steps (reaching, grasping, moving, etc.), and are chunked into short segments for training the flow-based model. They trained both mimic-video (VAM) and a standard diffusion-policy baseline on these demos. The baseline here is essentially a recent architecture that directly predicts actions via diffusion, all conditioned on the image input (and possibly language). It is single-task and trained on exactly the same limited data. Critically, both methods train their action components from scratch on the same small data. The difference is: mimic-video additionally fine-tunes (to a small extent) the video model on those same videos, whereas the baseline uses no pretrained video knowledge beyond perhaps a fixed vision encoder. In the authors’ words, “While mimic-video fine-tunes the video model backbone with task video, both methods train their action decoders from scratch with the same small dataset of low-dimensional robot actions”. On these tasks, mimic-video clearly won. The robot was able to execute the learned policies autonomously: in each action chunk, the model generated a latent video plan partway, followed by executing the resulting actions. The paper provides visualization frames: the predicted videos (fully denoised after execution), and side-by-side images of mimic-video in action versus the diffusion baseline. Although we cannot embed the video here, the description is telling. In the package sorting task, mimic-video produced seamless plans and succeeded in grasping and placing objects. The DP baseline often faltered mid action (likely dropping objects or missing the grasp). In tape stowing, which is quite tricky, mimic-video again planned the sequence of openings and placements and succeeded, whereas the baseline struggled to even pick up the tape reliably. Quantitatively, the success-rate gap was huge. The authors report (in the extended results) that mimic-video achieved high success in both tasks, whereas the DP baseline significantly underperformed. Even more impressively, mimic-video required dramatically fewer attempts (samples) to get there. Whereas diffusion-policy needed many repeated trials and often reinforcement fine-tuning, the video model leapfrogged those needs. This real-world comparison highlights the core point: by letting the video model guide the motions, even when data is scarce, the robot performs the tasks with high reliability. The standard baseline, by contrast, had to essentially re-learn aspects of the task from the raw demos and could not generalize as well. Both were using about the same number of action trajectories, but one had the visual imagination privilege. Simulation Benchmarks: SIMPLER and LIBERO. To show that these gains were not just flukes of hardware, the authors also tested mimic-video in simulation settings. They chose two modern benchmarks:. SIMPLER: A suite of simulated tasks (from different robot platforms) designed to correlate well with real robots. It includes tasks like “open drawer”, “move apple”, etc., mirroring real setups. Policies that do well in SIMPLER tend to do well on hardware, making it a credible proxy. LIBERO: A benchmark focused on lifelong learning, with 100 tasks divided into suites (spatial reasoning, object manipulation, goal changing, etc.). The idea is to test how well a robot can transfer knowledge across a curriculum of tasks. The mimic-video paper specifically evaluated on the LIBERO-Long and -90 suites (multi-step tasks of varying complexity). In these sims, they again compared mimic-video against a “traditional VLA” baseline. This baseline is basically the kind of model from earlier VLA papers, except updated with the latest improvements: it uses the FAST action tokenization and knowledge-insulation techniques to give it the best shot. In other words, they gave the VLA baseline all the bells and whistles except the video backbone. This isolates the benefit of using video pretraining. The results were consistent: the VAM drastically outperformed. On LIBERO, for example, mimic-video needed 10× less data to achieve similar success. Figure 5 in the paper (reproduced below) shows that for a given number of demonstration episodes, the VAM’s success curve always sits far above the VLA baseline. When the dataset is shrunk to a mere 2% of the usual actions (one episode per task), the VAM still solves about 77% of the tasks, whereas the VLA baseline basically collapses to near 0%. In other words, the baseline can’t make headway with so little data, but mimic-video manages the majority of tasks even in that extreme low-data regime. Moreover, mimic-video reaches its peak success in roughly half the training iterations – it “converges twice as fast”. The pattern is the same on SIMPLER, though the paper figures emphasize LIBERO. In summary, replacing the vision encoder with a video model let the policy learn far more quickly. Crucially, this isn’t because the video model magically skips imitation learning – the action decoder still had to be trained. Rather, the video backbone is simply providing vastly richer predictive signals. The authors point out that the underlying task effectively becomes one of matching a visual prediction, so the quality of that prediction effectively sets an upper bound on performance. They support this claim with an enlightening ablation. They ran the action decoder with perfect video inputs: first using the ground-truth future video (the actual future frames from the demonstration), and second using the predicted video from either the pretrained or finetuned cosmos model. The result: with ground truth video inputs, the policy was nearly flawless. In the authors’ words, “The near-perfect performance with ground truth inputs confirms that control effectively reduces to visual prediction…”. In other words, if the system knows exactly how the scene will evolve (which is what ground truth provides), then outputting the correct actions is trivial. The environment part is solved; you only need the inverse mapping. This experiment shows that almost all the remaining challenge is in the video prediction quality. The predicted videos (from Cosmos) achieved good but not perfect success, matching how “good” the model’s imagination was. And finetuning the video model on domain-specific data improves that further. The takeaway is compelling: make the video model better, and the robot gets that much better. The VAM essentially offloads policy performance onto the video model’s shoulders. If the video backbone can foresee the experiment, the downstream control module just follows suit. It’s a divide-and-conquer strategy, turning a huge joint learning problem into two smaller ones: learn realistic video prediction (mostly offline from Internet data) and learn the inverse dynamics (from a little bit of robot data). Why Does This Matter?. Taken together, mimic-video suggests a new direction for embodied AI. Instead of (or in addition to) loading up robots with ever-larger image-language models or training massive end-to-end RL, we can leverage world models learned from video data. This resonates with a growing intuition in the community that making machines truly “understand” the physical world requires moving beyond static text or images. (After all, when humans learn physics, we lean on motion and contact cues – kids learn gravity by watching things fall, not by seeing a still image of an apple and a ground.). Video-Action Models essentially bring that intuition to robot learning at scale. They remind us that general-purpose video datasets (even uncurated internet videos) capture a form of physical reasoning. By plugging that into a robot policy, we bootstrap a massive amount of common-sense knowledge. It’s akin to how large language models let agents know a lot of world facts; here, video models let robots know a lot of world dynamics. The results speak volumes: sample efficiency skyrocketed. This has practical implications for robotics: data collection on physical robots is expensive and slow. If a policy can learn in minutes of demonstration rather than millions of steps of trial, it becomes much more feasible to deploy new skills. For instance, one could imagine fine-tuning a video model on a handful of videos of a new assembly scenario, then teaching a robot to do it with minimal demo. The barrier between simulation training and real-world deployment shrinks, because the video model acts as a virtual world. It also opens the door to modular architectures: one could combine a video-actor VAM with a language model or symbolic planner up top to handle high-level goals. For example, an LLM could translate a new high-level instruction (e.g. “pack the banana into a smaller box”) into a sequence of intermediate visual goals or affordances, which the VAM could then plan and execute. In fact, since Cosmos-Predict2 itself supports text-to-video, one could even feed it a text prompt describing the task (e.g. “robot places tape in box”) and let the video model include that signal. The current mimic-video work didn’t explore that, but it seems like a natural extension: you have an internet-scale video model that likely knows the semantic meaning of the goal phrases as well as the visuals. From a learning standpoint, mimic-video is effectively doing one-shot or few-shot learning of control by reusing pretraining. It’s reminiscent of “one-shot imitation” ideas, except the “imitation” is of the video model’s imagined demonstrations, not just copying the human. So it is a blend of imitation and model-based planning: the video model is a learned “simulator,” and the control piece is like running a model-based plan with learned dynamics. It also connects to “world models” research: in model-based RL (e.g. latent-space planning), a learned model predicts future states and a separate planner chooses actions. Here, the video model (Cosmos) is the world model (very big and pretrained), and the action decoder is the planner. Notably, a parallel development called Cosmos Policy arrived at a similar idea independently. That work (Kim et al., ICLR 2026) fine-tunes Cosmos-Predict2 on robot data such that the model itself directly generates actions as special “latent frames” of video. In Cosmos Policy, the network output includes not only future scene images but also an encoding of the action sequence. Conceptually it’s doing a similar thing but by “bending” the video model to also produce action codes. In contrast, mimic-video attaches a separate action head. Both approaches leverage the same insight: large video models can be harnessed for control. It’s encouraging that independent teams reached this conclusion, underscoring the potential of video-based approaches. Limitations and Future Directions. Of course, this demo is early work and has its limits. First, the current system was tested on a few tasks in a fairly controlled environment. Real kitchens, factories or homes have much wider variation. The video model (Cosmos-Predict2) was trained on a broad range of videos, but it may still stumble on truly novel physics or highly domain-specific objects. Some fine-tuning on carefully collected videos helped, but one can imagine tasks where collecting even video demonstrations is nontrivial. For truly open-ended problems, one might need to continually fine-tune or integrate real-time feedback. Second, computational cost is high. Streaming a huge diffusion model (Cosmos-14B) for video prediction is no small matter. Inference time could be slow, and deploying this on a mobile robot might require serious hardware. The authors mitigate this by only partially denoising (so fewer steps) and by forming action chunks (not planning frame-by-frame). But still, latency vs responsiveness is an issue. For tasks requiring millisecond reaction, a diffusion backbone may not be suitable. That said, many assembly or pick-and-place tasks are relatively slow-moving, so it may be fine. Third, the current experiments didn’t explicitly incorporate language instructions, even though VLAs often do. The architecture can support it (Cosmos has text inputs), and it would be interesting to see if a text command could be used to modulate the video plan. In a sense, the W instruction is not needed for fixed tasks, but for generalization, an LLM-to-video-to-actions pipeline could be powerful. Future work might integrate language prompting so that VAMs become true vision-language-action models with video backbones. Finally, there’s the question of emergence. The video prediction horizon may not match the task horizon. Mimic-video handles that by re-planning in chunks: after executing a chunk of actions, it re-observes and generates a new plan from the updated scene. This receding-horizon approach worked for the experiments. But for extremely long-horizon tasks (e.g. “set the entire table”), one must chain many plans, and errors can compound. Techniques like hierarchical planning or reward-conditioned generation might help here. Overall, though, mimic-video shows a compelling new recipe: Pretrain a vision model on video, then learn to map its imaginations into reality. The sample-efficiency gains are reminiscent of how language models leapfrogged NLP – now we might see similar leaps in embodied AI via video models. It remains to see how far this can go (e.g. to mobile robots, outdoor tasks, deformable objects, etc.), but it opens an exciting avenue. References. The key ideas behind Video-Action Models are introduced in mimic-video: Video-Action Models for Generalizable Robot Control Beyond VLAs by Pai et al. (Dec 2025). We have drawn extensively from their project website and preprint. The revision of Vision-Language-Action approaches and their limitations is discussed in the same abstract, e.g. “VLM pretraining is blind to physical causality” and the incurred “unsustainable data burden”. Nvidia’s Cosmos-Predict2 model (used here) is detailed in their lab report; it is designed to predict future video frames given current scenes. The Diffusion Policy baseline is described by Chi et al. (2024) (generating actions via a denoising diffusion process). In mimic-video, a standard single-task version of this is used for real robot comparisons. The SIMPLER benchmark and its sim-vs-real correlation is documented by Li et al. (2024). The LIBERO lifelong learning benchmark details are given in its docs. A parallel approach, Cosmos Policy (Kim et al., ICLR 2026) also fine-tunes the same video model for control; we mention it to highlight concurrent thinking. Our analysis of these results is built on the cited sources, including quotes directly from Pai et al.’s abstract and project site.