FastVLA: aufgabenabhängige, zeitlich adaptive Kompression visueller Tokens für VLA-Modelle

Abstract

Vision-Language-Action (VLA) models present a promising paradigm for general-purpose robot manipulation, but closed-loop deployment is often limited by inference efficiency: at each timestep, high-resolution, often multi-view images are encoded into hundreds of visual tokens that dominate transformer computation and latency. Token compression via attention is a natural solution but is challenging for VLA control because (1) decision-critical tokens are determined by the task, not generic visual saliency, and (2) the token budget varies substantially across steps, so static metrics and budgets waste computation or discard control-critical tokens. We introduce FastVLA, a training-free, task-aware, and temporally adaptive visual token compression framework. At each step, FastVLA scores token importance via task-to-vision attention and adaptively sets the compression rate from the importance-distribution uniformity, measured by an inverse-Simpson metric with online sliding-window calibration. We evaluate FastVLA on OpenVLA, OpenVLA-OFT, and CogACT across LIBERO and SIMPLER, and on a physical Franka Research 3 robot. In simulation, it reduces LLM-backbone FLOPs by 35-59% and action latency by 9-32% (a 1.09\times-1.46\times speedup) while maintaining task success, achieving a comparable or better efficiency-performance trade-off than existing plug-and-play token compression/pruning/reuse baselines. On the real robot, it cuts end-to-end latency by 20% (1.25\times speedup) at comparable success. Code is available at https://github.com/jiuyixu25/FastVLA.

1 Introduction

Vision-Language-Action (VLA) models have recently emerged as a compelling paradigm for general-purpose robot manipulation, enabling policies to predict low-level actions conditioned on natural-language tasks and visual observations [30, 15, 3, 22, 6]. By leveraging large-scale pretraining and large vision-language backbones, VLAs demonstrate strong generalization across objects, scenes, and task specifications, making them increasingly attractive for deployment in versatile manipulation systems. Despite their impressive capabilities, deploying these models in closed-loop control is often limited by inference efficiency [8]. At every control step, high-resolution (e.g., 224\times224) and frequently multi-view observations are encoded into hundreds of visual tokens [14, 10] that dominate the compute and latency of the vision-language-model (VLM) backbone during action prediction, far outweighing the few text tokens of a short task.

Yet not all visual tokens contribute equally to action prediction. In a typical manipulation step, only a small subset of tokens carries decision-critical information (e.g., the target object/place or the gripper–object contact region), while the rest are redundant or even distracting [26, 27, 11]. Reducing the number of visual tokens processed by the large-language-model (LLM) backbone, without sacrificing task performance, has therefore become a key direction for accelerating VLA inference [20, 21, 25].

However, directly applying VLM-specific token compression methods [4, 7, 29] to robotic control is often suboptimal, because these methods are designed for single-shot vision-language understanding, where the objective is to preserve global semantic content for perception tasks such as detection, captioning, or generation. Unlike image-based VLMs that process a single image, or video-based VLMs that encode a fixed sequence of frames, a VLA interacts with the environment through actions that directly shape its subsequent observations: at each step the agent receives a new observation conditioned on its previous action and predicts the next one. Visual tokens are thus not representations of a static scene but components of a sequential decision process, which sets token compression for VLA apart from its VLM counterpart in two respects. The first is that token relevance is governed by the task rather than by generic visual saliency (now standard practice in language-guided pruning), which we adopt as our importance signal rather than claim as a contribution. The second, and the focus of this work, is that the amount of decision-critical visual information varies drastically across control steps: some steps (e.g., target localization) rely on broad scene context, whereas others (e.g., grasping or contact) depend on a small, localized region. A single fixed compression rate is therefore inherently mismatched, wasting computation when the useful information is concentrated, and discarding necessary context when broader information is required.

