VLA robot policies gain world-model grounding at no runtime cost

Vision-Language-Action (VLA) models, the systems that map a robot's camera feed and language instructions directly to motor actions, are trained with no objective that accounts for how the physical world responds to those actions. Because of that gap, the authors argue, a VLA's robustness is bounded mainly by how much training data it has seen rather than by any grounding in physics. World models, the class of systems trained to predict how a scene evolves, carry exactly that missing objective and are better grounded because of it. The catch is that rolling a world model's prediction forward costs seconds per decision, far too slow for a robot's real-time control loop.

The paper's central claim is that grounding and generation can be separated. What a world model has learned about physical scenes lives in its internal features; producing the future frame by frame is merely the training objective that shaped those features, so a policy can inherit the grounding while leaving the generative machinery behind. The method adds a single feature-alignment term to ordinary VLA training: a frozen world model is run once over the training frames and its outputs are cached, and the student policy is trained to match that cache. No teacher model is loaded during training beyond building the cache, the alignment projector is discarded afterward, and the deployed policy is architecturally identical to a standard, undistilled VLA: it runs in 32 ms and uses 1.86 GB of memory on a consumer RTX 5090 GPU. Because the deployed network itself does not change, the authors attribute any performance gain to the learned representation rather than to added model capacity or extra test-time computation.

In evaluation, a compact 0.8B-parameter student policy trained this way reaches 97.9% success on the LIBERO benchmark and improves from 48.2% to 50.5% on RoboCasa-GR1, a humanoid manipulation benchmark, compared with the same policy trained without the alignment term. The same objective also carries over to real robot hardware, tested on both a single-arm and a bimanual platform, though the source text does not give numeric results for those real-hardware trials beyond stating that the gain 'carries over.' The authors report that the improvement holds up when they vary the student model's scale, its backbone architecture, which layer the alignment is applied to, and which world model serves as the teacher, which they take as evidence of a broad, transferable representational prior rather than a narrow quirk tying two specific networks together.

Key facts

A single feature-alignment term added to VLA training lets a robot policy inherit a frozen world model's grounding without running that world model at deployment.
A 0.8B-parameter student policy trained this way reaches 97.9% success on the LIBERO benchmark.
The same method improves RoboCasa-GR1 humanoid manipulation performance from 48.2% to 50.5%.
The deployed policy runs in 32 ms and uses 1.86 GB of memory on a consumer RTX 5090, identical to an undistilled baseline of the same architecture.
Gains reproduce across changes in student scale, backbone, alignment layer and choice of teacher world model, and carry over to real single-arm and bimanual robot hardware.

Why it matters

VLA models are trained purely to map observations to actions, with no term that accounts for how the physical world reacts, so their robustness depends mostly on how much data they have seen. World models supply exactly that missing grounding but are too slow, at seconds per decision, to sit inside a robot's control loop. This work shows a policy can absorb a world model's grounding through one added training term without ever running the world model at deployment, so a robot gets better physical grounding without giving up real-time control.

Who it affects

Researchers and engineers building Vision-Language-Action policies for robot arms and humanoid manipulation. The change lands in the training pipeline, not in the deployed model's architecture or size: the resulting policy is the same shape as a standard VLA and needs no extra hardware to run.

How to use it

The method adds one feature-alignment loss during training: a frozen world model is run once over the training frames, its outputs are cached, and the student policy learns to match that cache. Nothing about the deployed model changes, no teacher network is loaded at runtime, and the alignment projector used during training is discarded afterward. The resulting policy runs in 32 ms and needs 1.86 GB of memory on a consumer RTX 5090, matching an ordinary undistilled baseline. A project page is available at https://thaw-vla.trung-dt.com/.

How solid is it

The gains are shown on two simulation benchmarks, LIBERO (97.9% for the 0.8B student) and RoboCasa-GR1 humanoid manipulation (48.2% to 50.5%), and the authors say the same objective carries over to real single-arm and bimanual robot hardware, though the available text gives no numeric results for those real-hardware trials. The authors report the improvement survives changes to student model scale, backbone architecture, the layer at which alignment is applied, and the choice of teacher world model, which they offer as evidence of a general representational prior rather than a fragile pairing between two specific networks.

Risks and caveats

The paper does not name the world model used as teacher or describe how it was trained, and it gives no numbers for the real-hardware trials, only the general claim that the objective carries over. No author names, institutional affiliations or publication date appear in the available text, and there is no comparison against other distillation methods or prior VLA baselines beyond the undistilled-baseline contrast, so independent replication or third-party benchmarking cannot yet be assessed from this material alone.

“The deployed policy is identical to the undistilled baseline, running in 32 ms and 1.86 GB on a consumer RTX 5090, so every gain is attributable to the representation rather than to added capacity or test-time compute.”

— the paper's authors