Think Twice, Act Once: Token-Aware Compression and Action Reuse for Efficient Inference in Vision-Language-Action Models

## Abstract

Abstract Vision-Language-Action (VLA) models have emerged as a powerful paradigm for general-purpose robot control through natural language instructions. However, their high inference cost—stemming from large-scale token computation and autoregressive decoding—poses significant challenges for real-time deployment and edge applications. While prior work has primarily focused on efficient architectural optimization, we take a different and innovative perspective by identifying a dual form of redundancy in VLA models: (i) high similarity across consecutive action steps, and (ii) substantial redundancy in visual tokens. Motivated by these observations, we propose FlashVLA , the first training-free and plug-and-play acceleration framework that enables action reuse in VLA models. Specifically, FlashVLA improves inference efficiency through a token-aware action reuse mechanism that avoids redundant decoding across stable action steps, and an information-guided visual token selection strategy that prunes low-contribution tokens. Extensive experiments on the LIBERO benchmark show that FlashVLA reduces FLOPs by 55.7% and latency by 36.0%, with only a 0.7% drop in task success rate. These results demonstrate the effectiveness of FlashVLA in enabling lightweight, low-latency VLA inference without retraining.

## 1 Introduction

In the development of embodied intelligence systems, Vision-Language-Action (VLA) models are rapidly emerging as a key technology for enabling general-purpose behavior control. By integrating visual perception, language understanding, and action generation, VLA models empower embodied agents to execute complex tasks based on natural language instructions, demonstrating strong generalization and task adaptability brohan2022rt; nair2022r3m; bai2023qwen; chen2023executing; cheang2024gr; li2023vision; jiang2023motiongpt; kim2024openvla; chen2024ll3da; chi2023diffusion; duan2024manipulate; singh2023progprompt. However, despite their impressive performance in task execution, VLA models often involve heavy computational loads and high latency during inference, making them difficult to deploy in high-frequency control settings and limiting their applicability in more dexterous and complex bimanual manipulation tasks kim2025openvlaoft; liu2024rdt; wen2025tinyvla; li2024inference.

Current VLA architectures typically fall into two paradigms: the autoregressive generation paradigm, such as OpenVLA kim2024openvla, which encodes multimodal inputs into tokens and decodes actions step-by-step using a language model; and the diffusion policy paradigm wen2024diffusion; li2024cogact; yan2024dnact; chi2023diffusion; hou2024diffusion, which formulates action generation as a conditional denoising process and enables parallel trajectory sampling. Both paradigms rely heavily on Transformer architectures, where each inference step incurs a quadratic complexity $\mathcal{O}(N^{2})$ with respect to sequence length $N$, leading to high computational cost. To mitigate this, recent work focuses on architectural-level optimizations, including action chunking song2025pdvla; liu2024bidirectional, parallel decoding kim2025openvlaoft, low-rank adaptation wen2025tinyvla, and model quantization park2024quantization. While effective, these methods typically require additional training overhead.

Figure: Figure 1: Motivation behind our proposed FlashVLA. The figure shows the change in the VLA model’s output vector at each time step relative to the previous one. The vertical axis indicates the directional difference between consecutive actions. Most actions remain highly consistent with the previous step and appear in the stable area of the figure, while only a few exhibit significant changes.
Refer to caption: x1.png

