VLN-Flash: Parallel Action Decoding with Adaptive Execution for Vision-and-Language Navigation

Ruizhe Xie, Honghua Chen, Binglin Wang, Tong Guo, Xu Tang, Puti Yan, Shaoxiong CaiarXiv 2026 · arXiv

TL;DR

VLN-Flash is a training-free decoding method that accelerates Vision-and-Language Navigation (VLN) by scoring all possible short-term action sequences in a single parallel forward pass. By using a "score margin" to adaptively decide when a robot should stop and re-observe its environment, it achieves a nearly 3× speedup in decoding and improves navigation success rates on both benchmarks and real-world hardware.

What Problem Does This Paper Address?

In Vision-and-Language Navigation (VLN), a robot must follow natural language instructions (e.g., "Go down the hall and turn right at the kitchen") using first-person camera views. Modern state-of-the-art policies often use large video-based language models to predict actions.

However, these models suffer from two major bottlenecks:

  1. The Autoregressive Delay: Standard models predict actions one by one. To plan a sequence of four actions, the robot must wait for four sequential model calls. This creates a "stop-and-go" motion that is inefficient and slow.
  2. The Execution Dilemma: How many actions should a robot take before it stops to look at the world again? Existing methods use a fixed number (e.g., always execute 2 actions). If the robot executes too many, it might miss a crucial turn; if it executes too few, it wastes time re-planning when it could have kept moving.

Methods

The authors introduce VLN-Flash, which leverages the fact that navigation has a very small action vocabulary (typically: forward, left, right, stop).

1. One-Pass Action-Tree Decoding

Instead of sequential calls, VLN-Flash enumerates every possible action sequence up to a certain horizon (e.g., 4 steps). Because the action space is so small, there are only 39 possible prefixes for a 4-step plan. The researchers "pack" these prefixes into a tree structure and process them in a single forward pass through the model.

  • Tree Attention: They use a specialized attention mask that allows different branches of the tree to share the same visual/instruction context while keeping their individual action histories separate.
  • Exact Equivalence: Mathematically, this parallel pass produces the exact same probability distributions as the slow sequential method, meaning no accuracy is lost to approximation.

2. Adaptive Execution

Rather than following a fixed execution limit, VLN-Flash uses the model's own confidence to decide when to stop. It calculates a score margin: the difference between the probability of the best-scoring plan and its strongest alternative.

  • If the margin is high, the model is confident, and the robot continues the plan.
  • If the margin drops below a threshold, it suggests the model is uncertain about the future. The robot then stops, takes a new observation, and re-plans.

Datasets

The authors evaluated VLN-Flash on two standard continuous environment benchmarks:

  • R2R-CE (Room-to-Room): Navigation in 3D reconstructed home environments.
  • RxR-CE (Room-Across-Room): A more complex, multilingual version of R2R.
  • Real-world Deployment: They also tested the system on a Unitree GO2 quadruped robot in various indoor and outdoor settings (corridors, classrooms, offices).

Key Insights and Ideas

  • The "Small Vocabulary" Advantage: While tree-based decoding is usually too expensive for standard LLMs (with 32k+ tokens), it is perfectly suited for robotics where the action space is tiny.
  • Confidence-Driven Replanning: The "aha moment" here is using the joint probability of a sequence to determine execution length. It treats the model's uncertainty as a natural signal for when the robot needs "fresh eyes" on the environment.
  • Training-Free Integration: Perhaps most impressively, VLN-Flash requires zero retraining. It can be "plugged in" to existing pre-trained models like Uni-NaVid or StreamVLN to immediately boost their speed and performance.

Key Results

  • Speedup: VLN-Flash achieved a 2.75× speedup on Uni-NaVid and a 2.57× speedup on StreamVLN compared to native autoregressive decoding.
  • Navigation Accuracy: It improved the Success Rate (SR) by up to 2.7 percentage points on standard benchmarks. This suggests that looking at the joint probability of sequences leads to better decision-making than picking actions one-by-one.
  • Real-World Impact: On the Unitree GO2 robot, VLN-Flash reduced the mean wait time between actions by 160 ms. It successfully completed 52 out of 60 instructions, outperforming the 49/60 success rate of the baseline autoregressive method.

Limitations and Future Work

  • Exponential Growth: While a horizon of $K=4$ is manageable (39 nodes), the tree size grows exponentially ($3^K$). Extending this to much longer horizons (e.g., $K=10$) would require pruning or more complex sampling strategies.
  • Discrete Actions Only: The current method relies on a small, discrete action set. It is not immediately clear how this would translate to robots using continuous control (e.g., specific joint torques or velocities).
  • Future Directions: The authors suggest that combining this with other acceleration techniques, like speculative decoding or KV-cache reuse, could push the speed even further.

Summary based on "VLN-Flash: Parallel Action Decoding with Adaptive Execution for Vision-and-Language Navigation" (arXiv:2611.19287v1).

Summary updated

Abstract

When a vision-and-language navigation policy generates an action sequence autoregressively, the robot waits for a chain of dependent predictions. A small discrete action vocabulary makes it possible to score all short-horizon plans in parallel. We introduce VLN-Flash, a training-free decoder that evaluates the complete action-prefix tree in a single forward pass. Branch-specific attention and matched token positions preserve the original policy's conditional action distribution for each prefix in exact arithmetic. We use the score margin between the stepwise-greedy prefix and its strongest alternative at each depth to decide how many actions to execute. The robot then executes the plan with the highest joint score at the chosen depth before observing again. On matched inputs, VLN-Flash achieves a nearly $3\times$ speedup in action decoding over native autoregression on Uni-NaVid and StreamVLN. Compared with the native autoregressive decoders, it improves success rate and success weighted by path length (SPL) on R2R-CE and RxR-CE, with success gains up to 2.7 percentage points. On a Unitree GO2, VLN-Flash improves navigation success and cuts the mean wait between actions by about 160 ms after subtracting network transmission time.
BibTeX
@misc{xie2026vln,
  author = {Ruizhe Xie and Honghua Chen and Binglin Wang and Tong Guo and Xu Tang and Puti Yan and Shaoxiong Cai},
  title = {{VLN-Flash: Parallel Action Decoding with Adaptive Execution for Vision-and-Language Navigation}},
  year = {2026},
  eprint = {2611.19287},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.19287},
}
Figure