💻 computer science

ChainVLA: Chaining Vision-Language-Action Queries through a Unified Execution State for Long-Horizon Manipulation

ChainVLA is a 1.2B-parameter vision-language-action policy that achieves superior long-horizon manipulation performance by chaining successive queries through a unified, revisable execution state combining recurrent working memory for task progress and motion tailing for continuous action generation.

Original authors: Yuzhi Huang, Weijue Bu, Ziyi Xiong, Jie Wu, Fanding Huang, Jingyan Jiang, Zhi Wang

Published 2026-08-04

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Yuzhi Huang, Weijue Bu, Ziyi Xiong, Jie Wu, Fanding Huang, Jingyan Jiang, Zhi Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a robot to clean your messy room. You give it a simple command: "Put the toys away." A robot that thinks in tiny, isolated steps might look at the floor, pick up a red block, and put it in a box. Then, it stops. It forgets that it just picked up the block. It looks at the floor again, sees a blue block, and picks that up. But what if the red block was actually supposed to go under the blue one? Or what if the robot needs to remember that it already cleared the left side of the room, so it shouldn't go back there? This is the challenge of "long-horizon manipulation." It's not just about moving an arm; it's about keeping a running story in your head while your hands are busy.

In the world of robotics, scientists use something called Vision-Language-Action (VLA) policies. Think of these as the robot's brain, which looks at the camera (vision), reads your instructions (language), and decides what to do (action). Usually, these brains work in short bursts. They make a plan for the next few seconds, do those moves, and then immediately stop to make a new plan from scratch. It's like trying to write a novel by writing one sentence, erasing your memory of the previous sentence, and then trying to guess what the next sentence should be based only on the current page. The problem is, the robot often loses the thread of the story. It forgets what it just accomplished or gets confused because its new plan clashes with the motion it was already doing. This paper asks: How can we make a robot that remembers its story and keeps its movements smooth, all while looking at the world in real-time?

The Robot with a Memory and a Momentum

Meet ChainVLA. It's a new kind of robot brain designed by researchers to solve the "forgetful robot" problem. Imagine you are riding a bicycle down a winding path. To stay upright, you need two things: you need to remember where you've been (did you just turn left? is there a hill coming up?), and you need to keep pedaling smoothly so you don't wobble and fall. ChainVLA is built to do exactly this for robot arms.

Most robot brains today work like a person who takes a photo, makes a decision, puts the photo down, takes a new photo, and makes a new decision. They don't carry the "feeling" of the previous decision into the next one. ChainVLA changes the game by chaining these decisions together. It creates a special "execution state" that acts like a backpack the robot wears. This backpack has two very important compartments:

The "Story" Compartment (Progress Context): This holds the memory of what the robot has already achieved. It's like a mental checklist. If the robot just moved a block to the left, this compartment remembers, "Okay, the left side is clear." It combines a quick, working memory (what's happening right now) with a sparse, long-term memory (important events that happened a while ago, like "I moved the red block first"). This helps the robot know where it is in the big picture of the task.
The "Momentum" Compartment (Motion Tail): This is the cool part. When the robot decides to move, it doesn't just say "move forward." It predicts a whole sequence of moves for the next few seconds. But it only actually does the first few moves before it stops to think again. The "Motion Tail" is the part of that prediction that wasn't done yet. ChainVLA saves this unfinished plan and feeds it back into the robot's brain for the next step. It's like a runner who, even after stopping to tie a shoe, remembers exactly how fast they were running and in which direction, so they don't have to start from a dead stop.

How It Works in Practice

The researchers tested this idea on some tricky tasks. One of the hardest was called "Put Back Block." Imagine a robot has to move a block to a spot, then move another object, and finally put the block back on that original spot. The problem? By the time the robot is ready to put the block back, the original spot might be hidden from the camera by the new object. A normal robot would look at the camera, see nothing, and get confused. It would forget where the spot was.

ChainVLA, however, uses its "Story" compartment to remember, "Hey, I put that block there earlier, even though I can't see it now." At the same time, its "Momentum" compartment ensures that when it moves to put the block back, it doesn't jerk the arm in a weird, new direction that clashes with where the arm was just pointing.

The results were pretty dramatic. On a tough test called RMBench, ChainVLA succeeded 62.8% of the time. Compare that to other smart robots:

If you take away the "Story" (Progress Context), the success rate crashes to 3.0%. The robot forgets the task entirely.
If you take away the "Momentum" (Motion Tail), the success rate drops to 11.2%. The robot remembers the task but moves so clumsily that it fails.

This shows that both parts are essential. The "Story" tells the robot what to do, and the "Momentum" helps it do it smoothly without tripping over its own feet.

Why It Matters

The paper suggests that keeping the "unfinished motion" alive is actually crucial for remembering the task. It's a bit like a dance: if you stop dancing completely between steps, you might forget the rhythm. But if you keep the rhythm going (the Motion Tail), your brain is better at remembering the choreography (the Progress Context).

When the researchers tried to fix the robot's clumsiness by just smoothing out the moves after the robot had already decided what to do (a common trick in other robots), it didn't work. The robot still failed. This proves that the secret isn't just about making the moves look nice; it's about feeding the idea of the next move into the robot's brain before it makes a new decision.

In short, ChainVLA suggests that for robots to handle long, complicated jobs, they need to be less like a camera taking snapshots and more like a storyteller who never loses their place in the book, while also keeping their feet moving to the beat of the music. It's a small step toward robots that can actually help us with the messy, multi-step chores of real life without getting confused or dropping everything.

Technical Summary: ChainVLA

Problem Statement

