VLA-∆: Learning Physical State Transition for Vision-Language-Action Models

Qi Lu, Jiarun Li, Ce Zhang, Miao Pan, Yi Pan, Xu Wang, Wenqi Zhang, Xuhong Zhang

VLA-∆ improves robot control by explicitly supervising physical state transitions during pretraining.

How can we improve robot control by explicitly modeling the physical state changes between current and future observations, rather than just mapping inputs directly to actions?

Vision-language-action (VLA) models often fail to grasp physical dynamics, frequently replaying memorized trajectories rather than responding to evolving scenes because they lack explicit supervision of intermediate state changes. VLA-∆ addresses this by introducing learnable Physical State Difference Queries that encode task semantics and visual motion as explicit learning targets during pretraining. This approach achieves a 98.4% success rate on the LIBERO benchmark and outperforms existing state-of-the-art models in real-robot experiments.

Paper Primer

Most VLA models map observations directly to actions, which leads to overfitting on observation-action pairs rather than learning the underlying physical dynamics. For example, a robot might continue moving toward a placement location even after a failed grasp because it lacks a grounded understanding of how the object's state—such as its contact status—should have changed.

VLA-∆ integrates learnable Physical State Difference Queries into the vision-language backbone to create a unified transition representation. The model uses a three-pronged supervision strategy: structured slots for spatial and contact variables, optical flow for dense motion details, and autoregressive text generation for coherent task-progress descriptions.

VLA-∆ achieves superior performance on standard manipulation benchmarks.

Success rates on the LIBERO benchmark and RoboTwin 2.0 platform. 98.4% success rate on LIBERO; outperforms $\pi\$0.5 by 5.5% in real-robot trials.

Crucially, the intermediate supervision signals (slots, flow, and text) are used only during pretraining. During downstream fine-tuning and deployment, the model relies solely on the action-learning objective, ensuring no additional inference overhead.

Why is explicit supervision of physical state transitions necessary if the model already learns from large-scale demonstrations?

Standard action-only supervision often fails to capture the causal relationship between physical changes (like contact or spatial displacement) and the required action, causing the model to overfit to visual appearance rather than the evolving physical state of the environment.

How does this approach differ from existing "reasoning" or "world model" VLAs?

Unlike reasoning models that focus on high-level task planning or world models that reconstruct future images, VLA-∆ explicitly supervises the physical state transition itself—the specific changes in object poses, spatial relations, and contact states that directly dictate the necessary robot actions.

The model assumes that physical state transitions—defined as the change between current and future states—are the primary drivers of successful manipulation, and that these can be effectively decomposed into semantic, spatial, and motion-based supervision signals.

By explicitly modeling physical state transitions during pretraining, VLA-∆ provides a more robust representational foundation for continuous control, allowing policies to generalize better to complex, multi-stage manipulation tasks.

Motivation and Problem Framing

We expose why directly mapping observations to actions leaves VLA policies blind to physical dynamics.

Vision‑language‑action (VLA) models leverage pretrained vision‑language backbones to map visual observations and language instructions to robot actions, achieving strong benchmark performance. However, most VLAs follow a direct‑mapping paradigm: they predict actions from the current observation without any explicit intermediate representation of how the physical world should evolve.

In the baseline setting the model receives the current image and instruction, encodes them with a VLM, and immediately outputs a motor command, never reasoning about intermediate physical changes.

Prior work attempts to inject intermediate reasoning: Reasoning VLAs generate task plans in language, World Action Models (WAMs) predict future images, and Latent‑WAMs forecast future latent visual states. Yet these approaches either focus on high‑level semantics or on visual appearance, never supervising the concrete physical changes—object poses, contacts, and motions—that directly dictate the required actions.

**Figure 1.** Comparison of transition modeling paradigms in vision–language–action policies. (a) Direct VLA maps observations and instructions directly to actions. (b) Reasoning VLA describes task plans and subgoals in language space. (c) WAM predicts future visual states, while (d) Latent-WAM predicts future latent representations. (e) VLA-$\Delta$ models physical state changes through multilevel supervision.

VLA‑$\Delta$ addresses the identified gap by learning a unified transition representation conditioned on current observations and instructions. This representation is shaped by three complementary supervision signals: Structured Transition Slots encode discrete variables such as positions and contacts; Optical Flow supplies dense motion cues; and Future‑State Difference Text supplies autoregressive semantic descriptions of the transition.