Motivated by this, we propose FastVLA, a training-free visual token compression framework for efficient VLA inference whose core is a temporally adaptive, per-step compression rate. At each step, FastVLA scores visual-token importance with task-to-vision attention which is a training-free signal that a controlled comparison shows is more reliable for action prediction than vision-only or fused attention and then, crucially, decides how many tokens to keep from the shape of the resulting importance distribution. Specifically, it estimates the effective number of tokens the decision depends on via an inverse-Simpson uniformity measure, and maps this quantity through an online sliding-window calibration to a timestep-dependent compression rate: when the current step concentrates on few tokens relative to its recent history it prunes aggressively, and when the decision draws on broader context it prunes conservatively. By allocating the token budget where each decision needs it, FastVLA reduces LLM-backbone computation, speeds up action prediction, and improves closed-loop responsiveness, without caches or training.

We evaluate FastVLA on three open-source VLA models including OpenVLA [15], OpenVLA-OFT [14], and CogACT [16], across the widely used LIBERO [18] and SIMPLER [17] benchmarks, and on a physical Franka Research 3 robot. In simulation, FastVLA reduces LLM-backbone FLOPs by 35-59% and action latency by 9-32% (up to a 1.46\times speedup) while maintaining task success, yielding a comparable or even better efficiency-performance trade-off than existing training-free compression, pruning, and reuse baselines. On the real robot, it cuts end-to-end latency by 20% (1.25\times speedup) and raises the control frequency by up to 25% at comparable success. In summary, our contributions are:

• We propose FastVLA, a training-free, plug-and-play visual token compression framework that accelerates closed-loop VLA inference.
• We design a step-adaptive compression policy that sets a timestep-dependent token budget from the inverse-Simpson uniformity of the importance distribution under online sliding-window calibration.
• We validate FastVLA on OpenVLA/OpenVLA-OFT (LIBERO), CogACT (SIMPLER), and a physical Franka Research 3 robot, achieving substantial compute and latency reductions in simulation and a 1.25\times real-robot speedup with comparable task success.

2 Related Work

2.1 Vision-Language-Action Models for Robot Manipulation

Vision-Language-Action (VLA) models have emerged as a general-purpose paradigm for robot manipulation, predicting actions directly from natural-language tasks and visual observations and generalizing across objects, scenes, and task specifications. Early work such as SayCan [1] combines language-conditioned planning with learned low-level skills, while RT-1 [5] and RT-2 [30] scale language-conditioned visuomotor learning with large robot datasets and web-scale vision-language pretraining. In parallel, PaLM-E [9] and Octo [23] highlight the benefits of large pretrained representations across tasks and embodiments. More recently, foundation VLA models including OpenVLA [15] and OpenVLA-OFT [14], CogACT [16], and \pi_{0} [3] / \pi_{0.5} [10] demonstrate strong robustness and open-world generalization via heterogeneous multi-robot data and transformer backbones. Despite their capabilities, these models are typically billion-scale and rely on high-resolution (often multi-view) observations that are encoded into long visual-token sequences and processed by large transformers at every control step. This incurs substantial computation and end-to-end latency in closed-loop control, motivating inference-time methods that reduce redundant visual tokens while preserving task-critical information.

2.2 Visual Token Compression for Efficient VLA Inference

Because most VLA models [15, 14, 16, 3, 10] adopt VLM-style architectures, training-free token compressors built for VLMs are broadly applicable: they prune or merge visual tokens by token similarity (ToMe [4]), shallow-layer or cross-modal attention (FastV [7], SparseVLM [29], VisPruner [28]), or token diversity (DivPrune [2]). However, these methods are designed for single-image inference and apply a static pruning policy, so transferring them directly to VLA often degrades control performance.

Recent work therefore targets VLA inference along three lines: reuse- and cache-based methods that exploit cross-step temporal redundancy (VLA-Cache [26], FlashVLA [21]); importance-estimation methods that add task-, phase-, or motion-aware cues (SpecPrune-VLA [25], ADP [20], VLA-Pruner [19]); and hybrid or learned schemes that go beyond pruning (EfficientVLA [27], LightVLA [11]).

These methods still share limitations that FastVLA overcomes. Reuse and caching introduce cross-step state and cache-management overhead, so wall-clock gains can lag FLOP reductions; learned schemes such as LightVLA require training and are tied to a specific backbone, although at equal success they can reach a better compute–latency point than training-free methods. In addition, some VLM/VLA compression algorithms commit to a fixed compression ratio, adapting (if at all) only through auxiliary external signals such as end-effector motion. FastVLA differs on three axes: it is training-free, pruning independently at each step without caches; it conditions token importance on the language task; and, crucially, it makes the compression rate itself adaptive, reading the per-step concentration of task-relevant evidence via an inverse-Simpson uniformity signal calibrated against a short temporal window, spending tokens where the decision needs them and pruning harder where it does not.

