| 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:
- At time t, compute actions concurrently with robot execution
- Predict where robot will be: s_{predict} = roll_forward(s_{current}, [previous_actions])
- Condition VLA on s_{predict}
- By time predictions return, robot is at ~s_{predict}
