Literature
Display
← All papers

FASTer: Toward Efficient Autoregressive Vision Language Action Modeling via Neural Action Tokenization

Yicheng Liu · Shiduo Zhang · Zibin Dong · Baijun Ye · Tianyuan Yuan · Xiaopeng Yu · Linqi Yin · Chenhao Lu · Junhao Shi · Luca Jiang-Tao Yu · Liangtao Zheng · Tao Jiang · Jingjing Gong · Xipeng Qiu · Hang Zhao

· ICLR 2026 ↗

Robotics14 min text · CondensedOriginal paper ↗
Contents

Overview

This edition reviews the 24-page arXiv v2 dated 8 December 2025, including the complete appendix. Its title differs from the later editorial title previously catalogued, but the arXiv identifier and all fifteen authors identify the same FASTer work. The displayed title and author order follow the reviewed PDF; the existing ICLR 2026 publication link is retained.

Complete original Figure 1.
Figure 1: FASTer combines a learnable action tokenizer (FASTerVQ) and an autoregressive VLA model (FASTerVLA), achieving efficient compression, fast control, and strong performance across eight real and simulated embodiments.

At a glance

FASTer combines a learned action codec with an autoregressive vision-language-action policy. FASTerVQ groups action dimensions by physical meaning, compresses temporal patches and uses residual vector quantization. FASTerVLA predicts blocks of codes through a lightweight action expert.

The reported policy reaches 97.9% on LIBERO and 87.9% on Simpler-Bridge. It is faster than the compared FAST policy, but not uniformly faster than π₀: whole-body timing is 237 ms versus 225 ms. Reconstruction, policy success, task progress and inference latency measure different properties and are kept separate below.

1 Introduction

Autoregressive robot policies need action tokens that are compact enough for fast generation while preserving precise motion. Time samples can be redundant, but position, orientation, gripper and base variables have different physical meanings and distributions. Flattening them indiscriminately can sacrifice useful structure.

FASTer—Flexible Action Sequence Tokenization for efficient inference—addresses compression, reconstruction, two-dimensional time/action structure and transferability together. Its learned codec compresses structured patches; residual codebooks refine coarse representations; block decoding reduces sequential policy calls.

The paper compares this combination with FAST, other discrete action tokenizers and continuous policies. Claims about generally stronger language grounding of autoregressive models are motivations drawn from prior work, not a universal result established by these experiments. “Near-lossless” refers to a chosen reconstruction tolerance, not bit-exact recovery.

2 Related Work

Robot policies: diffusion/flow approaches generate continuous trajectories, while models such as OpenVLA serialize discrete actions. FASTer aims to retain pretrained visual/language features while reducing the discrete sequence length and decoding cost.

Codecs: image, video and audio tokenizers motivate a transformer/convolution hybrid and residual quantization. Audio-style coarse-to-fine residual coding is adapted to robot action chunks; robot variables still require embodiment-specific grouping.

Action tokenizers: per-dimension bins, DCT plus byte-pair encoding, and MiniVLA/VQ-VLA differ in code length and reconstruction. FASTer learns the codec and preserves structured latent axes.

Block generation: prior video, speech, language and action models reduce sequential depth by generating chunks. FASTer applies this idea to discrete action codes, conditioning each block on earlier blocks while predicting its members together.

3 Method

A policy receives color imagery, proprioception and a language instruction, then predicts a fixed-horizon action chunk through discrete codes. The tokenizer maps actions to code indices and reconstructs continuous actions from predicted indices.

Long code sequences require many dependent model passes; the paper reports 150–200 FAST tokens and about three seconds for a two-second motion in its motivating whole-body case. Attention complexity alone does not determine latency: caching, context length and implementation matter. The measured timings later in the paper provide the concrete efficiency evidence.

Complete original Figure 2.
Figure 2: FASTerVQ. (a) The raw action sequence is patchified into compact tokens based on their embodied configuration. (b) FASTerVQ applies DCT and L1 reconstruction losses and adopts RVQ, encoding actions into NcN_{c} code levels; each level can be reshaped into a Ch×CaC_{h}\times C_{a} tensor.
Equation

It∈ℝH×W×3I_{t}\in\mathbb{R}^{H\times W\times 3}

st∈ℝdss_{t}\in\mathbb{R}^{d_{s}}

l∈ℒl\in\mathcal{L}

At:t+H=(at,at+1,…,at+H−1).A_{t:t+H}=(a_{t},a_{t+1},\ldots,a_{t+H-1}).

3.1 FASTerVQ

Patchifier: divide time into equal groups of h steps and action dimensions into physically related groups, such as position, orientation and gripper. Pad groups to the largest width d, then flatten each time/action patch. This treats the chunk as a structured single-channel array rather than a natural image.