3 Method

We propose FastVLA, a temporally adaptive and training-free visual token compression method that reduces the number of visual tokens processed by the VLA model’s LLM backbone (Fig. 1). FastVLA proceeds in two stages: it first scores visual-token importance with a task-conditioned attention signal, and then, as our core contribution, sets how many tokens to keep adaptively at each step from the concentration of that importance distribution. We present both stages below.

3.1 Preliminary: Visual Token Compression in VLA Models

Methods that reduce the visual-token cost of a VLA backbone fall into three families that differ in what they do to the token sequence. Token pruning permanently discards a subset of visual tokens at one or more layers, shortening the sequence processed by the subsequent layers; the removed tokens are not recovered. Token merging instead aggregates similar tokens into a smaller set of representative tokens, preserving part of the discarded information through pooling rather than hard deletion. Reuse/caching exploits temporal redundancy across control steps: token representations or key-value states computed at previous timesteps are cached and reused for regions that remain unchanged, so that only changed tokens are recomputed. These families are largely orthogonal and can be combined. FastVLA belongs to the pruning family: at every action step it performs a hard, task-conditioned top-K selection of visual tokens, with the retained budget set adaptively per step.

3.2 Task-conditioned visual token importance

A VLA policy is explicitly conditioned on the language task, so visual-token usage is driven by the task prompt rather than by generic visual saliency: the tokens that matter are those covering the target object/place and the interaction region named by the task. The design question is therefore which attention signal best captures this task-driven importance. Since selecting tokens by attention is already standard in VLM compression, we do not propose it as new but instead re-evaluate three candidate signals for VLA control: all-to-vision (naive cross-modal attention from the fused representation to visual tokens), task-to-vision (task tokens attending to visual tokens), and vision-to-vision (visual self-attention capturing perceptual saliency).

We progressively pruned visual tokens by each score and measured policy performance on LIBERO with OpenVLA-OFT (Fig. 2). Task-to-vision scoring was clearly the most robust: it retained near-saturated success under light-to-moderate compression (10%–50%) and preserved non-trivial performance even under aggressive compression (\geq 70\%), whereas vision-to-vision and all-to-vision degraded much faster and approached failure at 90%. We therefore adopt task-to-vision attention as the importance signal in the remainder of the method.

Formally, let \mathbf{T}\in\mathbb{R}^{M\times d} and \mathbf{V}\in\mathbb{R}^{N\times d} denote the task- and visual-token representations. Following scaled dot-product attention [24], we apply RMSNorm to obtain \tilde{\mathbf{T}} and \tilde{\mathbf{V}}, compute affinities \mathbf{S}=\tilde{\mathbf{T}}\tilde{\mathbf{V}}^{\mathsf{T}}/\sqrt{d}\in\mathbb{R}^{M\times N}, and apply a softmax over visual tokens to obtain attention weights \mathbf{A}. Averaging over a subset of task tokens \mathcal{Q} gives a per-token importance score:

s_{i}=\frac{1}{|\mathcal{Q}|}\sum_{q\in\mathcal{Q}}\mathbf{A}_{q,i},\quad i=1,\dots,N,

so that visual tokens consistently attended by the task context receive higher importance.

3.3 Adaptive Step-aware Compression Rate

Having fixed which tokens matter, the central question of our method is how many to keep at each step. In a closed-loop rollout, successive steps rely on visual information to very different extents. For example, approaching or grasping an object depends on a small localized region, whereas locating a target or verifying the scene requires broad context. Fig. 3 makes this concrete: within a single trial, the per-step importance distribution swings between nearly uniform (many tokens contribute comparably) and highly concentrated (a few tokens dominate). A fixed compression rate is therefore inherently mismatched because it wastes computation when the useful information is concentrated and discards decision-critical tokens when broader context is needed, so the rate should instead adapt to this per-step concentration.

