# Vlash Async Vla

> 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.

- Skill: `adu2021/vlash-async-vla` (Agent Skill)
- Install (CLI): `npx skillmds@latest add adu2021/vlash-async-vla`
- Raw SKILL.md: https://api.skillmd.com/api/skills/adu2021/vlash-async-vla/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: adu2021 (https://skillmd.com/u/adu2021)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/adu2021/vlash-async-vla

---


## 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:
```python
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:
```python
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}

## When to Use

- Real-time robotics control requiring low reaction latency
- VLA deployment where inference time competes with action execution
- Dynamic tasks (ping-pong, catching) needing responsive control
- Systems where reducing latency directly improves task success rate

## When NOT to Use

- Offline or non-real-time control scenarios
- Tasks where execution speed is slow relative to inference
- Models where state prediction is inaccurate or unavailable
- Scenarios where synchronous inference is simpler to debug

## Key References

- Vision-language-action model architectures for robotics
- Asynchronous control and prediction in real-time systems
- Robot state transitions and dynamics models
- Latency reduction techniques in inference pipelines