The limitation of direct mapping is its inability to capture how physical states evolve, leading to brittle policies that cannot adapt to unexpected dynamics.

The VLA-∆ Architecture

Describes the VLA‑$\Delta$ mechanism that injects explicit physical state transitions into action generation.

Direct‑mapping VLA models struggle to capture intermediate physical changes, which makes action generation brittle. VLA‑$\Delta$ inserts an explicit transition layer that forces the model to reason about how the world moves before acting.

**Figure 2.** Overall architecture of VLA-$\Delta$. Given multi-view observations, a task instruction, and the robot state, the model jointly learns a physical state transition representation from Structured Transition Slots, Optical Flow, and Future-State Difference Text supervision, and uses these representations to condition continuous action generation. The right panel illustrates the attention-visibility constraints among the different information streams.

The framework treats the robot’s environment as a short‑term physical story: first it asks a set of dedicated questions (the queries), then it writes down the story (slots, flow, text), and finally it acts on that story.

How does the query representation differ from a standard attention query?

Standard queries are generated on‑the‑fly from the current token. Here $Q$ is a fixed set of learnable vectors that explicitly ask “what has changed physically?” and the backbone reads out their hidden states, so the model is forced to encode a physical delta rather than arbitrary token‑level context.

Think of each query as a dedicated sensor that probes the scene for a specific physical change, rather than a generic camera pixel that sees everything at once.

Concatenate $C_t$ and $Q$ → sequence length 4.

Pass through $F_\theta$ (a single linear layer for illustration) → hidden matrix $H\in\mathbb{R}^{4\times4}$.

Read out rows 3 and 4 (the query positions) → $Z_t=\begin{bmatrix}h_{3}\\h_{4}\end{bmatrix}$, each $h_i\in\mathbb{R}^4$.

Resulting $Z_t$ has shape $2\times4$, ready for the slot and flow heads.

The queries act as fixed “what‑changed” probes; their learned values directly become the physical transition representation used by all later modules.

Why can’t the model just attend to the raw observation tokens instead of using queries?

If the backbone attended directly to observation tokens, each downstream head could pull arbitrary information without any enforced physical abstraction. The queries force the model to compress the raw perception into a unified physical delta before any downstream prediction, which is essential for consistent action generation.

Slots act like labeled boxes that collect specific physical facts (e.g., “gripper position”) from the query representation, ensuring each box receives the right type of information.

Slot 1 head $h_{\text{slot}}$ applies a linear map to $z_1$ → $\hat{y}_1=0.45$ (estimated gripper height).

Slot 2 head applies its linear map to $z_2$ → $\hat{y}_2=0.78$ (estimated target distance).

Compute individual losses $L_1=(\hat{y}_1-y_1)^2$, $L_2=(\hat{y}_2-y_2)^2$ and combine as $L_{\text{slot}}=w_1L_1+w_2L_2$.

Even with only two queries, the model learns to separate gripper and target information, demonstrating the semantic division of labor enforced by the slots.

Do the slots simply copy the query vectors, or do they perform a transformation?

Each slot head applies a learned linear projection (and optional nonlinearity) to its assigned query vector, so the output $\hat{y}_i$ is a transformed version that matches the scale and semantics of the target variable.

Optical flow provides a fine‑grained motion map, like a high‑resolution wind‑speed chart that tells the model how pixels move between frames.

Why not replace the flow decoder with a standard optical‑flow network that operates on raw images?

Because the flow decoder reads only the query hidden states, it forces those states to embed motion information. A separate network on raw images would bypass the queries, breaking the unified transition representation that the rest of the pipeline relies on.

The model writes a short description of what will happen next, much like a planner’s “next step” note, grounding high‑level semantics in the same query representation.

Is the generated text merely a copy of the slot values, or does it contain additional information?

The text is generated autoregressively and can express relationships and temporal ordering that are not explicit in the slot vector outputs, providing complementary high‑level context.

Encode multi‑view observations $o_t$ and instruction $\ell$ into contextual sequence $C_t$.

Append learnable queries $Q$ and run the vision‑language backbone $F_\theta$ to obtain hidden states.

Read out query positions to form transition representation $Z_t$.

Predict structured variables $\hat{y}_t$ via slot heads and dense optical flow $\hat{U}_t$ via the flow decoder.

Autoregressively generate future‑state difference text $\hat{T}_t$ conditioned on $Z_t$.