We implement this in two steps: measure how concentrated the importance distribution is, then map that concentration to a per-step rate. To measure it, a natural choice is Shannon entropy, but with hundreds of visual tokens and a long tail of near-zero scores, normalized entropy varies only within a narrow band and is insensitive to concentration among the dominant tokens (Fig. 4), making it hard to map to distinct compression rates.

Inverse Simpson uniformity. We instead adopt the second-order effective-number measure (inverse Simpson) [12, 13], which emphasizes squared weights and thus down-weights the long tail while reporting the effective number of dominant tokens which is a better fit for the sparse, heavy-tailed importance distributions of VLA models, and one with a substantially larger dynamic range across steps. Over the top-K tokens we compute:

\begin{gathered}\mathbf{v}=\mathrm{TopK}(\{s_{i}\},K),\qquad q_{j}=\frac{v_{j}}{\sum_{m=1}^{K}v_{m}},\\[4.0pt]
K_{\text{eff}}^{(t)}=\frac{1}{\sum_{j=1}^{K}q_{j}^{2}},\qquad U^{(t)}=\frac{K_{\text{eff}}^{(t)}}{K},\end{gathered}

where U^{(t)}\in(0,1]: small values indicate concentrated attention (few tokens dominate), large values a more uniform distribution. Here K=\lceil(1-(\rho+\tau))N\rceil is the smallest budget the band can request; since K is fixed within a run and U^{(t)} enters the decision only through the calibration below, which is invariant to constant rescaling, this normalization cannot conflate concentration with budget.

Online step-adaptive rate. Online step-adaptive rate. Thresholding U^{(t)} against an absolute scale would require anchors that do not transfer: the range of U^{(t)} drifts across suites and backbones, so anchors fit on one setting misallocate the budget on another. We therefore calibrate U^{(t)} against its own recent temporal context through a sliding window \mathcal{W}^{(t)}=\{U^{(t-T)},\dots,U^{(t-1)}\} of length T. Letting U_{\min}^{(t)} and U_{\max}^{(t)} be the window extremes, the relative position

\alpha^{(t)}=\mathrm{clip}\!\left(\frac{U^{(t)}-U_{\min}^{(t)}}{U_{\max}^{(t)}-U_{\min}^{(t)}},\,0,\,1\right)

locates the current step within the ongoing execution: a small \alpha^{(t)} (more concentrated than the recent past) warrants aggressive pruning, a large \alpha^{(t)} (more uniform) warrants caution. We then map it to a per-step rate via a bounded linear projection centered at a target rate \rho:

\rho^{(t)}=\mathrm{clip}\big(\rho+\tau\,(1-2\alpha^{(t)}),\;\rho-\tau,\;\rho+\tau\big),

so the rate adapts within [\rho-\tau,\rho+\tau], where \rho sets the average compression (e.g., 50\%) and \tau the allowable deviation (e.g., \pm 10\%). Algorithm 1 summarizes the full per-step procedure.

4 Experiments

To evaluate the effectiveness of FastVLA, we conduct experiments in both simulation and real-world environments. We implement FastVLA on three open-source VLA models: OpenVLA [15], OpenVLA-OFT [14], and CogACT-base [16]. Specifically, we evaluate OpenVLA and OpenVLA-OFT on the LIBERO benchmark [18] and CogACT-base on the SIMPLER benchmark [17], and additionally validate FastVLA on a physical Franka Research 3 robot, together covering a diverse set of manipulation tasks. All experiments are conducted on a single NVIDIA RTX 4090 GPU.

4.1 Experiment Setup

Compared Methods. We compare FastVLA against a broad range of recent acceleration methods spanning three categories: (i) general VLM token-pruning methods, including FastV [7], SparseVLM [29], and DivPrune [2]; (ii) VLA-specific token compression, caching, and reuse methods, including VLA-Cache [26], EfficientVLA [27], FlashVLA [21], SpecPrune-VLA [25], and ADP [20]; and (iii) the learned token-pruning method LightVLA [11]. Among these, VLA-Cache and LightVLA provide published, open-source, and reproducible implementations, which we re-evaluate under our unified setup. For the remaining methods (marked with ∗ in Tab. 1), we are unable to reproduce them in our environment and therefore quote their results from the original papers for reference only.

Evaluation Metrics. We report success rate, FLOPs, latency, control frequency, and CUDA latency, together with the resulting end-to-end speedup. Success rate measures overall task performance. FLOPs provides a hardware-agnostic estimate of the theoretical computation of the LLM backbone. Latency denotes the total per-step action-prediction time. Control frequency is the number of environment actions executed per second, H/\text{latency}, where H is the number of actions produced by one prediction call (H{=}8 for OpenVLA-OFT, which predicts an action chunk per forward pass, and H{=}1 for OpenVLA and CogACT); it quantifies the real-time responsiveness of closed-loop control and makes chunked and single-step policies comparable on one axis. CUDA latency reports the end-to-end LLM-backbone inference time on the GPU, and speedup is computed as the ratio of the per-backbone baseline latency to that of each method. These metrics are widely used in prior VLM/VLA acceleration studies, enabling fair and reproducible comparisons.

4.2 Evaluation Environments

Simulation Benchmarks. We evaluate on two large-scale simulation benchmarks for language-conditioned robot manipulation. LIBERO targets long-horizon, multi-stage tasks that require tight coupling between vision-task understanding and continuous control; it comprises four evaluation suites including Spatial, Goal, Object, and Long, that progressively emphasize generalization across scene layouts, language-specified target states, object detection under appearance shifts, and extended-horizon task combination, and we follow the standard protocol of OpenVLA1 and OpenVLA-OFT2 for fair comparison. SIMPLER, designed to approximate real-world conditions and reduce the sim-to-real gap, provides two settings (visual matching and variant aggregation); we evaluate on four tasks: Pick Coke Can, Move Near, Open/Close Drawer, and Put Apple in Drawer, following the protocol of CogACT3 with CogACT-base as our baseline.

Real-World Environment. We further validate FastVLA on a physical Franka Research 3 robot to examine whether the efficiency gains observed in simulation transfer to real deployment. We consider two tabletop manipulation tasks, pick and pick and place. The policy is OpenVLA-OFT fine-tuned with LoRA on teleoperated demonstrations and deployed in closed-loop control using the same RTX 4090 inference setup as in simulation. For each task and condition, we run 50 rollouts, alternating between the unmodified baseline and FastVLA.

4.3 Experiment Results

LIBERO. Tab. 1 reports results on the four LIBERO suites. On OpenVLA, FastVLA cuts LLM FLOPs from 1.86 to 1.20 T (-35.5\%) and latency from 186.64 to 161.53 ms (1.16\times) at a cost of 0.6 points of success (76.4\to75.8%); on OpenVLA-OFT, from 3.98 to 1.65 T (-58.5\%) and 118.52 to 81.17 ms (1.46\times, 67.50\to98.56 Hz) at a cost of 0.5 points (97.0\to96.5%). Against prior accelerators the picture is a trade-off rather than dominance. VLA-Cache preserves success best on OpenVLA-OFT (97.1%) but converts far less computation into speed, using 45.9\% more FLOPs and running 18.7\% slower than FastVLA, and its gains are backbone-dependent (0.92\times on OpenVLA vs. 1.19\times on OpenVLA-OFT). Against general VLM pruners (FastV, DivPrune, SparseVLM), FastVLA attains the highest success (96.5% vs. 89–96%) at lower FLOPs. LightVLA defines the better efficiency frontier: at equal success it uses 26.7% fewer FLOPs and is 10.8% faster (1.21 vs. 1.65 T; 72.41 vs. 81.17 ms), but must be re-trained per backbone, whereas FastVLA drops into three backbones and a real robot at inference time with a directly controllable budget \rho, staying within 0.6 points of baseline on both backbones.

SIMPLER. Tab. 2 reports results on SIMPLER under both Visual Matching and Variant Aggregation, with CogACT-base as the baseline. Under Visual Matching, FastVLA reduces LLM FLOPs(T) from 1.85 to 1.16 (-37.3\%) and latency(ms) from 174.48 to 159.59 (-8.5\%, 1.09\times), raising control frequency from 5.73 to 6.27 Hz (+9.4\%) with average success essentially unchanged (-0.4 points). Under the more challenging Variant Aggregation setting, it reduces FLOPs from 1.81 to 1.13 (-37.6\%) and latency from 174.94 to 157.06 (-10.2\%, 1.11\times), raising control frequency from 5.72 to 6.37 Hz (+11.4\%) and lowering CUDA latency by 21.0\% (82.74\to65.34 ms), while improving average success by 1.0 points, indicating that adaptive compression does not compromise robustness under distribution shift and task variation.

Real-World. Tab. 3 reports the real-robot results. On the pick task, FastVLA reduces action latency from 121.13 to 96.90 ms (-20.0\%) and raises the effective control frequency from 66.04 to 82.56 Hz (+25.0\%), while retaining a comparable success rate (84.0% vs. 80.0%). On the more demanding pick and place task, latency drops from 120.01 to 97.77 ms (-18.5\%) and control frequency increases from 66.67 to 81.82 Hz (+22.7\%), with the success rate again largely preserved (68.0% vs. 66.0%). These results confirm that FastVLA’s efficiency gains are not limited to simulation but transfer to real-world closed-loop manipulation. We demonstrate the compression performance of FastVLA in both simulation and real-world environments in Figure 5. As can be observed, the retained visual tokens are mainly concentrated in regions that are strongly correlated with the task, such as the robotic arm and the target objects.

4.4 Ablation Studies

Adaptivity vs. the budget it spends. Since the step-wise rate lives in a band around \rho, an adaptive run may realize a budget slightly different from its nominal target, and a gain could then reflect lighter compression rather than adaptivity. We therefore log the realized retained-token count and add a compute-matched control: a fixed-rate policy set to the budget the adaptive run actually consumed, \rho_{\text{fix}}{=}1-\bar{k}/N (Tab. 4). Realized budgets exceed the nominal target by 0.9–3.0\%, which is precisely why the control is needed. Handing the fixed policy that same extra budget is worth at most +0.6 points (+0.15 on average), whereas the adaptive policy turns it into +0.9 to +1.3 points on every suite (95.3{\to}96.5 on average) while never consuming more tokens than its control. The gain thus comes from when the budget is spent, not how much of it is spent.

Choice of calibration. A rank-based map, \alpha(t){=}\mathrm{rank}(U(t))/|W|, is more robust by construction: an anomalous step shifts \alpha by at most 1/|W| instead of resetting the min–max range. On closed-loop rollouts the two are indistinguishable (Tab. 5), differing by at most 0.6 points (0.2 on average) at budgets within 2.5\%, because U(t) drifts smoothly rather than spiking, so min–max’s outlier sensitivity is never exercised. We keep min–max, which is continuous and preserves the magnitude of a deviation, and note that rank calibration is a drop-in substitute for noisy observations.

Choice of diversity metric. Under identical scoring, budgets and calibration, we compare the inverse-Simpson effective number against a Shannon-based one (e^{H}/K) and 1-\text{Gini}, entropic and order-statistic families, respectively. Inverse-Simpson is strongest on both suites (Tab. 6), by +2.3 to +3.0 points over Shannon and +1.7 to +2.0 over Gini. This is not a budget artifact: it retains only 0.6–1.8\% more tokens, worth a few tenths of a point by Tab. 4. We attribute the advantage to dynamic range: the Shannon logarithm and the saturation of 1-\text{Gini} near uniform distributions both compress the variation of U(t), leaving the calibration less contrast to resolve.

5 Conclusion

We present FastVLA, a training-free, task-conditioned, and temporally adaptive visual-token compression framework for efficient VLA inference. Beyond scoring token importance with task-to-vision attention, its core idea is to reformulate per-step token budgeting as an online decision, setting the compression rate from the inverse-Simpson concentration of the importance distribution under sliding-window calibration. Across three backbones and two simulation benchmarks, FastVLA cuts LLM-backbone FLOPs by 35-59% and action latency by 9-32% while maintaining task success, and on a physical Franka robot it reduces latency by 20% and raises control frequency by up to 25% at comparable success, staying within 0.6 points of the uncompressed baseline on both backbones while remaining entirely training-free. Incorporating robot-specific structure such as 3D geometry or proprioception into the importance estimate, and combining adaptive pruning with complementary reuse or early-exit strategies, are promising directions for further accelerating real-time VLA control.