Unlike prior work that focuses on architectural optimizations, we take a new perspective by analyzing the temporal behavior of VLA models at the action level. We observe that in many tasks (e.g., OpenVLA kim2024openvla), consecutive action steps often show minimal directional change, suggesting semantic redundancy (see Fig. [1](https://arxiv.org/html/2505.21200v1#S1.F1)). This indicates that actions in stable phases can be reused to avoid redundant computation. We further find significant redundancy in visual tokens (see Appendix [C](https://arxiv.org/html/2505.21200v1#A3)), consistent with observations in vision-language models (VLMs) chen2024image; yang2024visionzip; zhang2025llava; chen2024efficient, which reveals potential for reducing computational cost along another computational dimension.

Building on these observations, we propose FlashVLA, a training-free, plug-and-play dual-path acceleration framework that improves VLA inference efficiency via action reuse and token pruning. The first component is a token-aware reuse mechanism that compares both action similarity and visual token stability to decide whether to skip computation and reuse the previous action. The second is a visual token selection strategy based on information contribution scores, retaining informative tokens while discarding low-impact ones. The proposed FlashVLA integrates seamlessly with Flash Attention-based VLA models and follows a “Think Twice, Act Once” paradigm: it performs lightweight assessment before execution, selecting between skipped execution and lightweight execution, significantly reducing FLOPs and latency while maintaining control accuracy.

To evaluate the effectiveness of FlashVLA, we conduct systematic experiments on four representative tasks from the LIBERO benchmark: Spatial, Object, Goal, and Long. We further validate the method on VLAbench to assess generalization. FlashVLA achieves a 55.7% reduction in FLOPs and a 36.0% reduction in latency without any additional training, while reducing the number of visual tokens to 62.5% of the original input. Notably, the average success rate drops by only 0.7% compared to the baseline VLA model. Ablation studies and benchmark results collectively demonstrate that FlashVLA significantly reduces computational cost while preserving task performance, enabling efficient VLA inference with minimal performance drop.

Our key contributions are summarized as follows:

- 1.
We identify a novel form of action-level and token-level redundancy in VLA inference. Specifically, we observe that most consecutive action steps yield highly similar outputs with only minor directional changes, allowing action reuse in stable phases. Additionally, many visual tokens contribute little to the overall inference process, revealing a degree of visual redundancy similar to that observed in MLLMs.
- 2.
We introduce FlashVLA, the first training-free and plug-and-play acceleration framework that enables action reuse in VLA models. It integrates a token-aware action reuse mechanism to skip redundant computation in stable action steps, and a visual token selection strategy based on information contribution scores to retain informative tokens. It is worth noted that FlashVLA is fully compatible with Flash Attention-based VLA backbones.
- 3.
We conduct comprehensive experiments on four representative tasks from the LIBERO benchmark. When visual tokens are reduced to 62.5% of the original input, FlashVLA lowers inference latency by 36.0% and decreases the FLOPs of visual token computation by 55.7%, while incurring only a 0.7% drop in success rate. These results demonstrate that FlashVLA achieves significant efficiency gains with limited performance trade-off.

## 2 Related Work

Recent advances in VLA models highlight the critical role of architecture in determining both performance and efficiency. To address the computational challenges inherent in these models, a variety of acceleration methods kim2025openvlaoft; song2025pdvla; li2024cogact; wen2025tinyvla; liu2024robomamba; xu2025vlacache; yue2024deer; park2024quantization have been proposed across two dominant paradigms: autoregressive generation and diffusion policy zitkovich2023rt; kim2024openvla; black2410pi0; liu2024rdt; wen2024diffusion; yan2024dnact; li2024cogact; chen2023executing.

#### Vision-language-action models.

Vision-language-action (VLA) models provide a promising direction for training generalist robot policies ahn2022can; brohan2022rt; black2410pi0; duan2024manipulate and are built on large-scale robot learning datasets liu2023libero; o2024open; fang2023rh20t; khazatsky2024droid; li2024evaluating. Most VLA models follow one of two paradigms: autoregressive generation and diffusion policy. Autoregressive models, such as RT-2 zitkovich2023rt and OpenVLA kim2024openvla, encode multimodal inputs into tokens and decode actions step-by-step using a language model. RT-2 treats actions as text tokens and trains them alongside natural language, while OpenVLA combines a vision backbone with a language model trained on large-scale robot trajectories. Pi0 black2410pi0 is another autoregressive model that uses flow matching for faster action generation. Diffusion-based models, including RDT-1B liu2024rdt, Diffusion-VLA wen2024diffusion, DNACT yan2024dnact, and CogACT li2024cogact, formulate action generation as conditional denoising. Diffusion-VLA combines autoregressive and diffusion methods to improve robustness. DNACT focuses on multi-task 3D policy learning, while CogACT generates diverse action sequences to improve flexibility. However, the large size of VLA models leads to high computational cost, limiting real-time deployment and high-frequency control.

#### Acceleration for VLA models.

Existing methods mainly focus on architectural-level optimizations tailored to the two main VLA paradigms, including action chunking song2025pdvla; kim2025openvlaoft, which splits complex actions into smaller segments to reduce per-step computation; parallel decoding song2025pdvla; kim2025openvlaoft, which enables simultaneous generation of multiple actions; low-rank adaptation wen2025tinyvla; hu2022lora, which compresses model weights to reduce parameters; and model quantization pertsch2025fast; park2024quantization, which lowers numerical precision to save memory and computation. While these techniques improve efficiency, they require additional training or fine-tuning.
Training-free acceleration remains underexplored. Although some pruning methods from VLMs chen2024fastv; zhang2024sparsevlm; yang2024visionzip; liu2024multi are training-free, they are incompatible with Flash Attention and do not sufficiently consider the structural characteristics of VLA models.
To address these limitations, we propose a training-free, plug-and-play dual-path framework that accelerates VLA inference through action reuse and token pruning.

Figure: Figure 2: Framework of our FlashVLA. We give the way our method works as the action step changes. Before each inference, FlashTrigger will think about whether it can reuse the output of the previous action based on action memory and token memory (as shown in blue block). If the trigger condition is met, this inference is skipped. If the trigger condition is not met, proceed to the pruned inference step. In pruned inference step, we select the set of important visual tokens in the prefill stage and prune the other unimportant tokens. After inference, action information and token information are used to update action memory and token memory.
Refer to caption: x2.png

## 3 FlashVLA

The FlashVLA architecture is illustrated in Fig.[2](https://arxiv.org/html/2505.21200v1#S2.F2). In the following, we first introduce the standard formulation of VLA models in Section[3.1](https://arxiv.org/html/2505.21200v1#S3.SS1). We then detail our visual token selection strategy and action reuse mechanism in Section [3.2](https://arxiv.org/html/2505.21200v1#S3.SS2) and Section [3.3](https://arxiv.org/html/2505.21200v1#S3.SS3), respectively. The overall algorithmic flow of FlashVLA is provided in Appendix [A](https://arxiv.org/html/2505.21200v1#A1) (Algorithm [1](https://arxiv.org/html/2505.21200v1#alg1)).

### 3.1 Preliminaries

VLA models extend vision-and-language foundation models for robotic control by generating actions conditioned on visual inputs and language prompts. A representative example is OpenVLA kim2024openvla, a 7B-parameter open-source model that establishes a strong baseline for general-purpose manipulation. It consists of a vision encoder that combines DINOv2 oquab2023dinov2 and SigLIP zhai2023sigmoid features, a projector that maps visual features into the language embedding space, and a LLaMA touvron2023llama language model as the backbone. Given an image and a text prompt, the encoder and projector produce a sequence of visual tokens $T^{v}=\{T^{v}_{1},T^{v}_{2},...T^{v}_{N}\}$, while the prompt is tokenized into $T^{l}=\{T^{l}_{1},T^{l}_{2},...,T^{l}_{M}\}$. These tokens are concatenated and passed to the language model, which autoregressively generates actions as control outputs. However, the large number of visual tokens, combined with highly repetitive action outputs, leads to significant computational overhead. These observations highlight two key sources of inefficiency in VLA models: visual token redundancy and temporal redundancy in action generation. In the following sections, we introduce methods to address both aspects and improve inference efficiency without additional training.

### 3.2 Visual Token Selection Strategy via Information Contribution Theory

We observe that VLA models exhibit visual token redundancy patterns similar to those found in VLMs chen2024image, where attention distributions are highly sparse beyond the initial few transformer layers (see Appendix [C](https://arxiv.org/html/2505.21200v1#A3)). This motivates our token selection strategy based on information contribution theory, which identifies tokens that best preserve the structure of the visual feature space. However, most recent architectures (e.g., OpenVLA) rely on Flash Attention dao2022flashattention, making traditional attention score-based selection infeasible. To address this, we directly operate on the attention output matrix and rank tokens by their estimated contribution to the global feature representation.

Let $\hat{T}^{v}\in\mathbb{R}^{N\times d}$ denote the attention output matrix corresponding to the visual tokens, where $N$ is the number of tokens and $d$ is the hidden dimension. To quantify the amount of information contained in $\hat{T}^{v}$, we perform singular value decomposition (SVD), where $\hat{T}^{v}=U\Sigma V^{\top}$. Here, $U\in\mathbb{R}^{N\times N}$ contains the left singular vectors, $V\in\mathbb{R}^{d\times d}$ contains the right singular vectors, and $\Sigma\in\mathbb{R}^{N\times d}$ is a diagonal matrix of singular values $\sigma_{i}$ sorted in descending order. Each token representation $\hat{T}^{v}(x)$ corresponds to a row of $\hat{T}^{v}$ and can be expressed as:

$$ $\hat{T}^{v}(x)=\sum_{i=1}^{r}u_{xi}\sigma_{i}v_{i}^{\top}$ (1) $$

where $r$ is the effective rank of the matrix. We define the information contribution score (ICS) of the $x$-th token as:

$$ $C(x)=\sum_{i=1}^{r}\left|u_{xi}\sigma_{i}\right|$ (2) $$

This score measures the magnitude of the token’s projection onto the dominant singular directions, weighted by their corresponding singular values. Tokens with higher $C(x)$ values are expected to contribute more significantly to the overall representation.

Figure: Figure 3: Comparison of visual token selection strategies on a sample image. Left: patches selected using the proposed ICS. Right: patches selected uniformly at random. Patches selected by ICS tend to focus on semantically meaningful and information-dense regions.
Refer to caption: x3.png

#### Theoretical Justification.

To theoretically justify the superiority of ICS-based token selection over random sampling, we analyze the information retention in the top-$K$ selected tokens. Let $S\subset\{1,\dots,N\}$ with $K\subset(1,N)$ be the number of selected token indices, and let $T_{S}^{v}\in\mathbb{R}^{K\times d}$ be the corresponding token matrix. The retained information is measured by the Frobenius norm of its projection onto the top-$r$ singular directions:

$$ $\mathcal{I}(S)=\left\|T_{S}^{v}V_{r}\right\|_{F}^{2}=\sum_{x\in S}\sum_{i=1}^{ r}(u_{xi}\sigma_{i})^{2}$ (3) $$

Maximizing $\mathcal{I}(S)$ ensures the preservation of the dominant subspace of $\hat{T}^{v}$. Although $C(x)$ is defined via absolute values, it provides a greedy approximation to maximizing $\mathcal{I}(S)$. Specifically, by the Cauchy–Schwarz inequality:

$$ $C(x)^{2}\leq r\sum_{i=1}^{r}(u_{xi}\sigma_{i})^{2}$ (4) $$

Thus, ranking tokens by $C(x)$ identifies those with high energy in the top singular directions.The retained information of the top-$K$ tokens is:

$$ $\mathcal{I}(S_{C})=\sum_{x\in S_{C}}\sum_{i=1}^{k}(u_{xi}\sigma_{i})^{2}$ (5) $$

In contrast, for uniformly random selection, the expected information retained is:

$$ $\mathbb{E}[\mathcal{I}(S_{\text{rand}})]=\frac{K}{N}\sum_{x=1}^{N}\sum_{i=1}^{ r}(u_{xi}\sigma_{i})^{2}$ (6) $$

Since the top-$K$ tokens ranked by $C(x)$ dominate this global sum, we have $\mathcal{I}(S_{C})\geq\mathbb{E}[\mathcal{I}(S_{\text{rand}})]$. Fig. [3](https://arxiv.org/html/2505.21200v1#S3.F3) illustrates this phenomenon by showing that tokens selected via ICS tend to concentrate on information-rich regions and achieve higher information retention than randomly selected tokens. Therefore, the ICS-based selection strategy retains more structural information in practice.

### 3.3 Token-Aware Action Reuse Strategy

Action outputs in VLA models often exhibit minimal variation or remain identical across frames (Fig.[1](https://arxiv.org/html/2505.21200v1#S1.F1)), and can be regarded as redundant actions suitable for direct reuse to accelerate inference. As shown in Fig.[2](https://arxiv.org/html/2505.21200v1#S2.F2), FlashTrigger decides whether to reuse the previous action or perform a new pruned inference. It consists of Action Memory, Token Memory, and a Trigger Thinking module. To ensure stability, reuse is not applied in the first two frames; the current frame is denoted as the $s$-th with $s>2$. At the action level, consistency is measured by the variation in action vectors $\vec{A}$. Action Memory stores the outputs from the previous two frames, $\vec{A}(s-2)$ and $\vec{A}(s-1)$, and computes the angle $\alpha$ between them to quantify the change:

$$ $\alpha(s)=Arccos(\frac{\vec{A}(s-2)\cdot\vec{A}(s-1)}{||\vec{A}(s-2)||\times|| \vec{A}(s-1)||})$ (7) $$

In token level, the change of set $I$ computed in Section [3.2](https://arxiv.org/html/2505.21200v1#S3.SS2) is used to determine the degree of change in environment with a VLA model perspective. The Token Memory dynamically updates and stores the computed $I$ from the previous two frames: $I(s-2)$ and $I(s-1)$. We calculate the intersection ratio $\phi$ between $I(s-2)$ and $I(s-1)$ to determine the extent of the change of $I$:

$$ $\phi(s)=\frac{Len\left[I(s-2)\cap I(s-1)\right]}{Len\left[I(s-1)\right]}$ (8) $$

where $Len(\cdot)$ returns the number of elements in the set.

At the same time, the lower limit of $\alpha(s)$ change is denoted by $\varepsilon_{1}$. We define $\delta$ as the maximum number of allowed changes in the set of visual tokens at the two action steps before and after. Thus the lower limit of the threshold $\varepsilon_{2}$ at which $\phi(s)$ is allowed to change can be defined:

$$ $\varepsilon_{2}=1-\frac{\delta}{Len\left[I(s-1)\right]}$ (9) $$

Before each inference, the Trigger Thinking module thinks ahead about whether this inference should directly reuse $\vec{A}(s-1)$ or recalculate how to act. It can be represented as:

$$ $Trigger\ Thinking=\left\{\begin{aligned} &Reuse\ Action,\ &if\ \alpha(s) \textgreater\varepsilon_{1}\ and\ \phi(s)\textgreater\varepsilon_{2}\\ &Pruned\ Inference,\ &else\\ \end{aligned}\right.$ (10) $$

When the reuse condition is not met, VLA performs pruned inference using the informative visual token set $I$ instead of the full token set. In other words, FlashVLA consistently accelerates the inference process, regardless of whether the action is reused.

## 4 Experiment

### 4.1 Experimental Setup

#### Evaluation Environment.

We evaluate the performance of FlashVLA on the LIBERO simulation benchmark, which features a simulated Franka Emika Panda robotic arm and provides multimodal demonstration data, including camera observations, robot states, task labels, and delta end-effector pose actions. The benchmark consists of four task suites—LIBERO-Spatial, LIBERO-Object, LIBERO-Goal, and LIBERO-Long—each comprising 500 expert demonstrations across 10 tasks. These suites are designed to test policy generalization under varying spatial layouts, object types, goal specifications, and long-horizon task sequences.

#### Implementation Details.

We apply the FlashVLA framework to accelerate the OpenVLA model fine-tuned on the LIBERO simulation benchmark. All experiments are conducted on a single NVIDIA H100 GPU. We report three evaluation metrics under different visual token configurations: success rate (SR), inference latency, and visual-token FLOPs. Latency is measured via wall-clock time, and FLOPs are computed following the method described in Appendix [B](https://arxiv.org/html/2505.21200v1#A2). To assess real-world speedup, we utilize the torch.profiler tool for runtime profiling.
FlashVLA includes a threshold-based action reuse mechanism whose sensitivity is governed by two hyperparameters, $\varepsilon_{1}$ and $\varepsilon_{2}$. Unless otherwise specified, we fix $\varepsilon_{1}=2$ and assign $\delta$ values based on the number of visual tokens as follows: ${(192,3),\ (160,4.5),\ (128,5),\ (96,5.5)}$. The $\delta$ values are converted to $\varepsilon_{2}$ using Equation [9](https://arxiv.org/html/2505.21200v1#S3.E9). A detailed hyperparameter sensitivity study is presented in Section [4.3](https://arxiv.org/html/2505.21200v1#S4.SS3).

**Table 1: Main results of FlashVLA under different visual token budgets across four task suites in the LIBERO benchmark. We report success rate (SR), visual-token FLOPs, and inference latency at five token settings. With 160 visual tokens, FlashVLA achieves a strong balance between SR and efficiency—reducing FLOPs by 55.7% and latency by 36.0%—while maintaining comparable or even improved success rates across most tasks.**
| Task / Visual token | 256<br>(Baseline) | 192<br>(75%) | 160<br>(62.5%) | 128<br>(50%) | 96<br>(37.5%) |  |
| --- | --- | --- | --- | --- | --- | --- |
|  | SR (%) | 84.2 | 81.8 ($-$ 2.4) | 82.6 ($-$ 1.6) | 75.4 ($-$ 8.8) | 67 ($-$ 17.2) |
| LIBERO-Spatial | Flops ($\scalebox{0.8}{10}^{\scalebox{0.6}{12}}$) | 1.31 | 0.8 ($\downarrow$ 38.9%) | 0.66 ($\downarrow$ 49.6%) | 0.51 ($\downarrow$ 61.1%) | 0.43 ($\downarrow$ 67.2%) |
|  | Latency (ms) | 82.7 | 62.7 ($\downarrow$ 24.2%) | 61.2 ($\downarrow$ 26.0%) | 58.1 ($\downarrow$ 29.7%) | 58.9 ($\downarrow$ 28.8%) |
|  | SR (%) | 86.4 | 86.6 ($+$ 0.2) | 86.6 ($+$ 0.2) | 85.2 ($-$ 1.2) | 83.6 ($-$ 2.8) |
| LIBERO-Object | Flops ($\scalebox{0.8}{10}^{\scalebox{0.6}{12}}$) | 1.31 | 0.74 ($\downarrow$ 43.5%) | 0.57 ($\downarrow$ 56.5%) | 0.42 ($\downarrow$ 67.9%) | 0.33 ($\downarrow$ 74.8%) |
|  | Latency (ms) | 82.7 | 58.8 ($\downarrow$ 28.9%) | 53.1 ($\downarrow$ 35.8%) | 45.3 ($\downarrow$ 45.2%) | 47.2 ($\downarrow$ 42.9%) |
|  | SR (%) | 75.4 | 76.2 ($+$ 0.8) | 78.8 ($+$ 3.4) | 76.8 ($+$ 1.4) | 70.2 ($-$ 5.2) |
| LIBERO-Goal | Flops ($\scalebox{0.8}{10}^{\scalebox{0.6}{12}}$) | 1.31 | 0.71 ($\downarrow$ 45.8%) | 0.6 ($\downarrow$ 54.2%) | 0.49 ($\downarrow$ 62.6%) | 0.37 ($\downarrow$ 71.8%) |
|  | Latency (ms) | 82.7 | 55.2 ($\downarrow$ 33.3%) | 56.8 ($\downarrow$ 31.3%) | 54.1 ($\downarrow$ 34.6%) | 53.8 ($\downarrow$ 34.9%) |
|  | SR (%) | 51.4 | 50.2 ($-$ 1.2) | 46.8 ($-$ 4.6) | 46.4 ($-$ 5.0) | 45.2 ($-$ 6.2) |
| LIBERO-Long | Flops ($\scalebox{0.8}{10}^{\scalebox{0.6}{12}}$) | 1.31 | 0.54 ($\downarrow$ 58.8%) | 0.47 ($\downarrow$ 64.1%) | 0.4 ($\downarrow$ 69.5%) | 0.32 ($\downarrow$ 75.6%) |
|  | Latency (ms) | 82.7 | 42.43 ($\downarrow$ 48.7%) | 40.35 ($\downarrow$ 51.2%) | 38.31 ($\downarrow$ 53.7%) | 44.05 ($\downarrow$ 46.7%) |
|  | SR (%) | 74.4 | 73.7 ($-$ 0.7) | 73.7 ($-$ 0.7) | 71.0 ($-$ 3.4) | 66.5 ($-$ 7.9) |
| Average | Flops ($\scalebox{0.8}{10}^{\scalebox{0.6}{12}}$) | 1.31 | 0.70 ($\downarrow$ 46.6%) | 0.58 ($\downarrow$ 55.7%) | 0.46 ($\downarrow$ 64.9%) | 0.36 ($\downarrow$ 72.5%) |
|  | Latency (ms) | 82.7 | 54.8 ($\downarrow$ 33.7%) | 52.9 ($\downarrow$ 36.0%) | 49.0 ($\downarrow$ 40.7%) | 51.0 ($\downarrow$ 38.3%) |

### 4.2 Main Results on LIBERO Benchmark

We evaluate the performance of FlashVLA across four task suites in the LIBERO benchmark under varying visual token budgets. As shown in Table [1](https://arxiv.org/html/2505.21200v1#S4.T1), the 160-token configuration (62.5% of the original) offers the best trade-off between accuracy and efficiency. Compared to the full 256-token baseline, it reduces visual-token FLOPs by 55.7% (from 1.31 to 0.58 $\times 10^{12}$) and lowers inference latency by 36.0% (from 82.7ms to 52.9ms), while maintaining the same average success rate (73.7% vs. 74.4%).
Interestingly, we observe a slight performance gain at 160 tokens in both LIBERO-Object and LIBERO-Goal, where the success rate increases from 86.4% to 86.6% and from 75.4% to 78.8%, respectively. This suggests that modest token pruning may even help mitigate redundancy and stabilize policy execution. In contrast, LIBERO-Long is more sensitive to pruning, showing a larger SR decline when the token count drops below 160. Nevertheless, even in such cases, FlashVLA achieves substantial savings in computational cost (e.g., 64.1% FLOPs reduction at 160 tokens).
These results highlight that FlashVLA, particularly at the 160-token configuration, significantly improves inference efficiency without compromising performance, making it suitable for real-world deployment across a wide range of embodied tasks.
Further, we visualize the trajectories of FlashVLA and the baseline during successful task executions (Fig. [6](https://arxiv.org/html/2505.21200v1#S4.F6)), showing that FlashVLA exhibits smoother and more stable motion while achieving comparable outcomes.

Figure: Figure 4: FLOPs breakdown of FlashVLA across four LIBERO tasks under different visual token budgets. Each bar shows the cumulative reduction in FLOPs contributed by token pruning and computation reuse. FlashVLA consistently operates below the baseline FLOPs (dashed line), demonstrating the effectiveness of the dual-path acceleration strategy.
Refer to caption: x4.png

### 4.3 Ablation Study

#### Effect of Token Pruning and Action Reuse.

To assess the contribution of each component in FlashVLA, we conduct ablation studies on the LIBERO-Spatial suite by disabling Pruned Inference and Action Reuse individually. As shown in Table [2](https://arxiv.org/html/2505.21200v1#S4.T2), both modules are critical for efficient inference with minimal performance loss. Removing Action Reuse (w/o Action Reuse) maintains the benefit of token pruning and achieves significant FLOPs reduction (e.g., 0.66 at 160 tokens vs. 0.85 without reuse), while maintaining comparable success rate. This indicates that Action Reuse primarily improves efficiency rather than accuracy. In contrast, disabling Pruned Inference (w/o Pruned Inference) results in consistently higher FLOPs across all token settings, with only marginal SR improvement—for example, at 128 tokens, FLOPs increase from 0.51 (FlashVLA) to 0.97 ($\times 10^{12}$), while SR improves from 75.4% to 81.0%. The full FlashVLA configuration combines both strategies and achieves the best trade-off between performance and efficiency. Fig. [4](https://arxiv.org/html/2505.21200v1#S4.F4) further demonstrates that the combination of both mechanisms effectively reduces the computational cost of VLA models.

#### Component Analysis of Action Reuse Module.

To evaluate the internal design of the Action Reuse module in FlashVLA, we conduct a component-level ablation on the LIBERO-Spatial suite by removing either the action vector signal (w/o ActionVector) or the token information signal (w/o TokenSet). As shown in Table [2](https://arxiv.org/html/2505.21200v1#S4.T2), disabling either component degrades overall performance. Without the action vector, the success rate drops notably under tight token budgets (e.g., 82.6% $\rightarrow$ 65.4% at 96 tokens), indicating that temporal consistency in action space is crucial for reliable reuse. Without token stability, the model tends to reuse too aggressively, achieving the lowest FLOPs (e.g., 0.29 at 96 tokens) but unstable control (e.g., SR drops to 62.2%). These results highlight the complementary roles of both signals: the action vector captures temporal continuity, while token stability reflects environmental change. Together, they enable the reuse module to balance efficiency and robustness.

**Table 2: We examine the effects of removing the two core modules—Pruned Inference and Action Reuse—as well as the impact of disabling the ActionVector and TokenSet components within the reuse mechanism. FlashVLA consistently achieves the best balance between accuracy and efficiency, while removing either module or component leads to higher FLOPs or reduced performance.**
| Method | 256 Tokens | 192 Tokens | 160 Tokens | 128 Tokens | 96 Tokens |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| SR<br>(%) | FLOPs<br>($\scalebox{0.8}{1\!0}^{\scalebox{0.6}{12}}$) | SR<br>(%) | FLOPs<br>($\scalebox{0.8}{1\!0}^{\scalebox{0.6}{12}}$) | SR<br>(%) | FLOPs<br>($\scalebox{0.8}{1\!0}^{\scalebox{0.6}{12}}$) | SR<br>(%) | FLOPs<br>($\scalebox{0.8}{1\!0}^{\scalebox{0.6}{12}}$) | SR<br>(%) | FLOPs<br>($\scalebox{0.8}{1\!0}^{\scalebox{0.6}{12}}$) |  |
| w/o Action Reuse | 84.2 | 1.31 | 84.6 | 1.00 | 83.6 | 0.85 | 78.2 | 0.69 | 67.8 | 0.54 |
| w/o Pruned Inference | 84.2 | 1.31 | 82.2 | 1.04 | 80.6 | 1.01 | 81.0 | 0.97 | 80.2 | 0.97 |
| w/o ActionVector for Action Reuse | 84.2 | 1.31 | 81.6 | 0.68 | 79.6 | 0.56 | 73.2 | 0.44 | 65.4 | 0.35 |
| w/o TokenSet for Action Reuse | 84.2 | 1.31 | 76.4 | 0.52 | 74.8 | 0.44 | 73.4 | 0.37 | 62.2 | 0.29 |
| FlashVLA | 84.2 | 1.31 | 81.8 | 0.80 | 82.6 | 0.66 | 75.4 | 0.51 | 67.0 | 0.43 |

Figure: Figure 5: Trajectory of action. We visualize the trajectory of action in 3-dimensional space. The location of red dashed box illustrates the smoother trajectory of FlashVLA for the same task.
Refer to caption: x5.png

#### Hyperparameter Sensitivity.

We conduct experiments to analyze the impact of two hyperparameters, $\varepsilon_{1}$ and $\delta$, on performance and efficiency, as shown in Fig.[6](https://arxiv.org/html/2505.21200v1#S4.F6). Fig.[6](https://arxiv.org/html/2505.21200v1#S4.F6)(a) shows that varying $\varepsilon_{1}$ has negligible effect on both success rate and FLOPs, indicating that our method is largely insensitive to this parameter. In contrast, Fig. [6](https://arxiv.org/html/2505.21200v1#S4.F6)(b) shows that $\delta$ significantly affects both metrics: increasing $\delta$ reduces computation cost but leads to a drop in performance. This provides flexibility to trade-off accuracy and efficiency based on application needs.

**Table 3: Comparison between FlashVLA and FastV on the LIBERO-Object task suite under various visual token budgets.**
| Method / Visual token | 256<br>(Baseline) | 192<br>(75%) | 160<br>(62.5%) | 128<br>(50%) | 96<br>(37.5%) |  |
| --- | --- | --- | --- | --- | --- | --- |
|  | SR (%) | 86.4 | 86.2 ($-$ 0.2) | 84.8 ($-$ 1.6) | 85.2 ($-$ 1.2) | 85.2 ($-$ 1.2) |
| FastV chen2024image | Flops ($\scalebox{0.8}{10}^{\scalebox{0.6}{12}}$) | 1.31 | 1.00 ($\downarrow$ 23.7%) | 0.85 ($\downarrow$ 35.1%) | 0.69 ($\downarrow$ 47.3%) | 0.54 ($\downarrow$ 58.8%) |
|  | Latency (ms) | 82.7 | 81.3 ($\downarrow$ 1.7%) | 79.9 ($\downarrow$ 3.4%) | 78.9 ($\downarrow$ 4.6%) | 77.8 ($\downarrow$ 5.9%) |
|  | SR (%) | 86.4 | 86.6 ($+$ 0.2) | 86.6 ($+$ 0.2) | 85.2 ($-$ 0.8) | 83.6 ($-$ 2.8) |
| FlashVLA | Flops ($\scalebox{0.8}{10}^{\scalebox{0.6}{12}}$) | 1.31 | 0.74 ($\downarrow$ 51.1%) | 0.57 ($\downarrow$ 56.5%) | 0.42 ($\downarrow$ 67.3%) | 0.33 ($\downarrow$ 74.8%) |
|  | Latency (ms) | 82.7 | 58.8 ($\downarrow$ 28.9%) | 53.1 ($\downarrow$ 35.8%) | 45.3 ($\downarrow$ 45.2%) | 47.2 ($\downarrow$ 42.9%) |

### 4.4 Comparison with Token Pruning Methods

FlashVLA is compared with FastV chen2024image, a FlashVLA is compared with FastV chen2024image, a representative dynamic token pruning baseline on the LIBERO-Object suite under varying visual token budgets. As shown in Table [3](https://arxiv.org/html/2505.21200v1#S4.T3), FlashVLA consistently achieves comparable or better performance with lower FLOPs. At 160 tokens, for example, it attains a higher success rate (86.6% vs. 84.8%) while reducing FLOPs from 0.85 to 0.57 ($\times 10^{12}$).
While both methods fall under the dynamic token pruning paradigm, a key advantage of FlashVLA is compatibility with FlashAttention dao2022flashattention, a memory-efficient and GPU-optimized attention kernel widely used in LLMs. This enables FlashVLA to achieve lower memory overhead and faster inference, making it suitable for real-time deployment.

**Table 4: Performance in VLAbench**
| Visual token | SR(%) | Flops ($\scalebox{0.8}{10}^{\scalebox{0.6}{12}}$) |
| --- | --- | --- |
| 256 (baseline) | 7.0 | 1.31 |
| 192 | 8.0 ($+$ 1.0) | 0.62 ($\downarrow$ 52.7%) |
| 160 | 5.0 ($-$ 2.0) | 0.62 ($\downarrow$ 52.7%) |
| 128 | 6.0 ($-$ 1.0) | 0.41 ($\downarrow$ 68.7%) |
| 96 | 7.0 ($+$ 0.0) | 0.30 ($\downarrow$ 77.1%) |

### 4.5 Generalization to Other Environments

To assess the generality of our approach, we evaluate it on VLAbench zhang2024vlabench, a simulated robot environment featuring more diverse and challenging tasks. Specifically, we test on the Select Painting task using OpenVLA with LoRA hu2022lora-fine-tuned weights provided by the authors. As shown in Table [4](https://arxiv.org/html/2505.21200v1#S4.T4), although the overall success rate is low due to task difficulty, our method significantly reduces computational cost while preserving baseline performance.

## 5 Conclusion

We propose FlashVLA, the first training-free and plug-and-play acceleration framework that enables action reuse in VLA models. By exploiting two forms of redundancy—temporal coherence across consecutive actions and visual token redundancy—FlashVLA improves inference efficiency through token-aware action reuse and information-guided visual token pruning. Specifically, it reduces unnecessary computation both across action steps and within input tokens. Experiments on the LIBERO benchmark show that FlashVLA reduces FLOPs by 55.7% and latency by 36.0%, with only a 0.7% drop in success rate—demonstrating its practicality, effectiveness, and scalability for efficient VLA inference. In future work, we plan to explore additional inference acceleration techniques further tailored to the unique characteristics of VLA models.

## References

- [1]
M. Ahn, A. Brohan, N. Brown, Y. Chebotar, O. Cortes, B. David, C. Finn, C. Fu, K. Gopalakrishnan, K. Hausman, et al.
Do as i can, not as i say: Grounding language in robotic affordances.
arXiv preprint arXiv:2204.01691, 2022.
- [2]
J. Bai, S. Bai, S. Yang, S. Wang, S. Tan, P. Wang, J. Lin, C. Zhou, and J. Zhou.
Qwen-vl: A frontier large vision-language model with versatile abilities.
arXiv preprint arXiv:2308.12966, 1(2):3, 2023.
- [3]
K. Black, N. Brown, D. Driess, A. Esmail, M. Equi, C. Finn, N. Fusai, L. Groom, K. Hausman, B. Ichter, et al.
$\pi$0: A vision-language-action flow model for general robot control, 2024.
URL https://arxiv. org/abs/2410.24164.
- [4]
A. Brohan, N. Brown, J. Carbajal, Y. Chebotar, J. Dabis, C. Finn, K. Gopalakrishnan, K. Hausman, A. Herzog, J. Hsu, et al.
Rt-1: Robotics transformer for real-world control at scale.
arXiv preprint arXiv:2212.06817, 2022.
- [5]
C.-L. Cheang, G. Chen, Y. Jing, T. Kong, H. Li, Y. Li, Y. Liu, H. Wu, J. Xu, Y. Yang, et al.
Gr-2: A generative video-language-action model with web-scale knowledge for robot manipulation.
arXiv preprint arXiv:2410.06158, 2024.
- [6]
J. Chen, L. Ye, J. He, Z.-Y. Wang, D. Khashabi, and A. Yuille.
Efficient large multi-modal models via visual context compression.
In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024.
- [7]
L. Chen, H. Zhao, T. Liu, S. Bai, J. Lin, C. Zhou, and B. Chang.
An image is worth 1/2 tokens after layer 2: Plug-and-play inference acceleration for large vision-language models.
In European Conference on Computer Vision, pages 19–35. Springer, 2024.
- [8]
L. Chen, H. Zhao, T. Liu, S. Bai, J. Lin, C. Zhou, and B. Chang.
An image is worth 1/2 tokens after layer 2: Plug-and-play inference acceleration for large vision-language models.
In European Conference on Computer Vision, pages 19–35. Springer, 2024.
- [9]
S. Chen, X. Chen, C. Zhang, M. Li, G. Yu, H. Fei, H. Zhu, J. Fan, and T. Chen.
Ll3da: Visual interactive instruction tuning for omni-3d understanding reasoning and planning.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 26428–26438, 2024.
- [10]
X. Chen, B. Jiang, W. Liu, Z. Huang, B. Fu, T. Chen, and G. Yu.
Executing your commands via motion diffusion in latent space.
In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 18000–18010, 2023.
- [11]
C. Chi, Z. Xu, S. Feng, E. Cousineau, Y. Du, B. Burchfiel, R. Tedrake, and S. Song.
Diffusion policy: Visuomotor policy learning via action diffusion.
The International Journal of Robotics Research, page 02783649241273668, 2023.
- [12]
T. Dao, D. Fu, S. Ermon, A. Rudra, and C. Ré.
Flashattention: Fast and memory-efficient exact attention with io-awareness.
Advances in neural information processing systems, 35:16344–16359, 2022.
- [13]
J. Duan, W. Yuan, W. Pumacay, Y. R. Wang, K. Ehsani, D. Fox, and R. Krishna.
Manipulate-anything: Automating real-world robots using vision-language models.
arXiv preprint arXiv:2406.18915, 2024.
- [14]
H.-S. Fang, H. Fang, Z. Tang, J. Liu, C. Wang, J. Wang, H. Zhu, and C. Lu.
Rh20t: A comprehensive robotic dataset for learning diverse skills in one-shot.
arXiv preprint arXiv:2307.00595, 2023.
- [15]
Z. Hou, T. Zhang, Y. Xiong, H. Pu, C. Zhao, R. Tong, Y. Qiao, J. Dai, and Y. Chen.
Diffusion transformer policy.
arXiv preprint arXiv:2410.15959, 2024.
- [16]
E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, W. Chen, et al.
Lora: Low-rank adaptation of large language models.
ICLR, 1(2):3, 2022.
- [17]
B. Jiang, X. Chen, W. Liu, J. Yu, G. Yu, and T. Chen.
Motiongpt: Human motion as a foreign language.
Advances in Neural Information Processing Systems, 36:20067–20079, 2023.
- [18]
A. Khazatsky, K. Pertsch, S. Nair, A. Balakrishna, S. Dasari, S. Karamcheti, S. Nasiriany, M. K. Srirama, L. Y. Chen, K. Ellis, et al.
Droid: A large-scale in-the-wild robot manipulation dataset.
arXiv preprint arXiv:2403.12945, 2024.
- [19]
M. J. Kim, C. Finn, and P. Liang.
Fine-tuning vision-language-action models: Optimizing speed and success.
arXiv preprint arXiv:2502.19645, 2025.
- [20]
M. J. Kim, K. Pertsch, S. Karamcheti, T. Xiao, A. Balakrishna, S. Nair, R. Rafailov, E. Foster, G. Lam, P. Sanketi, et al.
Openvla: An open-source vision-language-action model.
arXiv preprint arXiv:2406.09246, 2024.
- [21]
K. Y. Li, S. Goyal, J. D. Semedo, and J. Z. Kolter.
Inference optimal vlms need only one visual token but larger models.
arXiv preprint arXiv:2411.03312, 2024.
- [22]
Q. Li, Y. Liang, Z. Wang, L. Luo, X. Chen, M. Liao, F. Wei, Y. Deng, S. Xu, Y. Zhang, et al.
Cogact: A foundational vision-language-action model for synergizing cognition and action in robotic manipulation.
arXiv preprint arXiv:2411.19650, 2024.
- [23]
X. Li, K. Hsu, J. Gu, K. Pertsch, O. Mees, H. R. Walke, C. Fu, I. Lunawat, I. Sieh, S. Kirmani, et al.
Evaluating real-world robot manipulation policies in simulation.
arXiv preprint arXiv:2405.05941, 2024.
- [24]
X. Li, M. Liu, H. Zhang, C. Yu, J. Xu, H. Wu, C. Cheang, Y. Jing, W. Zhang, H. Liu, et al.
Vision-language foundation models as effective robot imitators.
arXiv preprint arXiv:2311.01378, 2023.
- [25]
B. Liu, Y. Zhu, C. Gao, Y. Feng, Q. Liu, Y. Zhu, and P. Stone.
Libero: Benchmarking knowledge transfer for lifelong robot learning.
Advances in Neural Information Processing Systems, 36:44776–44791, 2023.
- [26]
J. Liu, M. Liu, Z. Wang, L. Lee, K. Zhou, P. An, S. Yang, R. Zhang, Y. Guo, and S. Zhang.
Robomamba: Multimodal state space model for efficient robot reasoning and manipulation.
arXiv preprint arXiv:2406.04339, 2024.
- [27]
S. Liu, L. Wu, B. Li, H. Tan, H. Chen, Z. Wang, K. Xu, H. Su, and J. Zhu.
Rdt-1b: a diffusion foundation model for bimanual manipulation.
arXiv preprint arXiv:2410.07864, 2024.
- [28]
T. Liu, L. Shi, R. Hong, Y. Hu, Q. Yin, and L. Zhang.
Multi-stage vision token dropping: Towards efficient multimodal large language model.
arXiv preprint arXiv:2411.10803, 2024.
- [29]
Y. Liu, J. I. Hamid, A. Xie, Y. Lee, M. Du, and C. Finn.
Bidirectional decoding: Improving action chunking via closed-loop resampling.
arXiv preprint arXiv:2408.17355, 2024.
- [30]
S. Nair, A. Rajeswaran, V. Kumar, C. Finn, and A. Gupta.
R3m: A universal visual representation for robot manipulation.
arXiv preprint arXiv:2203.12601, 2022.
- [31]
M. Oquab, T. Darcet, T. Moutakanni, H. V. Vo, M. Szafraniec, V. Khalidov, P. Fernandez, D. Haziza, F. Massa, A. El-Nouby, R. Howes, P.-Y. Huang, H. Xu, V. Sharma, S.-W. Li, W. Galuba, M. Rabbat, M. Assran, N. Ballas, G. Synnaeve, I. Misra, H. Jegou, J. Mairal, P. Labatut, A. Joulin, and P. Bojanowski.
Dinov2: Learning robust visual features without supervision, 2023.
- [32]
A. O’Neill, A. Rehman, A. Maddukuri, A. Gupta, A. Padalkar, A. Lee, A. Pooley, A. Gupta, A. Mandlekar, A. Jain, et al.
Open x-embodiment: Robotic learning datasets and rt-x models: Open x-embodiment collaboration 0.
In 2024 IEEE International Conference on Robotics and Automation (ICRA), pages 6892–6903. IEEE, 2024.
- [33]
S. Park, H. Kim, W. Jeon, J. Yang, B. Jeon, Y. Oh, and J. Choi.
Quantization-aware imitation-learning for resource-efficient robotic control.
arXiv preprint arXiv:2412.01034, 2024.
- [34]
K. Pertsch, K. Stachowicz, B. Ichter, D. Driess, S. Nair, Q. Vuong, O. Mees, C. Finn, and S. Levine.
Fast: Efficient action tokenization for vision-language-action models.
arXiv preprint arXiv:2501.09747, 2025.
- [35]
I. Singh, V. Blukis, A. Mousavian, A. Goyal, D. Xu, J. Tremblay, D. Fox, J. Thomason, and A. Garg.
Progprompt: Generating situated robot task plans using large language models.
In 2023 IEEE International Conference on Robotics and Automation (ICRA), pages 11523–11530. IEEE, 2023.
- [36]
W. Song, J. Chen, P. Ding, H. Zhao, W. Zhao, Z. Zhong, Z. Ge, J. Ma, and H. Li.
Accelerating vision-language-action model integrated with action chunking via parallel decoding.
arXiv preprint arXiv:2503.02310, 2025.
- [37]
H. Touvron, T. Lavril, G. Izacard, X. Martinet, M.-A. Lachaux, T. Lacroix, B. Rozière, N. Goyal, E. Hambro, F. Azhar, et al.
Llama: Open and efficient foundation language models.
arXiv preprint arXiv:2302.13971, 2023.
- [38]
J. Wen, M. Zhu, Y. Zhu, Z. Tang, J. Li, Z. Zhou, C. Li, X. Liu, Y. Peng, C. Shen, et al.
Diffusion-vla: Scaling robot foundation models via unified diffusion and autoregression.
arXiv preprint arXiv:2412.03293, 2024.
- [39]
J. Wen, Y. Zhu, J. Li, M. Zhu, Z. Tang, K. Wu, Z. Xu, N. Liu, R. Cheng, C. Shen, et al.
Tinyvla: Towards fast, data-efficient vision-language-action models for robotic manipulation.
IEEE Robotics and Automation Letters, 2025.
- [40]
S. Xu, Y. Wang, C. Xia, D. Zhu, T. Huang, and C. Xu.
Vla-cache: Towards efficient vision-language-action model via adaptive token caching in robotic manipulation.
arXiv preprint arXiv:2502.02175, 2025.
- [41]
G. Yan, Y.-H. Wu, and X. Wang.
Dnact: Diffusion guided multi-task 3d policy learning.
arXiv preprint arXiv:2403.04115, 2024.
- [42]
S. Yang, Y. Chen, Z. Tian, C. Wang, J. Li, B. Yu, and J. Jia.
Visionzip: Longer is better but not necessary in vision language models.
arXiv preprint arXiv:2412.04467, 2024.
- [43]
Y. Yue, Y. Wang, B. Kang, Y. Han, S. Wang, S. Song, J. Feng, and G. Huang.
Deer-vla: Dynamic inference of multimodal large language models for efficient robot execution.
Advances in Neural Information Processing Systems, 37:56619–56643, 2024.
- [44]
X. Zhai, B. Mustafa, A. Kolesnikov, and L. Beyer.
Sigmoid loss for language image pre-training.
In Proceedings of the IEEE/CVF international conference on computer vision, pages 11975–11986, 2023.
- [45]
S. Zhang, Q. Fang, Z. Yang, and Y. Feng.
Llava-mini: Efficient image and video large multimodal models with one vision token.
arXiv preprint arXiv:2501.03895, 2025.
- [46]
S. Zhang, Z. Xu, P. Liu, X. Yu, Y. Li, Q. Gao, Z. Fei, Z. Yin, Z. Wu, Y.-G. Jiang, and X. Qiu.
Vlabench: A large-scale benchmark for language-conditioned robotics manipulation with long-horizon reasoning tasks, 2024.
- [47]
Y. Zhang, C.-K. Fan, J. Ma, W. Zheng, T. Huang, K. Cheng, D. Gudovskiy, T. Okuno, Y. Nakata, K. Keutzer, et al.
Sparsevlm: Visual token sparsification for efficient vision-language model inference.
arXiv preprint arXiv:2410.04417, 2024.
- [48]
B. Zitkovich, T. Yu, S. Xu, P. Xu, T. Xiao, F. Xia, J. Wu, P. Wohlhart, S. Welker, A. Wahid, et al.
Rt-2: Vision-language-action models transfer web knowledge to robotic control.
In Conference on Robot Learning, pages 2165–2183. PMLR, 2023.

## Appendix A Algorithm flow of FlashVLA

This section provides a detailed description of the algorithmic workflow of FlashVLA, as outlined in Algorithm [1](https://arxiv.org/html/2505.21200v1#alg1). The overall execution is divided into two phases: initialization and iterative reasoning.

During the initialization phase (lines 1–5), the agent executes the first two steps without action reuse to establish initial context. For each of the first two frames, the model selects a subset of informative visual tokens using the strategy described in Section [3.2](https://arxiv.org/html/2505.21200v1#S3.SS2), performs pruned inference based on the selected tokens, executes the resulting action, and updates the Action Memory and Token Memory with the new observations and outputs.

The iterative phase begins thereafter (lines 6–19), and continues until the task is successfully completed. At each step, the FlashTrigger mechanism (Section [3.3](https://arxiv.org/html/2505.21200v1#S3.SS3)) determines whether the previous action can be reused. If reuse is triggered and the last step did not already reuse an action, the model directly reuses the previous output and sets the reuse flag. Otherwise, the model selects a new visual token subset, runs pruned inference, updates both memories, and resets the reuse flag. Regardless of reuse, the action is executed in the environment and the task state is updated.

Once the task is complete, the loop exits.

Figure: Algorithm 1 FlashVLA

## Appendix B Computation Cost Estimation

To analyze the computational efficiency of FlashVLA, we estimate the FLOPs consumed by the Multi-Head Attention (MHA) and Feed-Forward Network (FFN) modules, which dominate the cost of Transformer-based architectures. In VLA models, visual tokens typically account for more than 80% of the input, making them the primary contributor to overall inference cost. Since the number of language prompt tokens varies across tasks, we use the FLOPs associated with visual tokens as a consistent and representative measure of complexity.

The total FLOPs are estimated as:

$$ $\text{FLOPs}=(1-R)\times\left[L_{p}\cdot(4nd^{2}+2n^{2}d+2ndm)+(L-L_{p})\cdot( 4n_{p}d^{2}+2n_{p}^{2}d+2n_{p}dm)\right]$ (11) $$

where:

- •
$n$: total number of input tokens (visual + language),
- •
$d$: hidden dimension,
- •
$m$: intermediate dimension in the FFN module,
- •
$L$: total number of Transformer layers,
- •
$L_{p}$: layer index at which visual token pruning starts,
- •
$n_{p}$: number of visual tokens after pruning,
- •
$R$: action reuse rate.

By default, we set $L_{p}=2$ during the prefill stage, meaning that full-token computation is retained in the first two layers to preserve early-layer representation quality. During decoding, FlashVLA reuses token selections from the prefill stage and sets $L_{p}=0$. Therefore, the actual FLOPs of FlashVLA are slightly lower than the values reported in this paper, as both prefill and decoding stages are estimated using $L_{p}=2$ for consistency.

## Appendix C Visual Redundancy in VLA Models

Figure: Figure 7: Attention Map: Layer-wise attention map visualizations in VLA and VLM models. Both models exhibit uniform attention distribution in the first layer, while attention becomes increasingly sparse from the second layer onward. This pattern suggests growing redundancy in token interactions, motivating token pruning strategies in deeper layers
Refer to caption: extracted/6484531/figs/Figure7.png

Figure: Figure 8: Attention Score: Attention score distributions across transformer layers in a VLA model. The scores are computed by averaging attention weights over heads and selecting the attention received by each token from the final query position. The results show increasing sparsity from the second layer onward, where attention becomes concentrated on a small subset of tokens.
Refer to caption: extracted/6484531/figs/Figure8.png

To better understand the presence of visual redundancy in VLA models, we analyze the behavior of attention maps and attention scores across transformer layers. Figure [7](https://arxiv.org/html/2505.21200v1#A3.F7) shows the average attention maps of VLA and VLM models across different layers. We observe that both types of models exhibit similar patterns: in early layers, attention is distributed relatively uniformly across visual tokens, while starting from the second layer, the attention maps become increasingly sparse and concentrated on fewer regions. This layer-wise transition suggests that redundancy accumulates early in the encoding process, making some tokens less informative in deeper layers.

To further quantify this sparsification effect, we examine the attention scores of visual tokens computed from the last transformer layer. Specifically, we extract the raw attention weights from the model outputs as follows:

> layer_attention = layer_outputs[1] layer_attention_avg = torch.mean(layer_attention, dim=1)[0] attention_score = layer_attention_avg[-1]

Here, the attention weights are averaged over all heads, and the final row corresponds to the attention received by each visual token when queried by the final position (e.g., the action token or decoder query). We use this vector as the attention score distribution.

As shown in Figure [8](https://arxiv.org/html/2505.21200v1#A3.F8), the attention scores are nearly uniform across token positions in the first two layers. However, starting from the second layer, we observe a clear increase in variance, with attention values increasingly concentrated on a small subset of tokens. This indicates a growing redundancy among visual tokens in deeper layers—a phenomenon also observed in recent studies on VLMs chen2024image. These observations provide empirical evidence for the existence of token-level redundancy in VLA models and motivate our token pruning strategy.

## Appendix D Additional Experimental Details

### D.1 LIBERO Simulated Environment Benchmark

LIBERO is a novel benchmark designed for studying knowledge transfer in multitask and lifelong robot learning. It addresses the challenge of benchmarking knowledge transfer capabilities in robot learning systems, with a focus on manipulation tasks that require both declarative knowledge (about objects and spatial relationships) and procedural knowledge (about motion and behaviors) .

LIBERO provides four main task suites, each designed to evaluate different aspects of knowledge transfer:

#### LIBERO-Spatial

It contains 10 tasks that focus on transferring knowledge of spatial relationships. These tasks require robots to understand the spatial relationship between different objects and use this knowledge to complete the task. For example, the robot need to place objects according to a certain spatial layout, or navigate to the target position according to spatial clues in a complex environment. Through these tasks, its ability to master and apply the knowledge of spatial relationship is investigated.

#### LIBERO-Object

It consists of 10 tasks that require transferring object-related knowledge. Robots are expected to identify different objects, comprehend their attributes (e.g., color, shape, material) and functions (e.g., tool usage, container functionality), and manipulate the objects accordingly. Examples include classifying objects based on their attributes or utilizing tools to perform specific tasks. These tasks serve to measure the robot’s capability to transfer knowledge related to objects.

#### LIBERO-Goal

It has 10 tasks that emphasize transferring goal-oriented knowledge. Robots must precisely comprehend the task objectives, determine the essential steps and strategies for achieving them. For example, it should be able to accurately prioritize goals in multi - task scenarios or break down complex goals into manageable sub - goals and accomplish them step by step. The evaluation aims to assess the robot’s ability to transfer and apply goal - oriented knowledge effectively.

#### LIBERO-Long

It has 10 tasks primarily designed to evaluate the robot’s knowledge transfer ability over extended learning periods. These tasks typically involve learning and integrating knowledge across multiple tasks. The investigation focuses on whether the robot can effectively apply the experience, skills, and knowledge acquired from previous tasks to new subsequent tasks, thereby achieving continuous performance enhancement and improved adaptability. Furthermore, it emphasizes the accumulation, updating, transfer, and application of knowledge throughout the long - term learning process.

Figure: Figure 9: Sample Frame of Four Main Task Suites.
Refer to caption: x7.png

## Appendix E Limitations and future works

We propose FlashVLA, the first training-free and plug-and-play acceleration framework that enables action reuse in VLA models. Although our approach maintains the performance of the model while greatly reducing the amount of modeling operations and the actuallatency, there are limitations and shortcomings in our approach. First of all we have only tested in a simulated environment, lacking further validation in the real world. Second, we only performe experimental validation of a single-arm robot. In the future, we will further validate the advantages of our approach in extending our method to more robotic arms with more degrees of freedom.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 4
presentation: 2
questions: - How sensitive is performance to the thresholds ε1 (action angle) and ε2 (token overlap)?  Could these parameters be adaptively learned or adjusted at runtime?

- In scenarios with discontinuous or abrupt motion (e.g., contact manipulation), does the reuse mechanism still function reliably, or could it mis-predict stable states?

- There seems to be a critical contradiction in the description of the "FlashTrigger" mechanism (Section 3.3). Could the authors please clarify the action reuse trigger logic in Equation 6? Is the condition $\alpha(s) > \epsilon_1$ a typo, and should it be $\alpha(s) < \epsilon_1$? The current formulation seems to contradict the stated goal of reusing actions in "stable areas" where the angle change is small.

- The visual token selection strategy is applied after the first two layers ($L_p=2$) in the prefill stage. What is the rationale for this specific depth? How sensitive is the model's performance to this $L_p$ parameter?
soundness: 3
strengths: - FLASHVLA can be directly plugged into existing VLA models (e.g., OpenVLA, UniVLA) without retraining, which makes it both practical and reproducible.

- The extensive ablation studies on # of Tokens, different modules and diverse VLA architectures make the results convincing.
summary: This paper proposes FLASHVLA, a training-free acceleration framework for Vision-Language-Action (VLA) models. The method is motivated by the identification of two key redundancies: high similarity across consecutive action steps and high redundancy in visual tokens. Experiments on the LIBERO benchmark show that FLASHVLA can reduce FLOPs and latency.
weaknesses: - Both the similarity across consecutive action steps and across visual tokens have been well-studied. “The first training-free and plug-and-play acceleration framework that enables action reuse in VLA models” also needs more justification.

- The method's hyperparameters appear to require careful, per-setting tuning, which may limit reproducibility. Specifically, the parameter $\delta$, which controls the token set stability threshold $\epsilon_2$, is set to different values for each token budget (e.g., 3, 4.5, 5, 5.5).

- The experiments should be further strengthened. First, the experiments on other VLA acceleration baselines and other benchmarks should be included. Second, the evaluation is confined to simulation. While the simulation results on LIBERO are strong, the paper lacks validation on a real-world robot.

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 2
questions: As we know, real-world tasks are prone to visual perturbations and sensor noise, while robotic arms face a sim-to-real gap. Could the action reuse mechanism significantly compromise the execution accuracy of the robotic arm? How effective can visual token reduction remain in the face of real-world visual variations?
soundness: 3
strengths: 1. Substantial reduction in FLOPs and inference latency without additional fine-tuning;
2. The method is straightforward and can be integrated with models that use Flash Attention for inference.
summary: This paper proposes a training-free and plug-and-play acceleration framework named FlashVLA. The proposed method features a token-aware action reuse mechanism and a visual token selection strategy that integrate seamlessly with Flash Attention to avoid redundant computation. The experiments on the LIBERO simulation benchmark show that inference latency and the FLOPs of visual token computation are both decreased considerably without significantly sacrificing the success rate.
weaknesses: All the experiments are conducted on simulation manipulation benchmarks (LIBERO, VLABench). It lacks validation on tasks that involve highly dynamic actions (requiring frequent and rapid changes in actuators) and rapidly changing visual scenes (with significant perturbations in objects and background).

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 3
questions: - How stable is the reuse mechanism under long-horizon or dynamic-scene tasks?
- Can the reuse threshold be made adaptive, e.g., based on uncertainty or temporal confidence?
- Could the authors report real-world timing (wall-clock) results beyond FLOPs estimation?
soundness: 2
strengths: - Proposes a simple yet effective framework to reduce redundant computations in VLA inference.

- Training-free and compatible with FlashAttention, enabling easy integration into existing models.

- Demonstrates strong empirical results on multiple benchmarks.

- Includes detailed ablation and sensitivity analyses.
summary: This paper presents FLASHVLA, a training-free and plug-and-play acceleration framework for Vision-Language-Action (VLA) models. Instead of architectural re-design or retraining, the method targets two types of redundancy: (1) temporal similarity between consecutive actions and (2) redundancy among visual tokens. To address these, the authors propose a token-aware action reuse mechanism and an information-guided token pruning strategy based on singular value decomposition (SVD) and information contribution scores (ICS).
Experiments on LIBERO, UniVLA, and VLAbench show that FLASHVLA reduces FLOPs by 55.7% and latency by 36.0%, with only 0.7% performance drop. While the idea is appealing and practical, the methodology mainly combines known techniques (e.g., token pruning, reuse heuristics) with moderate novelty.
weaknesses: - The approach primarily combines known concepts (token pruning, reuse heuristics) without strong theoretical advancement.

- The method is evaluated mostly in simulated environments; real-robot deployment results are missing.

- Performance may depend on manually tuned thresholds; no adaptive mechanism is proposed.

- Works such as VLA-Cache [1], TinyVLA [2], EfficientVLA [3] should be discussed and experimentally compared.
- Some related token pruning methods should also be discussed and compared, such as AIM
[4], DART [5], VisPruner [6]


[1] Xu, Siyu, et al. "Vla-cache: Towards efficient vision-language-action model via adaptive token caching in robotic manipulation." arXiv preprint arXiv:2502.02175 (2025). \
[2] Wen, Junjie, et al. "Tinyvla: Towards fast, data-efficient vision-language-action models for robotic manipulation." IEEE Robotics and Automation Letters (2025). \
[3] Yang, Yantai, et al. "EfficientVLA: Training-Free Acceleration and Compression for Vision-Language-Action Models." arXiv preprint arXiv:2506.10100 (2025). \
[4] Zhong, Yiwu, et al. "Aim: Adaptive inference of multi-modal llms via token merging and pruning." Proceedings of the IEEE/CVF International Conference on Computer Vision. 2025. \
[5] Wen, Zichen, et al. "Stop looking for important tokens in multimodal language models: Duplication matters more." arXiv preprint arXiv:2502.11494 (2025). \
[6] Zhang, Qizhe, et al. "Beyond text-visual attention: Exploiting visual cues for effective token pruning in vlms." Proceedings of the IEEE/CVF International Conference on Computer Vision. 2025.