Cross‑attend $Z_t$ with proprioceptive encoding $E_\eta(r_t)$ in the Action Expert and decode actions $\hat{A}_t$ with flow matching.

Training and Inference Procedures

Describes how transition text guides action generation and the training objectives linking them.

Direct mapping skips the intermediate physical state, leaving the action expert without explicit cues about how objects move or contacts change.

Instead of feeding raw state deltas, the model writes a short natural‑language description that jointly captures task progress, spatial motion, contact changes, and constraints.

Token 1: “Gripper opens” → matches $g=0$.

Token 2: “Apple at (0.6, 0.5)” → encodes the current bounding box.

Token 3: “Gripper closes” → reflects the change $g:0arrow1$.

Token 4: “Apple moves to (0.58, 0.39)” → encodes the spatial displacement.

Token 5: “Maintain grasp” → captures the contact constraint.

By grounding each token in a concrete numeric change, the model learns a one‑to‑one mapping between language and physical transition, which later serves as a clear conditioning signal for action generation.

Why not just feed the raw state vectors instead of generating a sentence?

Raw vectors are high‑dimensional and lack a shared semantic grounding across modalities. A short sentence abstracts the change into a modality‑agnostic cue that the language model can attend to directly, improving generalization to new tasks.

Given the transition text representation $Z_t$ and the robot’s proprioceptive encoding $E_\eta(r_t)$, the expert learns a vector field that maps noisy action samples back to the clean demonstration trajectory.

Compute $A_\tau = (1-0.4)\,[0.0,0.0] + 0.4\,[0.2,-0.1] = [0.08,-0.04]$.

Feed $A_\tau$, $Z_t$, and $E_\eta(r_t)$ to $v_\psi$; suppose it outputs $[0.075,-0.045]$.

Loss term $\|[0.075,-0.045] - v^\star\|^2$ drives the network toward the true field $v^\star=[0.08,-0.04]$.

During inference, start from $\xi$ and integrate $v_\psi$ over $\tau\in[0,1]$ to recover the full action chunk.

The example shows how a single noisy sample can be turned into a full trajectory by repeatedly applying the learned vector field, which is why flow matching yields smooth continuous actions.

How does this differ from standard behavior‑cloning that directly regresses actions?

Behavior‑cloning predicts a single deterministic action for each timestep, whereas flow matching learns a continuous vector field. This field can be queried at any intermediate time, giving the model flexibility to generate actions of arbitrary length and to handle stochasticity in the demonstration.

Pre‑train jointly on $L_{\text{Text}}$, $L_{\text{slot}}$, $L_{\text{flow}}$, and $L_{\text{act}}$ to learn both transition text and the flow‑matching policy.

During fine‑tuning on a downstream task, freeze the transition encoder and optimize only $L_{\text{act}}$ on the new demonstrations.

At inference, the VLM extracts $Z_t$ from the current visual observation and instruction, encodes the robot’s proprioceptive state $E_\eta(r_t)$, and runs the action expert $v_\psi$ to integrate a continuous action chunk via flow matching.

**Table 1.** Performance comparison of various VLM-based methods across different task categories (Spatial, Object, Goal, Long) and their average performance.

Performance and Benchmarks

VLA‑$\Delta$ outperforms baselines across simulation and real‑robot tasks.

Recall that most VLA models skip an explicit physical‑state transition, while VLA‑$\Delta$ inserts this intermediate representation to guide action generation.

The backbone processes visual‑language inputs through a hierarchical encoder that preserves spatial structure before feeding a lightweight policy head.

How does GR00T N1 differ from a vanilla transformer backbone?

GR00T N1 retains high‑resolution spatial maps throughout the encoder, whereas a vanilla transformer collapses spatial dimensions early, losing fine‑grained geometry needed for precise manipulation.

VLA‑$\Delta$ attains the highest average success on the LIBERO benchmark, reaching 98.4 %.

All compared methods fall below this figure; the next best method achieves 96.1 %.

**Table 2.** Performance comparison on RoboTwin 2.0 (Success Rates, %) under Clean and Random settings. Full results are provided in Appendix C.2.

**Figure 4.** LIBERO-Plus performance under four different perturbations.

**Figure 5.** Real-robot evaluation on the AgileX PiPER 6-DoF platform. (a) Dual-arm robot platform. (b) Real-robot experimental results (Success Rates, %). (c) Overview of the five tasks.