Long-horizon robotic manipulation requires a continuous execution flow where decisions depend on both the task progress established by prior actions and the motion continuation of actions currently underway. Existing Vision-Language-Action (VLA) policies typically operate in an action-chunked, receding-horizon regime. In this design, the policy repeatedly replans from the current observation, proprioceptive state, and instruction, predicting a finite action horizon, executing a strict prefix, and then discarding the remainder.

This design creates an incomplete cross-query handoff at two levels:

Task Level: Earlier task evidence (e.g., a completed subtask or an object's initial layout) may leave the current observation field. Without explicit memory of these events, the policy cannot infer the correct next step when the current view is ambiguous (e.g., the "Put Back Block" task in RMBench).
Motion Level: Replanning discards the unexecuted continuation of the preceding prediction. This causes the newly predicted prefix to potentially disagree with the motion already in progress, creating discontinuities in pose and velocity. Since the executed motion shapes the observation stream for the next query, these discontinuities degrade the quality of observations used for future task-progress inference.

Existing solutions address these issues separately: memory-augmented policies retain task history but discard motion continuity, while temporal ensembling or real-time execution preserves motion but lacks long-term task evidence.

Methodology: ChainVLA

ChainVLA is a 1.2B-parameter VLA policy designed to chain successive queries through a joint and revisable execution state ( $s_k = (g_k, u_k)$ ). This state is maintained across query boundaries, allowing the policy to regenerate action horizons under the latest observation while retaining necessary context.

1. The Execution State

The state consists of two complementary components:

Progress Context ( $g_k$ ): Carries observation-derived task progress. It is a fusion of:
- Working State: A recurrent summary of the current execution, updated at every query using live tokens from the current input and a bounded cache of recent tokens.
- Sparse Event Memory: A retrievable memory of sparse, significant milestones (e.g., stage transitions). Events are written based on stage annotations or periodic rules and retrieved using a query conditioned on the current execution estimate and age encoding.
Motion Tail ( $u_k$ ): Carries the preceding prediction's unexecuted suffix. This component bridges the gap between the executed prefix and the next query, providing a "continuation prior" for the unfinished motion.

2. Query Transition and Architecture

At each query $k$ , the policy receives the current input $x_k$ and the carried state $s_k$ .

State Update: The encoder processes $x_k$ into multimodal tokens. A learned working-query bank attends to these tokens and the previous Working State to produce live tokens ( $L_k$ ) and a summary ( $\bar{W}_k$ ). The summary retrieves event evidence ( $Z^e_k$ ) from the Sparse Event Memory.
Progress Context Formation: $g_k$ is formed by fusing $L_k$ and $Z^e_k$ .
Motion Tail Integration: The incoming Motion Tail ( $u_k$ ) conditions the Working State and initializes the action generation process. Specifically, it aligns the normalized suffix with the full-horizon action representation to set the initial mean ( $\mu_{k+1}$ ) of the decoder's state.
Action Generation: A conditional-flow decoder (DiT backbone) regenerates the full action horizon $A_k$ conditioned on $x_k$ , $g_k$ , and $u_k$ . Crucially, the decoder does not copy or freeze any horizon position; it regenerates every position based on the latest observation, ensuring the carried state acts as a revisable prior rather than a fixed plan.
Next State: After executing the prefix, the unexecuted suffix of $A_k$ becomes the Motion Tail ( $u_{k+1}$ ) for the next query.

3. Training

Training unrolls the execution-state transition in episode order. The model is supervised by:

Standard conditional-flow action objectives.
Stage supervision (where annotations exist) for the stage estimate and write targets.
An overlap-consistency regularizer that penalizes disagreement between the temporally aligned overlap of consecutive predicted horizons, encouraging a coherent handoff without fixing actions in the new horizon.

Key Contributions

Identification of Cross-Query State Components: The paper identifies task progress and unfinished motion as two complementary, asymmetric components of cross-query execution state. Ablation studies show that removing either component drastically reduces performance, and their interaction suggests that motion continuity is essential for preserving the observation stream required for task-progress inference.
ChainVLA Policy: A 1.2B-parameter policy that chains queries through a joint state of Progress Context and Motion Tail. Unlike prior work, it regenerates each horizon under the latest observation while maintaining a revisable prior derived from the previous prediction.
Empirical Validation: Extensive evaluation on RMBench and LIBERO suites demonstrates that ChainVLA outperforms existing memory-augmented and action-chunked baselines.

Results

RMBench: ChainVLA achieves a 62.8% average success rate across five memory-dependent tasks. This significantly outperforms the strongest listed method with complete coverage (Mem-0 at 52.8%) and is particularly effective on the "Put Back Block" task (96% vs. 90% for Mem-0), where task evidence leaves the view.
LIBERO: The policy achieves 98.8% average success across four suites (Spatial, Object, Goal, Long), with all suites exceeding 98% success.
Ablation Studies:
- Removing Progress Context reduces RMBench success to 3.0%.
- Removing Motion Tail reduces RMBench success to 11.2%.
- Replacing the carried state with observation history and post-decoding temporal ensembling (FIFO Hist. + TE) yields only 35.6% success.
- Post-decoding smoothing controls (Linear Continuation, Temporal Ensemble) reduce boundary discontinuities but fail to recover task success, indicating that the gain comes from the model-side conditioning of the generation process, not just smoother execution.

Significance

The paper claims that ChainVLA addresses a fundamental gap in long-horizon manipulation: the lack of a unified mechanism to handle both long-term task evidence and short-term motion continuity simultaneously. The results suggest that motion continuity is not merely a control objective but a prerequisite for reliable task-progress inference, as discontinuous motion alters the observation stream in ways that degrade memory retrieval. By chaining queries through a joint, revisable state, ChainVLA enables policies to maintain coherence over long horizons without requiring separate planners or world models.