Codec: a Transformer Action AutoEncoder combines global attention with local convolution and downsampling. At each residual stage, the quantizer selects a nearest codebook vector, subtracts it from the residual and adds it to the accumulated quantized latent. Indices form a tensor over residual stage, latent time and latent action axes.

Training: reconstruct both the original action signal and its DCT using L₁ losses, plus a stop-gradient commitment term. A straight-through estimator trains the encoder; exponential moving averages update codebooks and dead entries are reinitialized. The residual design is intended to capture coarse motion before fine corrections; exact frequency separation is not guaranteed by the quantization rule.

Algorithm 1 and all formal definitions are retained. Its pseudocode appends cᵢ without separately defining that index; the prose supplies the nearest-codebook selection that gives its meaning. The codec is lossy even when its error falls below an evaluation threshold.

Algorithm 1 FASTer Tokenizer
Require: FASTerVQ quantizers {𝒬i}i=1Nc\{\mathcal{Q}_{i}\}_{i=1}^{N_{c}} , encoder ϕe​n​c\phi_{enc} and decoder ϕd​e​c\phi_{dec} .
procedure ENCODE ( at:t+Ha_{t:t+H} )
    r←z←ϕe​n​c(Patchify(at:t+H))r\leftarrow z\leftarrow\phi_{enc}({\texttt{Patchify}}\left(a_{t:t+H}\right))
    C←[],zq←0C\leftarrow[~],z_{q}\leftarrow 0
    for i=1i=1 to NcN_{c} do
        zq+=𝒬i(r),r-=𝒬i(r)z_{q}\mathrel{+}=\mathcal{Q}_{i}({r}),r\mathrel{-}=\mathcal{Q}_{i}(r)
        C.append​(ci)C.\texttt{append}(c_{i})
    return CC
procedure DECODE ( CC )
    zq←0z_{q}\leftarrow 0
    for i=1i=1 to NcN_{c} do
        zq+=𝒬i.lookup​(C⁡[i])z_{q}\mathrel{+}=\mathcal{Q}_{i}.\texttt{lookup}(C[i])
    at:t+H←UnPatchify(ϕd​e​c(zq))a_{t:t+H}\leftarrow{\texttt{UnPatchify}}\left(\phi_{dec}(z_{q})\right)
    return at:t+Ha_{t:t+H}
procedure VQ_Training ( at:t+Ha_{t:t+H} )
    a^t:t+H=DECODE(ENCODE(at:t+H))\hat{a}_{t:t+H}=\texttt{DECODE}\left({\texttt{ENCODE}\left(a_{t:t+H}\right)}\right)
     Train with the loss ℒ\mathcal{L} in Equation 1
Equations 1
ℒ=‖𝒂t:t+H−𝒂^t:t+H‖1+‖DCT(𝒂t:t+H)−DCT(𝒂^t:t+H)‖1+λ⋅‖𝒛−sg(𝒛q)‖22,\mathcal{L}=\left\|\bm{a}_{t:t+H}-\hat{\bm{a}}_{t:t+H}\right\|_{1}+\left\|\text{DCT}(\bm{a}_{t:t+H})-\text{DCT}(\hat{\bm{a}}_{t:t+H})\right\|_{1}+\lambda\cdot\left\|\bm{z}-\text{sg}(\bm{z}_{q})\right\|^{2}_{2}, (1)

At:t+H=(𝐚t,𝐚t+1,…,𝐚t+H−1),A_{t:t+H}=(\mathbf{a}_{t},\mathbf{a}_{t+1},\ldots,\mathbf{a}_{t+H-1}),

𝐚t∈ℝD\mathbf{a}_{t}\in\mathbb{R}^{D}

(m⋅h)×(n⋅d)(m\cdot h)\times(n\cdot d)

𝐚Pt:t+H∈ℝ(m⋅n)×(h⋅d)\mathbf{a}^{P}_{t:t+H}\in\mathbb{R}^{(m\cdot n)\times(h\cdot d)}

𝐳∈ℝCh×Ca\mathbf{z}\in\mathbb{R}^{C_{h}\times C_{a}}

𝐫1=𝐳\mathbf{r}_{1}=\mathbf{z}

𝐫i+1=𝐫i−𝒬i​(𝐫i)\mathbf{r}_{i+1}=\mathbf{r}_{i}-\mathcal{Q}_{i}(\mathbf{r}_{i})

𝐳q=∑i=1Nc𝒬i​(𝐫i)\mathbf{z}_{q}=\sum_{i=1}^{N_{c}}\mathcal{Q}_{i}(\mathbf{r}_{i})

k=arg⁡minj⁡‖𝐫i−ej‖2k=\arg\min_{j}\|\mathbf{r}_{i}-e_{j}\|^{2}