VLA‑$\Delta$ consistently outperforms direct‑mapping baselines across LIBERO tasks.

Ablation Analysis

Component ablations on LIBERO reveal how each supervision signal lifts task success.

We evaluate four supervision signals—Physical State Difference Queries, Future‑State Difference Text, Structured Transition Slots, and Dense Optical Flow—by ablating them on the 40‑task LIBERO benchmark, keeping only the action‑learning objective during fine‑tuning.

Adding the query mechanism raises average success to 96.25 %.

Table 3 reports 96.25 % for the “Query + Difference Text” variant, compared with 95.70 % for the baseline.

Including Physical State Difference Queries alone yields 95.85 % success.

Table 3 shows 95.85 % for the “Difference Queries Only” variant.

Future‑State Difference Text contributes an additional lift, reaching 96.45 % when combined with queries.

Table 3 lists 96.45 % for the “Query + Structured Slots” variant, which adds the text signal.

Structured Transition Slots further improve performance to 97.20 %.

Table 3 records 97.20 % for the “Query + Optical Flow” variant, which includes slot supervision.

Dense Optical Flow provides the largest single boost, achieving 98.40 % in the full model.

Table 3 reports 98.40 % for the “VLA‑$\Delta$ (Full)” configuration.

**Figure 6.** t-SNE visualization of Slot Query hidden states.

**Figure 7.** Query attention maps for towel folding and mug hanging.

Related Work

We situate VLA‑$\Delta$ among prior vision‑language‑action, embodied reasoning, and world‑model work.

Vision‑language‑action (VLA) models fuse pretrained vision‑language backbones with robot demonstrations to map multimodal inputs to actions. Prominent examples include RT‑2, which tokenizes actions for joint training, OpenVLA, which scales policy learning on large robot datasets, and flow‑matching approaches such as $\pi$0 and GR00T N1 that generate continuous action chunks. These works provide the architectural and pretraining foundations that VLA‑$\Delta$ builds upon.

Embodied reasoning connects high‑level task semantics to concrete motions via intermediate plans, spatial reasoning, and grounded representations. Methods such as ECoT generate explicit task plans, ThinkAct learns goal‑completion rewards, and ThinkingVLA interleaves textual reasoning with future‑image prediction to guide policies. VLA‑$\Delta$ adopts this paradigm by supervising physical state changes, but it restricts such reasoning to pretraining.

World action models predict future observations or latent states to condition action generation. Approaches like WorldVLA, VLA‑JEPA, DreamVLA, and Motus use autoregressive image generation, latent‑space prediction, or optical‑flow supervision to shape policies. VLA‑$\Delta$ unifies readable task‑progress descriptions, structured transition slots, and dense optical‑flow signals, achieving a shared transition representation without requiring online future‑image decoding.

Automated Annotation Pipeline

The section details the automated pipeline that creates physical state‑transition annotations for VLA‑$\Delta$ training.

Training VLA‑$\Delta$ requires large amounts of accurate physical‑state transition data, but manually labeling such data is costly, time‑consuming, and prone to inconsistency.

The pipeline turns raw multimodal robot demonstrations into structured “current–future” state pairs without human labor, guaranteeing consistent coverage of task phases, object poses, contacts, and constraints.

Keyframe selector flags both frames because the gripper state (closed) is constant but the cube’s position changes.

SAM 3 generates masks for the cube and gripper in each frame; UniDepth V2 estimates median depths 0.12 m (t=0) and 0.13 m (t=0.5 s).

MegaFlow computes a 2‑D displacement of (+0.05, −0.02) m for the cube between the two frames.

Future‑State Difference Text is created: “Task progress 0.42→0.50; cube moves right‑up; gripper remains closed.”

Structured Transition Slots are filled with numeric values (progress, phase IDs, bounding boxes, depth, displacement) and validity flags set to 1.

The example shows how a single motion segment yields a complete annotation package—progress, pose change, depth, and motion—without any human input.

How does this pipeline differ from a conventional manual annotation workflow?

Manual pipelines require a human to watch each demonstration, draw bounding boxes, write textual state descriptions, and verify consistency—an effort that scales linearly with video length. The automated pipeline replaces every human step with deterministic models (SAM 3, UniDepth V2, MegaFlow) and a language model that selects keyframes and writes the textual description, achieving orders‑of‑magnitude speedups while guaranteeing uniform slot formats.

**Figure 3.** Physical state-transition annotations and the automated data annotation pipeline.