References

1. [1] M. Ahn, A. Brohan, N. Brown, Y. Chebotar, O. Cortes, B. David, C. Finn, C. Fu, K. Gopalakrishnan, K. Hausman, et al. (2022) Do as i can, not as i say: grounding language in robotic affordances. arXiv preprint arXiv:2204.01691.
2. [2] S. R. Alvar, G. Singh, M. Akbari, and Y. Zhang (2025) Divprune: diversity-based visual token pruning for large multimodal models. In Proceedings of the Computer Vision and Pattern Recognition Conference, pp. 9392–9401.
3. [3] K. Black, N. Brown, D. Driess, A. Esmail, M. Equi, C. Finn, N. Fusai, L. Groom, K. Hausman, B. Ichter, et al. (2024) Backslashpi\_0: a vision-language-action flow model for general robot control. arXiv preprint arXiv:2410.24164.
4. [4] D. Bolya, C. Fu, X. Dai, P. Zhang, C. Feichtenhofer, and J. Hoffman (2022) Token merging: your vit but faster. arXiv preprint arXiv:2210.09461.
5. [5] A. Brohan, N. Brown, J. Carbajal, Y. Chebotar, J. Dabis, C. Finn, K. Gopalakrishnan, K. Hausman, A. Herzog, J. Hsu, et al. (2022) Rt-1: robotics transformer for real-world control at scale. arXiv preprint arXiv:2212.06817.
6. [6] R. Cai, J. Guo, X. He, P. Jin, J. Li, B. Lin, F. Liu, W. Liu, F. Ma, K. Ma, et al. (2026) Xiaomi-robotics-0: an open-sourced vision-language-action model with real-time execution. arXiv preprint arXiv:2602.12684.
7. [7] L. Chen, H. Zhao, T. Liu, S. Bai, J. Lin, C. Zhou, and B. Chang (2024) 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, pp. 19–35.
8. [8] C. Chi, Z. Xu, S. Feng, E. Cousineau, Y. Du, B. Burchfiel, R. Tedrake, and S. Song (2025) Diffusion policy: visuomotor policy learning via action diffusion. The International Journal of Robotics Research 44 (10-11), pp. 1684–1704.
9. [9] D. Driess, F. Xia, M. S. Sajjadi, C. Lynch, A. Chowdhery, B. Ichter, A. Wahid, J. Tompson, Q. Vuong, T. Yu, et al. (2023) Palm-e: an embodied multimodal language model. arXiv preprint arXiv:2303.03378.
10. [10] P. Intelligence, K. Black, N. Brown, J. Darpinian, K. Dhabalia, D. Driess, A. Esmail, M. Equi, C. Finn, N. Fusai, et al. (2025) Backslashpi_{0.5}: a vision-language-action model with open-world generalization. arXiv preprint arXiv:2504.16054.
11. [11] T. Jiang, X. Jiang, Y. Ma, X. Wen, B. Li, K. Zhan, P. Jia, Y. Liu, S. Sun, and X. Lang (2025) The better you learn, the smarter you prune: towards efficient vision-language-action models via differentiable token pruning. arXiv preprint arXiv:2509.12594.
12. [12] L. Jost (2006) Entropy and diversity. Oikos 113 (2), pp. 363–375.
13. [13] C. Keylock (2005) Simpson diversity and the shannon–wiener index as special cases of a generalized entropy. Oikos 109 (1), pp. 203–207.
14. [14] M. J. Kim, C. Finn, and P. Liang (2025) Fine-tuning vision-language-action models: optimizing speed and success. arXiv preprint arXiv:2502.19645.
15. [15] M. J. Kim, K. Pertsch, S. Karamcheti, T. Xiao, A. Balakrishna, S. Nair, R. Rafailov, E. Foster, G. Lam, P. Sanketi, et al. (2024) Openvla: an open-source vision-language-action model. arXiv preprint arXiv:2406.09246.
16. [16] Q. Li, Y. Liang, Z. Wang, L. Luo, X. Chen, M. Liao, F. Wei, Y. Deng, S. Xu, Y. Zhang, et al. (2024) CogACT: a foundational vision-language-action model for synergizing cognition and action in robotic manipulation. arXiv preprint arXiv:2411.19650.
17. [17] X. Li, K. Hsu, J. Gu, K. Pertsch, O. Mees, H. R. Walke, C. Fu, I. Lunawat, I. Sieh, S. Kirmani, S. Levine, J. Wu, C. Finn, H. Su, Q. Vuong, and T. Xiao (2024) Evaluating real-world robot manipulation policies in simulation. arXiv preprint arXiv:2405.05941.
18. [18] B. Liu, Y. Zhu, C. Gao, Y. Feng, Q. Liu, Y. Zhu, and P. Stone (2023) LIBERO: benchmarking knowledge transfer for lifelong robot learning. arXiv preprint arXiv:2306.03310.
19. [19] Z. Liu, Y. Chen, H. Cai, T. Lin, S. Yang, Z. Liu, and B. Zhao (2025) VLA-pruner: temporal-aware dual-level visual token pruning for efficient vision-language-action inference. arXiv preprint arXiv:2511.16449.
20. [20] X. Pei, Y. Chen, S. Xu, Y. Wang, Y. Shi, and C. Xu (2025) Action-aware dynamic pruning for efficient vision-language-action manipulation. arXiv preprint arXiv:2509.22093.
21. [21] X. Tan, Y. Yang, P. Ye, J. Zheng, B. Bai, X. Wang, J. Hao, and T. Chen (2025) Think twice, act once: token-aware compression and action reuse for efficient inference in vision-language-action models. arXiv preprint arXiv:2505.21200.
22. [22] G. R. Team, S. Abeyruwan, J. Ainslie, J. Alayrac, M. G. Arenas, T. Armstrong, A. Balakrishna, R. Baruch, M. Bauza, M. Blokzijl, et al. (2025) Gemini robotics: bringing ai into the physical world. arXiv preprint arXiv:2503.20020.
23. [23] O. M. Team, D. Ghosh, H. Walke, K. Pertsch, K. Black, O. Mees, S. Dasari, J. Hejna, T. Kreiman, C. Xu, et al. (2024) Octo: an open-source generalist robot policy. arXiv preprint arXiv:2405.12213.
24. [24] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin (2017) Attention is all you need. Advances in neural information processing systems 30.
25. [25] H. Wang, J. Xu, J. Pan, Y. Zhou, and G. Dai (2025) Specprune-vla: accelerating vision-language-action models via action-aware self-speculative pruning. arXiv preprint arXiv:2509.05614.
26. [26] S. Xu, Y. Wang, C. Xia, D. Zhu, T. Huang, and C. Xu (2025) VLA-cache: towards efficient vision-language-action model via adaptive token caching in robotic manipulation. arXiv preprint arXiv:2502.02175.
27. [27] Y. Yang, Y. Wang, Z. Wen, L. Zhongwei, C. Zou, Z. Zhang, C. Wen, and L. Zhang (2025) Efficientvla: training-free acceleration and compression for vision-language-action models. arXiv preprint arXiv:2506.10100.
28. [28] Q. Zhang, A. Cheng, M. Lu, R. Zhang, Z. Zhuo, J. Cao, S. Guo, Q. She, and S. Zhang (2025) Beyond text-visual attention: exploiting visual cues for effective token pruning in vlms. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 20857–20867.
29. [29] Y. Zhang, C. Fan, J. Ma, W. Zheng, T. Huang, K. Cheng, D. Gudovskiy, T. Okuno, Y. Nakata, K. Keutzer, et al. (2024) Sparsevlm: visual token sparsification for efficient vision-language model inference. arXiv preprint arXiv:2410.04417.
30. [30] B. Zitkovich, T. Yu, S. Xu, P. Xu, T. Xiao, F. Xia, J. Wu, P. Wohlhart, S. Welker, A. Wahid, et al. (2023) Rt-2: vision-language-action models transfer web knowledge to robotic control. In Conference on Robot Learning, pp. 2165–2183.