C∈{1,…,|𝒵|}Nc×Ch×CaC\in\{1,\ldots,|\mathcal{Z}|\}^{N_{c}\times C_{h}\times C_{a}}

(h,a)(h,a)

3.2 FASTerVLA

Policy architecture: a vision tower and projection feed a pretrained language backbone; new embedding slots represent action codes, and proprioception is discretized and represented as text. A smaller action expert uses the backbone’s encoded context for repeated action decoding. The paper does not fully specify the expert’s widths, parameter count or the later partial-freezing schedule.

Positions: rotary embeddings use training offsets of 1+ε between adjacent action tokens, with integer ε sampled from 0 through k (example k=2). Inference uses a fixed spacing such as two. This spacing augmentation targets position overfitting while preserving token order.

Block decoding: the usual teacher-forced loss predicts one code from earlier codes. BAR instead predicts B codes in one pass, conditioning on previous blocks; its objective factorizes the current block’s code probabilities under that shared context. A block attention mask and BoBlk/EoBlk control tokens switch between text-style and block-style generation. BoBlk is replicated B times to initiate the first block.

The stated intra-block attention concerns the network’s representation and must not be read as conditioning each predicted code on already-known ground-truth codes from the same output block. The paper does not fully document the shifted training alignment and control-token termination implementation.

Decoding covers temporal locations within one residual codebook before moving to the next; action-axis tokens can be emitted together. Approximately N/B passes replace N sequential passes. This preserves coarse-to-fine codebook order but assumes enough within-block predictability to avoid costly sequential dependencies. The claimed threefold advantage over π₀ is not reproduced by the final timing table’s 112 versus 176 ms.

Complete original Figure 3.
Figure 3: FASTerVLA. (a) The model takes RGB images, proprioceptive states, and a language instruction as inputs to a transformer–based VLM. An Action Expert autoregressively generates discrete action tokens, which a VQ decoder maps into the final continuous action sequence. (b) Codes are generated codebook–wise before advancing along the temporal horizon, yielding greater stability than horizon–first decoding (red arrows denote the decoding order). (c) Left: vanilla causal mask; Right: Block-wise causal mask, where tokens within each block attend to preceding and intra-block tokens. Token colors denote different modalities.
Equations 2–3
ℒAR=−∑i=1Nlogpθ(ci∣c<i,It,st,x),\vskip-5.0pt\mathcal{L}_{\text{AR}}=-\sum\nolimits_{i=1}^{N}\log p_{\theta}\!\big(c_{i}\mid c_{<i},I_{t},s_{t},x\big),\vskip-1.00006pt (2)
ℒBAR=−∑j=1J∑i=1Blogpθ(cj,i|C<j,It,st,x).\mathcal{L}_{\text{BAR}}=-\sum\nolimits_{j=1}^{J}\sum\nolimits_{i=1}^{B}\log p_{\theta}\!\big(c_{j,i}\,\big|\,C_{<j},I_{t},s_{t},x\big).\vskip-5.0pt (3)

pi=pi−1+1+ϵip_{i}=p_{i-1}+1+\epsilon_{i}

k=2k=2

pi=pi−1+2p_{i}=p_{i-1}+2

C=(c1,…,cN)C=(c_{1},\ldots,c_{N})

N=Nc×Ch×CaN=N_{c}\times C_{h}\times C_{a}

C={C1,…,CJ}C=\{C_{1},\ldots,C_{J}\}

Cj=(cj,1,…,cj,B)C_{j}=(c_{j,1},\ldots,c_{j,B})

N=J​BN=JB

C∈ℤNc×Ch×CaC\in\mathbb{Z}^{N_{c}\times C_{h}\times C_{a}}

4 Experiments

Experiments separate tokenizer reconstruction/compression from downstream robot-policy behavior. Main results compare success rates on LIBERO and Simpler-Bridge; additional figures report either success or partial task progress across simulated and physical robots.

Table 1 gives FASTer 97.9% LIBERO versus 94.2% π₀-FAST-D and 97.1% OpenVLA-OFT. Simpler-Bridge averages are 87.9% versus 76.5% π₀-FAST-D, an 11.4-percentage-point difference; the prose’s 12.9% claim does not match that table. Removing BAR gives 95.4% and 81.0%, respectively. Individual tasks need not improve—for example the no-BAR spoon score exceeds FASTer’s.

Model LIBERO Simpler-Bridge
Spatial Object Goal Long Average Spoon Carrot Block Eggplant Average
Diffusion Policy (Chi et al., 2023) 78.3 92.5 68.3 50.5 72.4 - - - - -
Octo-Base (Team et al., 2024) 78.9 85.7 84.6 51.1 75.1 12.5 8.3 0.0 43.1 16.0
SpatialVLA (Qu et al., 2025) 88.2 89.9 78.6 55.5 78.1 16.7 25.0 29.2 100.0 42.7
π0\pi_{0} (Black et al., 2024) 96.8 98.8 95.8 85.2 94.2 66.7 58.3 58.3 88.3 66.7
π05\pi_{05} (Intelligence et al., 2025) 98.8 98.2 98.0 92.4 96.8 - - - - -
OpenVLA-OFT (Kim et al., 2025) 97.6 98.4 97.9 94.5 97.1 12.5 4.2 8.3 0.0 6.25
UniVLA (Bu et al., 2025) 96.5 96.8 95.6 92.0 95.2 54.2 66.7 50.0 4.2 43.8
OpenVLA (Kim et al., 2024) 84.7 88.4 79.2 53.7 76.5 32.0 30.0 18.0 38.0 29.5
Palligemma + Naive Tokenizer 55.8 64.8 64.4 31.2 54.1 66.7 29.2 12.5 54.2 40.9
MiniVLA (Belkhale and Sadigh, 2024) - - - 77.0 - 68.0 44.0 70.0 14.0 49.0
VQ-VLA (Wang et al., 2025c) - - 75.2 60.0 - 12.5 8.0 6.0 0.0 6.3
π0\pi_{0} FAST-R 11 1 π0\pi_{0} FAST-D: delta action chunks; π0\pi_{0} FAST-R: relative action chunks. All results use π0\pi_{0} FAST-D unless otherwise noted.(Pertsch et al., 2025) 96.4 96.8 88.6 60.2 85.5 29.1 21.9 10.8 66.6 32.1
π0\pi_{0} FAST-D (Pertsch et al., 2025) 96.6 97.2 96.0 86.8 94.2 77.5 88.3 68.3 71.7 76.5
FASTer w/o BAR 99.4 98.8 94.8 88.6 95.4 97.5 83.3 65.0 78.3 81.0
FASTer 98.0 99.4 98.6 95.4 97.9 91.7 93.3 67.5 99.2 87.9

Table 1: Policy performance on Libero and Simpler-Bridge benchmarks.
Complete original Figure 4.
Figure 4: Policy performance across embodiments and environments. Results are reported in the in-distribution setting, covering two real-world embodiments and three simulated setups.

4.1 Experiment Setups

Evaluations cover simulation and hardware, including deformable objects, bimanual and whole-body control, instructions and long tasks. The source alternates between eight real/simulated embodiments, four plus four settings, and nine benchmarks over five embodiments; Appendix A.1 explicitly enumerates eight suites. Those counting descriptions are not silently harmonized.

Most policies start from robotics-pretrained checkpoints. Bridge and DROID policy experiments instead start from pretrained VLM weights and train on the same robot dataset for comparison. Tokenizer training is a separate stage and can include different mixtures. In-distribution evaluation reuses task/scene families with randomized layouts; the appendix specifies each recipe.

Complete original Figure 5.
Figure 5: Average VRR of different action tokenizers under multiple error tolerances σ\sigma. FASTer achieves the best performance across all scales and exhibits clear data-scaling behavior.
Complete original Figure 6.
Figure 6: Compression rate vs. reconstruction trade-off across action horizons, where FASTer achieves the best balance, particularly for long sequences.

4.2 Results and Analysis of FASTerVQ

Metric: Valid Reconstruction Rate is the fraction of reconstructed actions whose L₁ deviation is below σ. The prose then describes translation error as Euclidean distance in meters and rotation/joint error in radians, while other analysis uses normalized actions. The exact aggregation and physical denormalization are not fully reconciled; VRR is a tolerance-based reconstruction proxy, not task success or exact losslessness.

Compression and scale: FASTer’s curves improve the code-length/fidelity tradeoff, particularly for longer and higher-frequency chunks. S/L/XL mixtures increase both data breadth and available action representations, so their gains are not a controlled scaling law at fixed distribution. The strongest reconstruction at σ=10⁻³ remains below one for some dataset/mixture cells.

Transfer: tokenizers trained on single-arm delta end-effector data are tested on new Widow/XArm data and on DROID joint velocity, Galaxea absolute joint position and Agilex delta joint position. The findings concern normalized action reconstruction; they do not establish that an unchanged complete policy controls every new embodiment. Mixture-specific training exposure must be checked before calling a result zero-shot.

Equation 4
VRR=Nvalid/Ntotal,Nvalid=∑i=1Ntotal𝟏​(‖𝐚irecon−𝐚igt‖1<σ),\text{VRR}={N_{\text{valid}}}/{N_{\text{total}}},\quad N_{\text{valid}}=\sum\nolimits_{i=1}^{N_{\text{total}}}\mathbf{1}\left(\left\|\mathbf{a}_{i}^{\text{recon}}-\mathbf{a}_{i}^{\text{gt}}\right\|_{1}<\sigma\right), (4)
Complete original Figure 7.
Figure 7: Comparison of FASTer, its non-BAR variant, and FAST across backbones on the Libero benchmark.
Complete original Figure 8.
Figure 8: FASTer generalizes well across embodiments and action types with scaling trend.

4.3 Results and Analysis of FASTerVLA

In distribution: FASTer’s reported 97.9% LIBERO mean leads Table 1’s baselines. Other settings include VLABench, GalaxeaManipSim, xArm and R1Lite bimanual/whole-body tasks. The paper acknowledges a small deficit to π₀ on VLABench, so it does not outperform every baseline on every benchmark.

Generalization: VLABench tests category, common-sense, semantic and texture changes. The prose claims a 29% relative drop, but Figure 9 labels FASTer’s average drop as 34% and FAST+ as 32%; the assertion of the smallest drop is therefore not supported uniformly by the plotted labels. Real Widow and Franka evaluations in Figure 10 report task progress, not binary completion rates.

Token statistics: Bridge codebook utilization is 48.39% for FAST, 57.37% for FAST+ and 100% for FASTer. Normalized entropy is 0.69/0.77/0.91 and the most frequent token accounts for 9.63/1.82/1.35%. More balanced activation correlates with stronger results, but these comparisons also change tokenizer architecture and training; they do not isolate utilization as the cause.

Backbones: all five Table 9 model averages improve, with the largest gain for InternVL3.5-2B: 79.35% to 96.65%, or 17.30 points. Several individual suites still regress. Figure 7 indicates that changing the tokenizer supplies much of the gain and BAR adds a smaller increment in those settings.

Latency: RTX 5090/PyTorch measurements are 112 ms single-arm and 237 ms whole-body, versus π₀ 176/225 ms and π₀-FAST 197–556/1,100–3,000 ms. Thus the single-arm speedup over π₀ is about 1.57×, while whole-body FASTer is slightly slower. These are action-chunk inference times, not proof of equally fast sensor-to-actuator feedback or universal hardware performance.

Single-arm timing includes image encoding 16 ms, observation pass 72 ms, three BAR passes at 7.4 ms and detokenization 2.7 ms. Whole-body uses 23+105 ms observation processing, twelve passes at 8.51 ms and 7 ms detokenization. Rounded component sums need not equal rounded totals. The observation stage dominates, limiting benefits from further tokenizer acceleration.

Complete original Figure 9.
Figure 9: Evaluation results of generalization ability on VLABench. The evaluation dimensions cover generalization of language, vision, and goal and knowledge transfer.
Complete original Figure 10.
Figure 10: Comparison of zero-shot performance between FASTer and baselines on Droid and Bridge datasets.
model part Time(Single) Time(WBC)
image encoders 16 ms 23ms
observation forward pass 72 ms 105ms
AR forward pass 6.4*21 ms -
BAR forward pass 7.4ms*3 8.51ms*12
FASTerVQ detokenization 2.7 ms 7ms
total inference 112ms 237ms

Table 2: The inference time is measured using a PyTorch implementation on an RTX 5090. WBC refers to a whole-body-control setting that uses an action DoF/chunk size of 21/32, whereas Single refers to a single-arm setting that uses 7/20.

4.4 Additional Studies

Appendix ablations compare encoder design, codebook size, residual depth, action-expert initialization and block size. They favor the selected configuration within those tested settings; not every component change helps without pretraining. Figure 15 retains the original task-rollout montage.

5 Conclusion

The framework couples a structured residual codec, blockwise autoregression and a small action expert to improve the observed accuracy/latency tradeoff. Tokenizer reuse is demonstrated for selected downstream tasks and backbones, with separately trained mixtures for some embodiments.

Broader limits include reliance on physical action grouping and normalization, incomplete details of the expert/training alignment, limited reported evaluation counts outside Simpler, and differing metrics across suites. Reconstruction tolerances and codebook utilization do not replace closed-loop control validation.

6 Ethics statement

The authors state that they follow the ICLR Code of Ethics, use publicly available datasets, and involve no human subjects or sensitive data. Elsewhere the paper also describes newly collected Widow/XArm data and real-robot demonstrations; availability of every collection is not independently established here.

7 Reprodicibility statement

The source promises code release upon publication and points to the methods, experiments and appendix for reproducibility. This edition preserves those details and identifies conflicting block-size and metric descriptions; it does not infer later repository availability or missing implementation settings.

Appendix A Appendix

The appendix provides suite-specific training recipes, data mixtures, hyperparameters, ablations, backbone comparisons and qualitative reconstruction analysis. All supplemental tables, plots and rollout images are preserved.

A.1 Detailed Evaluation Setups.

LIBERO: forty tasks across Spatial/Object/Goal/Long, fifty demonstrations each; a single multi-task policy trains for 30k steps, batch 32, eight H100s, no image augmentation. Both robotics-pretrained fine-tuning and VLM-initialized imitation-learning settings are studied; FASTerVQ(S) supplies codes.

Simpler-Widow: Bridge policy training lasts four epochs, batch 128 on eight H100s with augmentation; FASTerVQ(S) is used. Evaluation increases from the default 24 to 120 trials per task. Real Widow250 evaluation uses the same checkpoints, so “zero-shot” concerns the test tasks/settings after Bridge robot-data training.

VLABench: fine-tune π₀, π₀-FAST and FASTer on 5,000 demonstrations across ten tasks, 30k steps, batch 32, eight H100s, no augmentation. Its tokenizer is trained separately on the VLABench primitive dataset.

GalaxeaManipSim: seven dual-arm tasks—BlockHammerBeat, BlocksStackEasy, ContainerPlace, DiverseBottlesPick, DualBottlesPickHard, EmptyCupPlace and ShoePlace—supply 7,000 demonstrations. Training uses four epochs, batch 128, eight H20s, augmentation and head/two-wrist views. The Galaxea-trained tokenizer is reused without post-training.

xArm: 500 demonstrations cover board wiping, poker choosing, fruit placing, object managing and towel folding. Training uses 30k steps, batch 128 and augmentation with FASTerVQ(L).

R1Lite: cube picking and table bussing each have 200 demonstrations; bed making has 1,000. Models train eight epochs, batch 256 across 64 H20s with the Galaxea tokenizer reused unchanged. These are training-set sizes, not evaluation trial counts.

Bridge/DROID: Bridge contains over 60k trajectories and supports Widow hardware tests. DROID contains over 90k trajectories; joint-velocity policy training lasts three epochs on 64 H200s, batch 16 per GPU (1,024 total). Training exposure distinguishes these evaluations from controlling a robot without robot-data pretraining.

Complete original Figure 11.
Figure 11: Experiment setups. Diverse embodiments, scenes, and tasks for assessing multiple capability dimensions (marked by emojis).

A.2 Implementation Details

Mixtures: S uses LIBERO:Bridge at 5:1. L adds Kuka, Fractal and DROID end-effector data, each at weight 1. XL additionally includes DROID joint velocity and Galaxea, each at weight 1. Separate pure Galaxea and pure DROID joint-velocity tokenizers serve their respective evaluations. Mixture ratios are sampling weights, not trajectory counts.

Tokenizer training: AdamW learning rate 10⁻⁴, weight decay 0.1, β=(0.9,0.95), cosine schedule with 1,000 warmup steps, gradient norm 1 and bfloat16. Single-arm/full-body codecs have 8M/13M parameters and batches 512/2,048; training on eight H100s converges within 300k steps. Codebooks have 4,096 entries, latent dimension 128 and commitment cost 0.25.

Policy: AdamW 2.5×10⁻⁵, decay 10⁻¹⁰, cosine schedule with 1,000 warmup steps, bfloat16, zero attention dropout. Inference uses top-k 50, temperature 0.8, one observation step and action clipping to [−1,1].

Table 4 lists block size 7 for every suite, whereas the prose states 8 for bimanual/whole-body and 7 for single-arm. The table’s whole-body code tensor has 3×2×21=126 tokens, while Table 2 reports twelve decoding passes; these descriptions do not identify one consistent block configuration. All original values remain unchanged. The tokenizer paragraph’s “length 21 tokens” also does not cover every table configuration.

Table 3: Overview of data mixtures used for training FASTerVQ.
Mixture Name Datasets Ratio Application
Galaxea Galaxea Open Dataset (Jiang et al., 2025) 1.0 Used for R1Lite Evaluation.
Droid Mixture Droid (Joint Velocity) (Khazatsky et al., 2024) 1.0 Used for Droid evaluation.
FASTer(S) Libero (Liu et al., 2024) 5.0 Used for libero, simpler and widow evaluation.
Bridge (Walke et al., 2023) 1.0
FASTer(L) Libero (Liu et al., 2024) 5.0
Bridge (Walke et al., 2023) 1.0
Kuka (Kalashnikov et al., 2018) 1.0 Used for Xarm finetuning and tokenizer scaling analysis.
Fractal (Brohan et al., 2023) 1.0
Droid(EEF) (Khazatsky et al., 2024) 1.0
FASTer(XL) Libero (Liu et al., 2024) 5.0
Bridge (Walke et al., 2023) 1.0
Kuka (Kalashnikov et al., 2018) 1.0
Fractal (Brohan et al., 2023) 1.0 Used for tokenizer scaling and action representation analysis.
Droid(EEF) (Khazatsky et al., 2024) 1.0
Droid(Joint Velocity) (Khazatsky et al., 2024) 1.0
Galaxea Open Dataset (Jiang et al., 2025) 1.0
Table 4: Detailed Hyperparameter Configuration for FASTerVQ and BAR.
Suite Embodiment Action DoF BAR block size Action chunk size 𝐂𝐚\mathbf{C_{a}} 𝐂𝐡\mathbf{C_{h}} Number of codebook
Libero Franka 7 7 20 7 1 3
Simpler Widow250s 6 7 10 7 1 3
VLABench Franka 7 7 10 7 1 3
GalaxeaManipSim R1, R1Lite 14 7 32 14 2 3
Xarm Suite XArm 7 7 20 7 1 3
R1Lite Suite R1Lite 21 7 32 21 2 3
Bridge Widow250 6 7 10 7 1 3
Droid Franka 7 7 20 7 1 3

A.3 Ablation Study

Codec: TAAE reaches 97.9% success and L₁ 0.0021, versus CNN 96.2%/0.0027 and transformer 95.3%/0.0036. Codebook success is 95.4/93.2/97.9/96.3% for 512/1,024/4,096/8,192 entries: improvement is not monotonic. Usage at 4,096 is 99.6%, slightly below the 100% smaller books; 8,192 falls to 95.1%. Calling this collapse is an interpretation of reduced usage, not complete codebook failure.

Residual depths 1/2/3/8 yield 93.4/95.5/97.9/96.6%. Three stages give the best listed result, while more stages do not guarantee improvement.

Action expert: LIBERO no-expert/no-pretrain/pretrained-expert scores 95.5/94.8/97.9%; Simpler scores 75.6/23.6/87.9%. Thus an unpretrained expert hurts both settings, contrary to the prose’s claim that it consistently helps. The source suggests two-stage pretraining followed by partial freezing but does not give a complete freezing recipe.

Decoding: tokenwise 95.5%/323 ms becomes blockwise 96.7%/140 ms; adding the expert gives 97.7%/140 ms. These ablation timings differ from the 112 ms main configuration. Figure 12 tests 42-code chunks and favors block size 7; very large blocks degrade sharply. Statistical variation across training seeds is not reported.

Table 5: Inference time across environments and models, measured on an NVIDIA GeForce RTX 5090 using PyTorch.
Model FASTer pi0 FAST
LIBERO (ms) 112 176 197–556
R1Lite-WBC (ms) 237 225 1,100–3,000
Table 6: Ablation on FASTerVQ policy success rate in libero simulator (SR, %) and ℓ1\ell_{1} loss (lower is better);.
(a) Tokenizer (b) Codebook Size (c) Residual
Arch. SR ℓ1\ell_{1} Size SR utilization #Res. SR
CNN 96.2 0.0027 512 95.4 100 1 93.4
Transf. 95.3 0.0036 1024 93.2 100 2 95.5
TAAE 97.9 0.0021 4096 97.9 99.6 3 97.9
– – – 8192 96.3 95.1 8 96.6
Table 7: Ablation studies of FASTer. Left: ablation study of the action expert (AE) on libero; Middle: AE on simpler-widow; Right: BAR decoding. “Pretrain” indicates whether the model is initialized from a checkpoint pretrained on robotics datasets; others without this label are all initialized from such pretrained checkpoints.
libero (AE) simpler-widow (AE) bar decoding
Variant SR ↑\uparrow Variant SR ↑\uparrow Decoding strategy SR ↑\uparrow Latency (ms)↓\downarrow
No AE 95.5 No AE 75.6 Token-wise (AR) 95.5 323
AE (no pretrain) 94.8 AE (no pretrain) 23.6 Block-wise 96.7 140
AE (with pretrain) 97.9 AE (with pretrain) 87.9 Block-wise + AE (FASTer) 97.7 140
Complete original Figure 12.
Figure 12: Different BAR block sizes, including irregular granularity, and their performance on the LIBERO environment.
Metric Fast Fast+ FASTer
NvocabN_{\text{vocab}} ↑\uparrow 2048 2048 4096
U​s​a​g​eUsage [%] ↑\uparrow 48.39 57.37 100.0
Nactive​(σ=10−2)N_{\text{active}}(\sigma=10^{-2}) ↓\downarrow 8 16 3
Fm​a​xF_{max} [%] ↓\downarrow 9.63 1.82 1.35
E​n​t​r​o​p​yn​o​r​mEntropy_{norm} ↑\uparrow 0.69 0.77 0.91

Table 8: Comparison of vocabulary distributions of different tokenizers on the Bridge.