**Figure 8.** Physical state-transition annotation examples: a current–future observation pair with Future-State Difference Text and Structured Transition Slots (top), and slot annotations for loading a plate into a metal rack (middle) and hanging a mug (bottom).

Audit results (Table 5) show that across 300 sampled current–future pairs, validity rates exceed 93 % for every slot, with the highest scores (≈99 %) on object‑constraint text, target‑position slot, and gripper‑state‑transition slot.

Pretraining Dataset

Describes the pretraining datasets and their filtering for robot manipulation.

We assemble a pretraining corpus for robot manipulation by unifying demonstrations from DROID, MolmoAct, and RH20T into a common trajectory format. Samples are retained only if visual frames, language instructions, robot states, and action records are complete. This filtering yields a diverse set of tasks, scene layouts, robot configurations, and interaction types.

The table provides a comparison of three datasets: MolmoAct, DROID, and RH20T, detailing the number of frames, hours, tasks, and a brief introduction for each.

DROID contributes roughly 27.6 million frames (511.7 hours) from 76 k demonstration trajectories across 564 scenes and 84 task categories. We keep only trajectories with complete timestamps, valid visual frames, and continuous action records, emphasizing phases such as approaching, grasping, transporting, placing, and releasing objects. This selection enriches the pretraining data with varied environments, objects, and task structures.

MolmoAct adds over 1.1 million frames (30.7 hours) from more than 10 k high‑quality household and tabletop manipulation trajectories. Each trajectory includes visual observations, language instructions, robot states, and actions, and we retain those that clearly show task progress and sub‑goal transitions. These examples provide rich language conditioning, spatial relations, and multistage manipulation cues.

RH20T supplies about 3.9 million frames (108.3 hours) from over 110 k contact‑rich sequences spanning multiple robot platforms and sensor configurations. We use its visual observations, proprioceptive states, and continuous action records, while other modalities such as force and audio are omitted from the policy input. The dataset contributes examples of grasping, pushing, insertion, and release, illustrating fine‑grained object state changes.

Evaluation Protocol

Details of the evaluation benchmarks, protocols, and supervision targets used in the experiments.

LIBERO is a simulation benchmark for multitask robot manipulation. It contains four suites—Spatial, Object, Goal, and Long—that probe distinct capabilities such as relative positioning, object identification, goal achievement, and extended horizon planning.

Training uses 1,693 demonstration trajectories drawn from all four suites. Standard evaluation runs 50 independent episodes per task, totaling 2,000 episodes, with each episode initialized from a predefined scene.

LIBERO‑Plus measures out‑of‑distribution robustness. Four perturbation types—language variation, lighting changes, background modifications, and layout shifts—are applied across all suites, yielding 8,000 evaluation episodes without any additional demonstrations or fine‑tuning.

RoboTwin 2.0 is a dual‑arm simulation benchmark focusing on bimanual coordination and generalization. It offers a Clean setting with fixed scene appearance and a Random setting that varies objects, lighting, backgrounds, and instructions.

Training consumes 27,500 demonstrations (50 Clean + 500 Random per task). Evaluation runs 100 episodes per task under each setting, for a total of 10,000 episodes, using an action‑chunk length of 16 and a closed‑loop rollout of the first eight actions.

**Table.** Task success rates (%) on RoboTwin 2.0 under the Clean and Random settings.

Real‑robot evaluation uses the AgileX PiPER dual‑arm platform with three cameras and proprioceptive feedback. Five tasks target obstacle avoidance, long‑horizon execution, fine‑grained manipulation, spatial reasoning, and generalization under changed tablecloths.

**Table.** Evaluation protocol. Each task is evaluated over 40 independent episodes, for a total of 200 real-robot trials. For each task, all episodes use the same task instruction and a predefined distribution of initial scene configurations, while specific object positions, poses, or background conditions may vary according to the experimental setup.

D.1 introduces Structured Slot Heads, where each supervision target (S₁–S₉) is predicted from a mean‑pooled query group. Linear projections follow LayerNorm, and targets share groups when their semantics overlap (e.g., task progress and phase share G₁₂).

This table defines the classes and their meanings for three specific targets: $S_2$ (Task phase), $S_7$ (Gripper state transitions), and $S_8$ (Contact transitions).

**Table 9.** Fixed class vocabularies for task phase, gripper state transitions, and contact transitions. Class IDs start at zero.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers