vlash-async-vla

name	vlash-async-vla
title	VLASH: Real-Time Vision-Language-Action Models via Future-State-Aware Asynchronous Inference
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2512.01031
keywords	["robotics","vla-models","asynchronous-inference","latency-reduction","robot-control"]
description	Rolls forward robot state using previously generated actions to condition predictions on estimated future states, paired with temporal-offset training augmentation. Achieve 2× speedup and 17.4× latency reduction in vision-language-action models without architectural changes.

Summary

VLASH enables efficient asynchronous inference for Vision-Language-Action models by addressing prediction-execution temporal misalignment. The method makes VLA models future-state-aware by rolling forward the robot state using previously generated actions, conditioning on where the robot will be when predictions execute rather than its stale state at inference start. Temporal-offset training augmentation and efficient fine-tuning complete the approach.

Core Technique

Future State Prediction: While the model processes input observations, the robot is executing previous actions. When new predictions emerge, the robot has moved. Instead of conditioning on the initial state s_0, condition on s_t, the predicted state at execution time using: s_t = step_forward(s_0, [a_0, a_1, ..., a_{t-1}]).

Temporal-Offset Training: Train the VLA model to leverage offset robot states by augmenting training data with multiple temporal offsets. Show the model: "Given state at time t, predict action for execution at time t+δ." This teaches the model to condition predictions on shifted states.

Shared Observation Fine-Tuning: Reuse visual encodings across multiple temporal offsets to amortize computation. A single observation encoding is projected to multiple temporal contexts efficiently.

Implementation

State rolling function: Maintain a differentiable state transition model:

def roll_forward(state, actions, num_steps):
    for action in actions[:num_steps]:
        state = apply_dynamics(state, action)
    return state

Training augmentation: For each training trajectory, generate multiple versions:

for offset in [0, 1, 2, 3]:
    future_state = roll_forward(state_0, actions, offset)
    training_sample = (future_state, action_offset, target_action)

Inference asynchrony: During deployment:

1. At time t, compute actions concurrently with robot execution
2. Predict where robot will be: s_{predict} = roll_forward(s_{current}, [previous_actions])
3. Condition VLA on s_{predict}
4. By time predictions return, robot is at ~s_{predict}