A.4 Detailed results of different VLM backbones

The comparison begins with pretrained VLM checkpoints, then trains robot policies on LIBERO: PaliGemma/InternVL use their original checkpoints; Qwen2.5 variants use a vision tower/projector trained with LLaVA 1.5 data. “From scratch” here does not mean uninitialized language or vision weights.

Mean FAST→FASTer scores are 84.15→87.00 for Qwen 0.5B, 90.45→92.25 for 1.5B, 91.30→95.45 for 3B, 79.35→96.65 for InternVL 2B, and 93.50→94.80 for PaliGemma 3B. Improvements are in percentage points, not relative percentages; some per-suite scores decline despite better means. No repeated-seed confidence intervals accompany Table 9.

Table 9: Detailed performance of different VLM backbones on Libero
Model Tokenizer Spatial Object Goal Long Average
Qwen2.5-0.5B FAST 92.60 95.80 70.00 78.20 84.15
Ours 90.40 99.00 71.60 87.00 87.00 (↑2.85\uparrow 2.85)
Qwen2.5-1.5B FAST 96.00 92.80 87.20 85.80 90.45
Ours 94.40 97.80 92.00 84.80 92.25 (↑1.80\uparrow 1.80)
Qwen2.5-3B FAST 97.80 93.80 90.20 83.40 91.30
Ours 96.40 99.40 92.00 94.00 95.45 (↑4.15\uparrow 4.15)
InternVL3.5-2B FAST 92.60 95.20 77.20 52.40 79.35
Ours 97.80 98.60 97.20 93.00 96.65 (↑17.30\uparrow 17.30)
Paligemma2-3B FAST 93.40 98.80 95.00 86.80 93.50
Ours 96.60 98.00 95.20 89.40 94.80 (↑1.30\uparrow 1.30)

A.5 Qualitative Analysis of the Tokenizer

Baselines: MiniVLA uses released LIBERO/Bridge codebooks. VQ-VLA is trained on a 1:1 LIBERO/Bridge mixture for 800k steps, batch 1,024, learning rate 5×10⁻⁵ on one H200. FAST+ uses a tokenizer trained on one million robot trajectories. FASTer uses the mixtures listed in Table 3, so reconstruction comparisons do not uniformly match training data or compute.

Trajectories: Figure 14 compares normalized actions on LIBERO, Bridge, xArm and Widow. Red is ground truth, green reconstruction, and the tolerance band is 0.01. Horizontal segments can result from clipping at the 99th-percentile normalization bound; they are not necessarily evidence of constant commanded motion. FAST+/FASTer are generally more stable than the compared smaller VQ models on the shown out-of-domain examples.

Activation: the 256-entry MiniVLA/VQ-VLA books activate every entry, while FAST+ activates 1,175/2,048 on Bridge and 1,067 on xArm. FASTer activates all 4,096; above frequency 10⁻³, counts are 162 on Bridge and 38 on xArm. Full activation alone does not imply uniform or useful codes, and a dash in the table is preserved without assuming it means zero.

Detailed VRR: Figure 13 retains all dataset-specific values at 10⁻², 5×10⁻³ and 10⁻³. Better tolerance scores support reconstruction fidelity under the chosen normalization and evaluation, but not guaranteed closed-loop transfer. Table 8 and Table 10 use different frequency thresholds and must not be combined as the same statistic.

Complete original Figure 13.
Figure 13: Heatmap for detailed VRR of different tokenizers across ID and OOD datasets.
Table 10: Token activation statistics on Bridge and XArm-mixture. Columns show codebook size, active tokens, and counts of tokens exceeding the 10−310^{-3} and 2×10−22\times 10^{-2} thresholds.
Tokenizer Bridge XArm
CB Act. >1​e−3>1e^{-3} >2​e−2>2e^{-2} CB Act. >1​e−3>1e^{-3} >2​e−2>2e^{-2}
VQ-VLA-vq (800k) 256 256 – 1 256 256 – 1
MiniVLA-vq-bridge 256 256 – 1 256 256 – 1
Fast+ 2048 1175 200 – 2048 1067 216 –
FasterVQ 4096 4096 162 – 4096 4096 38 –
Complete original Figure 14.
Figure 14: Visualization of action reconstruction results from MiniVLA, VQ-VLA, Fast+, and FasterVQ on representative trajectories from the Libero, Bridge, XArm, and Widow datasets.

A.6 Use of LLM

The authors report using language models only to polish grammar, wording and clarity; they attribute the research concepts, methods and conclusions to themselves. Figure 15 provides qualitative rollout examples rather than an additional quantitative evaluation.

Complete original Figure 15.
Figure 15: Visualization of our evaluation tasks.
Concept demonstration

Open image ↗