VLA-0: Building State-of-the-Art VLAs with Zero Modification

ArXiv: 2510.13054

🎯 Pitch

Simply writing robot actions as space-separated integers in text — with no model modifications whatsoever — beats far more complex VLA architectures on LIBERO, even surpassing several models pretrained on massive robotics datasets. The key isn't the representation itself but a training trick that randomly masks parts of the action text to stop the model from cheating through auto-completion.

1. Executive Summary

This paper introduces VLA-0, a method for building Vision-Language-Action models that requires zero modification to the underlying VLM architecture — actions are represented directly as space-separated integers in text form and generated through the model's native text generation capability — yet achieves state-of-the-art performance through a careful training and inference recipe involving masked action augmentation (randomly masking characters in the target action string during training to force the model to reason from visual observations rather than auto-completing) and ensemble prediction (averaging temporally overlapping action predictions across a chunked sequence, following ACT). On the LIBERO benchmark using Qwen-VL-2.5-3B, VLA-0 achieves 94.7% average success rate across all four suites, outperforming all existing models trained without large-scale robotic pretraining — including π0.5-KI, OpenVLA-OFT, and SmolVLA — by 1.4 points, and surprisingly surpasses several methods pretrained on large-scale action data including π0 (94.2%) and GROOT-N1 (93.9%), establishing that simple text-based action representation can match or exceed architecturally complex alternatives only when combined with these specific training and inference techniques.

2. Context and Motivation

The Core Problem: We Don't Know How Simple a VLA Can Be

The fundamental question this paper tackles is deceptively simple: can we build a state-of-the-art Vision-Language-Action model without modifying the underlying VLM in any way? Specifically, can we represent robot actions — continuous signals like joint angles, end-effector positions, or gripper commands — directly as text strings (e.g., "4 12 98 3 0 0 13 5...") and have a standard VLM generate them using its native autoregressive language modeling capability?

This question matters because the prevailing trend in the VLA literature has been toward increasing architectural complexity. The paper catalogs three major families of VLA designs (Figure 2), each of which introduces some form of modification to the base VLM:

• Discrete Token VLAs (e.g., RT-2, OpenVLA) discretize continuous actions into bins and map each bin to a token in the VLM's vocabulary — either by repurposing existing low-frequency tokens or by introducing entirely new ones.
• Generative Action Head VLAs (e.g., π0, SmolVLA) keep the VLM's vocabulary intact but attach a separate neural network — typically a diffusion process or flow matching model — that decodes a latent vector produced by the VLM into continuous actions.
• Custom Architecture VLAs (e.g., OpenVLA-OFT, π-FAST) introduce specialized components such as novel action tokenization schemes (e.g., Discrete Cosine Transform in π-FAST), custom decoding heads, or architectural modifications beyond simple head attachment.

The natural question — left largely unexplored by the literature — is whether any of this complexity is actually necessary. The paper frames this explicitly:

"Have we ruled out predicting actions as text? Why not represent actions (e.g., coordinates, joint angles) as numerical strings and generate them using the VLM's native text generation capability?"

This is not a rhetorical question. The fact that the simplest possible approach — direct text generation — has remained "largely unexplored" (Abstract) while the field has invested heavily in specialized architectures reveals a genuine gap in our understanding of what VLAs fundamentally require.

Why This Gap Exists: Implicit Assumptions in Prior Work

The paper identifies several reasons why the text-based approach has been overlooked or dismissed:

1. Resolution anxiety. Continuous actions require fine-grained control. A robot arm might need to specify end-effector positions to within a millimeter or joint angles to within a fraction of a degree. The intuition is that discretizing this continuous space into bins — and then mapping those bins to tokens — would either sacrifice resolution (if the number of bins is small) or consume an impractically large portion of the vocabulary (if fine-grained). Discrete Token VLAs like RT-2 and OpenVLA explicitly embrace this trade-off, accepting that their vocabulary sharing approach constrains action expressiveness. The unstated assumption is that text-based representation would suffer from the same or worse resolution limitations.

2. Token semantics corruption. When Discrete Token VLAs repurpose existing vocabulary tokens for action prediction, they overwrite whatever semantic meaning those tokens originally carried in the language model's embedding space. A token that once represented a common word now represents "joint angle 47 in bin 3." This corruption can degrade the VLM's language understanding and instruction-following capabilities, which are precisely the capabilities that make VLMs valuable as VLA backbones in the first place. The implicit field consensus has been that any approach sharing the text vocabulary for actions inherits this trade-off.

3. Architectural momentum. The Generative Action Head family emerged partly as a response to the limitations of Discrete Token VLAs. By keeping the VLM's vocabulary intact and adding a separate action decoder, these models preserve language understanding while achieving high-fidelity action generation. The success of π0 and SmolVLA reinforced the intuition that a dedicated action generation mechanism is necessary for strong performance. Once this architectural pattern became established, the simpler text-based alternative may have been dismissed without rigorous empirical evaluation — the paper's results suggest this dismissal was premature.

4. Training complexity as a focal point. The recent literature has heavily emphasized training recipe optimization within each architectural paradigm. π0.5-KI focuses on "knowledge insulation" to prevent language degradation during VLA fine-tuning. OpenVLA-OFT develops specialized fine-tuning strategies for speed and success. SmolVLA optimizes for efficiency on affordable hardware. These efforts are valuable, but they share an implicit assumption that the architectural choice itself is settled — that you need either vocabulary modification or an action head. The paper disrupts this assumption by asking: what if we instead focus on the simplest architecture?

Prior Approaches and Their Specific Shortcomings

The paper provides concrete critiques of each existing VLA family (Section I, Introduction):

Discrete Token VLAs (RT-2, OpenVLA, MolmoAct) have two specific limitations:

"(i) it restricts the resolution of the action space, since fine-grained control can require thousands of bins, which conflicts with sharing the text vocabulary; and (ii) it compromises the pretrained language understanding of the VLM by repurposing its vocabulary for actions."

The resolution limitation is quantitative: if you have a vocabulary of, say, 32,000 tokens and need to represent 7 degrees of freedom each with 1,000 possible values, you would need 7,000 tokens just for actions — nearly a quarter of the vocabulary. This is impractical, so models settle for coarser discretization, losing precision. The language degradation problem is qualitative but potentially severe: the VLM's ability to follow instructions, reason about object properties, and ground language in visual scenes depends on the integrity of its token embeddings. Repurposing tokens disrupts this.

The paper notes (Table I) that these models underperform relative to alternatives: OpenVLA (with large-scale action pretraining) achieves only 76.5% average on LIBERO, and MolmoAct reaches 86.8%, trailing architectures from other families.

Generative Action Head VLAs (π0, π0.5-KI, SmolVLA, GR00T-N1, Octo) address the vocabulary issue but introduce their own problem:

"While this method improves action fidelity, it also introduces a new neural network that needs to be finetuned. This often leads to a decline in the language understanding and grounding capabilities of the underlying VLM, and introducing a non-pretrained action head may compromise generalization of the overall system."

This is a different form of the language degradation problem. Rather than corrupting the token space, the action head approach creates a architectural bottleneck: the VLM produces a latent vector that the action head (typically a diffusion model or flow matching network) decodes. During fine-tuning, the VLM's parameters shift to optimize for action prediction through this head, potentially drifting away from the representations that supported strong language understanding. The paper cites π0.5-KI (Driess et al., 2025) which specifically documents this phenomenon and proposes "knowledge insulation" as a mitigation — confirming that the problem is empirically real, not just theoretical.

Additionally, the action head itself starts from random initialization. It has no pretraining, no prior knowledge — it must learn to decode actions entirely from the fine-tuning data. This is a potential weak link in generalization: on novel scenes or instructions, the head may fail even if the VLM's internal representations are sound.

Custom Architecture VLAs (OpenVLA-OFT, π-FAST) achieve strong results — OpenVLA-OFT with large-scale pretraining reaches 97.1% on LIBERO, the highest in Table I — but at the cost of significant architectural complexity and training pipeline specialization. π-FAST uses Discrete Cosine Transform tokenization, which is mathematically elegant but requires domain expertise to implement and tune. OpenVLA-OFT introduces a specialized ACT head with parallel decoding. These methods "typically involve significant architectural changes, additional parameters, or custom training pipelines" — raising the barrier to entry for practitioners and introducing more potential failure modes.

The Unexplored Alternative: Actions as Text

VLA-0's core insight is that none of the above complexity is necessary if you get the training and inference recipe right. The approach is almost embarrassingly simple (Figure 3):

1. Normalize continuous action values to an integer range (e.g., [0, 1000]).
2. Concatenate these integers as space-separated numbers into a text string (e.g., "4 12 98 3 0 0 13 5 123 23 0 0 24 0 132 34 13 0" for an action chunk spanning $H$ timesteps with $D$ dimensions each).
3. Prompt the VLM with a system prompt, task instruction, and camera images, asking it to generate exactly this string.
4. Train with standard next-token prediction (cross-entropy loss).

This approach has several immediate theoretical advantages that the paper highlights implicitly through its experimental results:

• Arbitrary resolution without vocabulary conflict. Since the action is represented as a string of digits (e.g., "1000" is four characters), the resolution is limited only by the string length, not the vocabulary size. A resolution of 1000 (0–999) requires only 3–4 tokens per action dimension, and increasing to 4000 adds no tokens — just larger integer values. Table II (Row 3) confirms that 4000 resolution performs similarly to 1000, while 250 degrades performance (Row 4), suggesting there is a sufficient resolution threshold beyond which gains saturate.

• No vocabulary corruption. Every token generated is a standard digit token (0–9) or space character, all of which exist in the VLM's native vocabulary. There is no repurposing, no new tokens, no disruption to the embedding space. The VLM's language understanding should be preserved because the training signal only reinforces the mapping from visual context to numerical sequences — the semantic meaning of non-numeric tokens remains intact.

• No new parameters. Zero architectural modification means zero randomly initialized components. Every parameter in the system — vision encoder, projection layers, LLM decoder — benefits from full pretraining. This should theoretically improve sample efficiency and generalization, since there are no untrained components that need to learn from scratch.

• Native autoregressive generation. The model generates actions token-by-token using its standard language modeling head. There is no need for a separate decoding process (like diffusion denoising) or specialized sampling strategy. This simplifies both training and inference.

The Critical Role of the Recipe

However, the paper's key empirical finding — and the reason this gap existed — is that naive text-based action generation does not work well on its own. Two specific techniques are required to unlock performance:

1. Masked Action Augmentation. During training, the paper randomly masks out characters in the target action string. This is not data augmentation in the traditional sense (like image transformations) but rather a conditional generation manipulation: by hiding parts of the target sequence, the model is forced to predict those masked characters based on the visual observation and instruction rather than simply auto-completing from the preceding digits. Without this augmentation, the model can learn a shortcut: once it has correctly generated the first few action dimensions, the remaining dimensions are highly predictable from context (since actions at consecutive timesteps or related joints are correlated). This shortcut reduces the model's reliance on visual grounding — it learns to generate plausible action sequences that might not actually correspond to the current scene. Masking disrupts this shortcut, forcing the model to attend to the image for every dimension.

The paper's ablation (Table II, Row 2) shows that removing this augmentation drops success rate by 1.2 points (from 94.7% to 93.5%), confirming its practical importance.

2. Ensemble Prediction (Temporal Action Chunking). At inference time, VLA-0 predicts a chunk of $n$ future actions (following the Action-Chunking Transformer paradigm). For the current timestep $t$, there are $n$ overlapping predictions available: one made at time $t$ (as the first action in its chunk), one made at time $t-1$ (as the second action in its chunk), and so on. VLA-0 averages these $n$ predictions to produce the final action. This temporal ensembling smooths out noise and inconsistencies across predictions, producing more stable robot behavior.

The ablation (Table II, Row 1) shows this is the single most important technique: disabling ensembling drops performance by 2.0 points (94.7% → 92.0%), a larger impact than any other ablation.

Neither technique is architecturally complex — they are purely procedural additions to the training and inference pipelines — but their absence in prior work (like LLARVA, the closest predecessor, which also predicts actions as text but lacks these components) explains why the text-based approach was not previously recognized as competitive.

How the Paper Positions Itself

VLA-0 is explicitly positioned as a rebuttal to the implicit assumption that VLA architecture complexity is necessary. The paper does not claim to introduce a fundamentally new architectural paradigm — in fact, it claims the opposite: the architectural paradigm already exists (standard VLMs) and needs no modification. The contribution is empirical and methodological: demonstrating that the right training and inference recipe transforms a standard VLM into a state-of-the-art VLA.

The paper draws a sharp contrast with the closest prior work, LLARVA (Niu et al., 2024), which also predicts actions as text but uses a two-stage process (first generating a 2D trajectory plan, then generating the action). VLA-0 shows that direct, end-to-end generation is sufficient — no intermediate planning stage is needed. Similarly, HAMSTER (Li et al., 2025) uses a VLM to predict a 2D action trajectory as text in its first stage, but VLA-0 predicts the complete robot action (joint poses or end-effector deltas) directly, without the hierarchical decomposition.

The positioning relative to the broader robot learning literature (Section II) is also notable: while methods like Diffusion Policy and RVT train policies from scratch on in-domain data without leveraging pretrained vision-language models, VLA-0 aligns with the VLA paradigm of building on powerful pretrained representations. The paper's finding that this simple approach can outperform specialized from-scratch methods like Diffusion Policy (72.4% vs. 94.7% average on LIBERO, Table I) demonstrates the power of proper VLM utilization.

The Stakes: Why This Matters Beyond Academic Interest

The practical implications of this finding are significant:

Accessibility. If state-of-the-art VLAs can be built by fine-tuning a standard VLM with no architectural modifications, the barrier to entry drops dramatically. Any practitioner who can fine-tune a VLM can build a VLA — no need to implement diffusion policies, design custom tokenizers, or manage complex multi-component training pipelines. The paper notes that VLA-0 trains in 32 hours on 8 A100 GPUs using a standard PyTorch implementation with the Adam optimizer — a setup accessible to many research labs and companies.

Model agnosticism. VLA-0's approach is VLM-agnostic. While the paper uses Qwen-VL-2.5-3B, the method should transfer to any VLM that supports text generation, including larger, more capable models. This means VLA capabilities should scale naturally with VLM progress — as VLMs improve, VLA-0-style models should improve correspondingly without any architectural rework.

Conceptual clarity. By stripping away architectural complexity, VLA-0 isolates the essential question: how well can a VLM's pretrained representations, when properly prompted and fine-tuned, support robotic control? The strong results suggest that VLM representations are far more capable in this domain than previously assumed, and that much of the VLA literature's complexity may have been solving problems that don't actually exist when the training recipe is right.

Revealing the importance of recipe. Perhaps the deepest contribution is methodological: the paper shows that how you train matters more than what you train. The difference between a failed text-based VLA (presumably what prior researchers encountered, leading them to dismiss the approach) and VLA-0's state-of-the-art performance is not the architecture — it's the masked action augmentation and ensemble prediction. This shifts attention from architectural innovation to training methodology, a lesson that echoes findings in other domains (e.g., the importance of training recipes in computer vision, where ConvNeXt showed that modern training techniques could make standard ConvNets competitive with Transformers).

3. Technical Approach

3.1 Reader Orientation

VLA-0 is a method for converting a standard Vision-Language Model (VLM) into a robot control policy by representing actions as text strings and fine-tuning the VLM to generate these strings autoregressively, with zero architectural modifications. The problem it solves is how to build a Vision-Language-Action model (VLA) that achieves state-of-the-art performance without the complexity of vocabulary modification, custom action heads, or specialized architectures — instead relying on a carefully designed training recipe (masked action augmentation) and inference procedure (temporal action ensembling) that compensate for the simplicity of the text-based representation.

3.2 Big-Picture Architecture (Diagram in Words)

The VLA-0 system has exactly one trainable component — the VLM itself (Qwen-VL-2.5-3B) — and three procedural mechanisms applied during training and inference. Information flows as follows:

1. Input Construction Module — takes the raw sensor data (one or more camera images, a language instruction, and a task description) and formats it into the VLM's standard input structure: a system prompt specifying the action format, the camera images, and the task instruction.
2. Vision-Language Model (VLM) — the same off-the-shelf Qwen-VL-2.5-3B model, with its original vocabulary, vision encoder (ViT), and language model (LLM) completely unmodified. It processes the visual and textual inputs and autoregressively generates a text string of space-separated integers representing a chunk of future actions.
3. Action Decoder — converts the VLM's generated text string back into continuous action values by reversing the normalization: the space-separated integer string is parsed into individual integers, each divided by the normalization range (e.g., 1000), and mapped back to the original continuous action space.
4. Ensemble Aggregator — at inference time, maintains a rolling buffer of the last $n$ predicted action chunks (where $n$ is the chunk size). For the current timestep $t$, it collects the $n$ overlapping predictions made at times $t, t-1, \ldots, t-n+1$ and averages them element-wise to produce the final, temporally smoothed action.
5. Masked Action Augmentation — applied only during training. Before computing the loss, randomly masks a fraction of the characters in the target action string (replacing them with a mask token or simply removing them from the context). This forces the VLM to predict each action digit from the visual observation rather than auto-completing from preceding digits in the sequence.

The entire system adds zero parameters beyond the base VLM. The only differences from a standard VLM fine-tuning setup are: (a) the system prompt structure, (b) the action string format, (c) the random masking during training, and (d) the temporal averaging during inference.

3.3 Roadmap for the Deep Dive

• First, the base VLM architecture and how it is left completely unchanged — to establish that VLA-0 imposes no structural requirements beyond what any standard VLM provides.
• Second, the input formulation — how observations, instructions, and the system prompt are structured into the VLM's native input format, including the specific choices for action discretization range, chunk size, and image handling (separate vs. tiled).
• Third, action decoding — how continuous actions are normalized to integers, concatenated into text, and the specific format constraints that make this work.
• Fourth, the autoregressive training objective — what loss is used, how the cross-entropy objective operates over the integer string, and why this is a natural fit.
• Fifth, masked action augmentation — the specific masking procedure, why it is necessary, the mechanism by which it prevents shortcut learning, and its quantified impact.
• Sixth, ensemble prediction — the temporal action chunking scheme, how overlapping predictions are averaged, why this produces smoother and more stable actions, and its quantified impact relative to other components.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an empirical methods paper whose core idea is that the simplest possible approach — representing robot actions as text strings and fine-tuning a standard VLM with next-token prediction — can match or exceed architecturally complex alternatives, provided that specific training and inference techniques (masking and ensembling) are applied to compensate for the unique challenges of generating precise numerical sequences.

Base VLM: Qwen-VL-2.5-3B (Unmodified)

The foundation of VLA-0 is the 3-billion-parameter Qwen-VL-2.5 model (Yang et al., 2024), used exactly as released by its authors with no architectural modifications of any kind. The paper's choice of this specific model is motivated by three practical factors stated in Section III-A: (1) "highly competitive performance for its model size," making it a strong baseline for VLA construction, (2) "computationally efficient, which facilitates faster training and inference" — a 3B parameter model is manageable on consumer or small-cluster GPU hardware, and (3) "its open-weight nature promotes accessibility and reproducibility," aligning with the paper's goal of demonstrating a simple, reproducible approach.

The Qwen-VL-2.5 architecture follows the standard VLM design pattern, consisting of two major sub-components connected by a projection layer:

Vision Encoder (Vision Transformer). A pretrained Vision Transformer takes one or more images as input and produces a sequence of visual feature vectors — one per image patch plus a global [CLS]-like token, depending on the specific ViT variant used in Qwen-VL-2.5. The ViT is frozen during standard VLM pretraining but is fully fine-tuned during VLA-0's training (the paper states "full fine-tuning" in Section III-B).

Projection Layer. The visual feature vectors are linearly projected into the same embedding space used by the LLM's text tokens. This projection is typically a learned linear transformation (or small MLP) that maps from the ViT's output dimension to the LLM's embedding dimension. In VLA-0, this projection is also fine-tuned — it must learn to map visual features into representations that are useful for generating precise numerical action strings.

Large Language Model (Decoder-only Transformer). The projected visual tokens are concatenated with the text token embeddings (system prompt + task instruction) to form a single interleaved multimodal sequence. The LLM processes this sequence using standard causal (autoregressive) attention, generating output tokens one at a time, each conditioned on all previous tokens (both visual embeddings and text tokens). The LLM's output head — a linear layer followed by softmax over the fixed vocabulary — remains completely unchanged, predicting probability distributions over the exact same set of tokens that Qwen-VL-2.5 was originally trained on.

Why this model matters for the method's generality. The paper explicitly states that "our method is applicable to any other VLM" (Section III-A). The only requirements are that the VLM: (a) accepts image and text inputs, (b) generates text outputs autoregressively, and (c) supports fine-tuning. Since essentially all modern VLMs satisfy these criteria, VLA-0's approach is architecture-agnostic. The Qwen-VL-2.5-3B is a concrete instantiation, not a special case.

The key architectural property that VLA-0 exploits is vocabulary stability: because the VLM's output vocabulary is never modified, the model retains all of its pretrained language understanding. Digit tokens (0–9) and space characters already exist in the vocabulary and carry their usual semantic associations. The fine-tuning process only shifts the conditional distribution over these tokens — teaching the model to emit "4" after "put the banana on the plate" and the camera images, rather than some other token — without overwriting any token embeddings or introducing new ones.

Input Formulation: System Prompt, Images, and Instruction

VLA-0 inherits the input structure of the underlying VLM exactly, with no modifications to tokenization, embedding, or attention mechanisms. The input consists of three components concatenated into a single multimodal sequence:

1. System Prompt. A fixed text string that specifies the high-level format of the expected output. The paper uses the following template (Section III-B):

"Analyze the input image and predict robot actions for the next H timesteps. Each action has D dimensions. Output a single sequence of H × D integers (0 - B each), representing the H timesteps sequentially. Provide only space-separated numbers. Nothing else."

The placeholders H, D, and B are filled in based on the dataset and task configuration. H is the action chunk size (number of future timesteps to predict at once), D is the dimensionality of each action (e.g., 7 for a typical 7-DOF robot arm: 3 for end-effector position delta, 3 for orientation delta, 1 for gripper open/close), and B is the maximum integer value (determined by the action resolution, e.g., 999 for resolution 1000).

The system prompt serves three critical functions. First, it constrains the output format — telling the model to emit only numbers, no natural language explanations or task confirmations, which simplifies parsing and reduces the risk of generating incorrect tokens. Second, it communicates the expected sequence length (H × D integers), which helps the model allocate its generation budget correctly. Third, it specifies the numeric range, preventing the model from generating out-of-range values that would map to invalid actions.

2. Images. VLA-0 accepts one or more images as input, matching the VLM's native image handling capabilities. For the LIBERO simulation experiments, the paper uses two images: a third-person camera view and a wrist-mounted camera view, consistent with the baselines. For real-world experiments with the SO-100 robot, the paper uses left and right camera images (Figure 3).

The paper experiments with two strategies for providing multiple images to the VLM (Table II, Rows 0 vs. 5):

• Separate input: Each image is fed as an independent input to the ViT, producing separate sets of visual tokens that are concatenated in the multimodal sequence. This is the default behavior for VLMs that natively support multi-image inputs.
• Tiled composite input: All images are stitched into a single composite image (e.g., arranged side-by-side) before being fed to the ViT. This reduces the number of visual tokens and can simplify handling for VLMs with limited multi-image support.

The ablation (Table II, Row 5 with non-tiled scoring 94.5% vs. Row 0 with tiled scoring 94.7%) shows a difference of only 0.2 percentage points, which the paper summarizes as: "We find that this decision has no discernible impact on performance." This is a practically useful finding — it means practitioners can choose whichever image handling strategy is most convenient for their VLM and hardware.

3. Task Instruction. A natural language description of the manipulation task, such as "put the banana on the plate" or "place the cupcake in the bowl". This text is tokenized using the VLM's standard text tokenizer and concatenated with the system prompt tokens to form the text portion of the multimodal sequence.

Sequence assembly. The three components are assembled into a single interleaved sequence: visual tokens from all images are interleaved with text tokens according to the VLM's native input format (e.g., text tokens, then image tokens, then more text tokens). The exact interleaving pattern depends on Qwen-VL-2.5's design — typically, image tokens are placed at the positions in the text sequence where a special image placeholder token appears. VLA-0 does not modify this pattern; it uses whatever template the base VLM expects.

Action Representation: Continuous-to-Discrete Normalization

The core representational choice in VLA-0 is how continuous robot actions are converted to text that a VLM can generate. The paper's approach involves three stages:

Stage 1: Normalize to integer range. Each continuous action dimension is individually normalized from its original physical range to a fixed integer range [0, B]. The paper states (Section III-B): "the original continuous action values are first normalized to a fixed integer range (e.g., [0,1000])." The normalization is a simple linear rescaling: given a continuous value $x \in [x_{\text{min}}, x_{\text{max}}]$, the integer representation is:

$x_{\text{int}} = \text{round}\left(\frac{x - x_{\text{min}}}{x_{\text{max}} - x_{\text{min}}} \cdot B\right)$

where $x_{\text{min}}$ and $x_{\text{max}}$ are the known physical limits of that action dimension (e.g., joint angle limits, workspace boundaries), and $B$ is the chosen maximum integer value. The rounding operation maps to the nearest integer. The inverse operation during decoding is:

$x_{\text{recovered}} = \frac{x_{\text{int}}}{B} \cdot (x_{\text{max}} - x_{\text{min}}) + x_{\text{min}}$

where $x_{\text{int}}$ is parsed from the generated text.

What this computes: a lossy compression of the continuous action value into a discrete integer representation. The resolution is determined by $B$: with $B = 1000$, each integer step represents 0.1% of the action range (e.g., for a joint with a 180° range, each integer step represents 0.18°). With $B = 250$, each step represents 0.4%. The paper ablates this choice and finds that $B = 1000$ achieves the best performance (Table II, Row 0: 94.7% at 1000 vs. Row 4: 93.2% at 250), while $B = 4000$ (Row 3: 94.2%) provides no additional benefit — suggesting that 1000 bins (approximately 10 bits of precision) is sufficient for the manipulation tasks in LIBERO, capturing the necessary motion fidelity without wasting representational capacity.

Why this form: linear rescaling is the simplest normalization that preserves the ordering and relative distances of action values. Unlike discretization into bins that are mapped to distinct vocabulary tokens (as in RT-2 and OpenVLA), this representation uses the decimal representation of numbers — each digit is a separate token in the VLM's vocabulary. This means that representing the value 487 requires three tokens (4, 8, 7), not a single dedicated token. The resolution is therefore orthogonal to vocabulary size: you can achieve arbitrary precision by using more digits (larger $B$), without consuming additional vocabulary slots. This is the key advantage over Discrete Token VLAs — increasing resolution from 250 to 4000 does not change the vocabulary at all, only the maximum string length.

Stage 2: Concatenate into action chunks. VLA-0 predicts a chunk of $H$ future actions at once, following the Action-Chunking Transformer (ACT) paradigm (Zhao et al., 2023). Each action has $D$ dimensions. The model therefore generates a sequence of $H \times D$ integers. These integers are concatenated in temporal order: all $D$ dimensions for timestep $t$, followed by all $D$ dimensions for timestep $t+1$, and so on up to timestep $t+H-1$. Each integer is represented as its decimal digit string, and consecutive integers are separated by a single space character.

For example, with $H = 3$ and $D = 6$ (e.g., 3D position delta + 3D orientation delta for a 6-DOF action), the output string would be:

127 483 89 512 734 201 131 479 92 508 730 204 135 482 95 511 728 198

where the first 6 numbers are the action at timestep $t$, the next 6 are timestep $t+1$, and the final 6 are timestep $t+2$.

Stage 3: Text tokenization. The VLM's standard tokenizer converts this string into a sequence of tokens. Each digit (0–9) and each space character is a separate token in the VLM's vocabulary. The model never needs to learn new tokens or repurpose existing ones — it simply learns to emit the right sequence of digit and space tokens conditioned on the visual and textual input.

A subtle consequence of this representation: the model must learn the decimal structure of numbers — that "127" (tokens: 1, 2, 7) represents a single value that is the sum of 100 + 20 + 7, not three independent values. This is a non-trivial learned behavior, but the paper's results show that the VLM can acquire it through fine-tuning. The masked action augmentation (discussed below) plays a key role in forcing this learning.

Training Objective: Next-Token Prediction with Cross-Entropy Loss

VLA-0 is trained using the exact same objective as the base VLM's pretraining: causal language modeling with cross-entropy loss over the fixed vocabulary. There is no auxiliary loss, no reinforcement learning, no specialized action prediction loss — just standard next-token prediction.

Given an input sequence consisting of the system prompt tokens, image tokens, and task instruction tokens (collectively, the prefix), the model must predict the target action string one token at a time. Let the full sequence of tokens be $z_1, z_2, \ldots, z_T$, where tokens $1$ through $M$ are the prefix (including visual tokens) and tokens $M+1$ through $T$ are the target action string. The training loss is:

$\mathcal{L} = -\frac{1}{T - M} \sum_{t=M+1}^{T} \log p_\theta(z_t \mid z_{<t}, I)$

where $p_\theta(z_t \mid z_{<t}, I)$ is the VLM's predicted probability for the correct token $z_t$ given all previous tokens $z_{<t}$ and the image(s) $I$, and $\theta$ represents all trainable parameters (ViT, projection layer, and LLM — everything is fine-tuned).

What this computes: the average negative log-likelihood of the correct action tokens, summed over all positions in the action string. For each position $t$ in the action string, the model produces a probability distribution over its entire vocabulary (all 100,000+ tokens in Qwen-VL-2.5's vocabulary). The loss penalizes the model based on how much probability mass it assigned to the correct token at that position — if the correct token is '4' and the model assigned probability 0.8 to '4', the loss contribution is $-\log(0.8) \approx 0.22$; if it only assigned 0.1 to '4', the loss contribution is $-\log(0.1) \approx 2.30$. The loss is averaged over all $T - M$ positions in the action string to produce a single scalar.

Why this form: causal language modeling with cross-entropy is the maximum-likelihood objective for autoregressive sequence generation. It is the standard loss function used to pretrain and fine-tune all LLMs and VLMs. By using exactly this loss, VLA-0 ensures that: (a) the training process is compatible with all existing VLM training infrastructure (no custom loss functions needed), (b) the model's pretrained knowledge is preserved through the same optimization landscape it was originally trained in, and (c) the gradients flow naturally through the model's existing output head without requiring any modification. Using a regression loss (MSE on the continuous action values) would require replacing the output head and would not leverage the VLM's pretrained token prediction capabilities.

A critical detail: the loss is computed only on the action string tokens, not on the prefix tokens. This is standard for conditional generation — the model should learn to predict actions given the context, not to predict the context itself. The system prompt, instruction, and image tokens are provided as input but their cross-entropy is not included in the training loss. This focuses the entire optimization signal on the action prediction task.

The paper reports the following training hyperparameters (Section III-B): "Adam optimizer, 64 epochs, batch size 192, learning rate 5e-6, training time approximately 32 hours on 8 A100 GPUs." The use of full fine-tuning (all parameters updated) rather than parameter-efficient methods (like LoRA) is a deliberate choice — it gives the model maximum capacity to adapt its visual and language representations to the action prediction task. The batch size of 192 and 64 epochs suggest relatively aggressive training, which may be necessary to overcome the initial mismatch between the VLM's pretraining distribution (natural images and text) and the target distribution (robot camera views and numerical action strings).

Masked Action Augmentation

Masked Action Augmentation is a training-time technique that randomly removes information from the target action string, forcing the model to predict each digit based on the visual input rather than by auto-completing from the preceding digits. This is the paper's primary training innovation and is described in Section III-B.

Procedure. During training, for each sample in the batch, a random subset of the characters in the target action string are masked (replaced with a special mask token or removed from the context available to the model at that position). The model must then predict the correct character at each masked position based solely on the prefix (system prompt, images, instruction) and any unmasked characters that appear before that position.

Concretely, if the target action string is "127 483 89", a masked version might look like "1_7 48_ 8_" where _ represents a masked position. At position where the first 2 should appear, the model sees only 1 preceding it (and the prefix), not 2. When predicting the 9 at the end of 89, the model sees the full prefix plus "1_7 48_" — it has partial information from the preceding digits but must still rely on the visual observation to determine that the last digit is 9 (not 0, 1, etc.).

What this computes: a modified training signal where the model's prediction at each position depends more heavily on the visual and instruction context (which are never masked) and less on the local sequential context of the action string (which is randomly degraded). The masking probability is a hyperparameter that controls the trade-off: 0% masking means standard autoregressive training (the model sees all previous digits and can learn sequential shortcuts), while 100% masking would mean the model must predict every digit independently from the image alone (losing the benefits of autoregressive coherence).

Why this form: the motivation stems from a specific failure mode of text-based action generation. Without masking, the model can learn a shortcut: once it has correctly generated the first few action dimensions (which are highly constrained by the visual scene — e.g., the end-effector must move toward a specific object), the remaining dimensions become strongly predictable from the preceding ones due to the physical correlations in robot motion. For example, if the model correctly generates the first three position coordinates of a reaching motion, the subsequent orientation coordinates and gripper command are largely determined by the task context and the preceding trajectory — the model can "autocomplete" the action string without continuing to attend to the image. This shortcut reduces the model's reliance on visual grounding, leading to actions that look plausible but are actually disconnected from the current scene state.

Masking disrupts this shortcut by randomly removing the preceding digits that the model would otherwise use for autocompletion. At masked positions, the model is forced to fall back on the only remaining information source: the visual observation and task instruction. This ensures that the model learns to ground every action dimension — not just the first few — in the visual scene.

The ablation in Table II (Row 2 vs. Row 0) quantifies this effect: removing masked action augmentation drops the average success rate from 94.7% to 93.5%, a decrease of 1.2 percentage points. While this is a smaller effect than removing ensembling (2.0 point drop), it is still a meaningful contribution. Notably, the benefit is described as "modest but consistent" (Section IV-E), suggesting it improves robustness across the task distribution rather than dramatically transforming performance on any single task.

Connection to other masking techniques. Masked Action Augmentation resembles techniques from other domains: it is structurally similar to masked language modeling (e.g., BERT), where random tokens are masked and the model must predict them from surrounding context. However, the motivation is different — the goal is not to learn bidirectional representations (VLA-0 remains autoregressive) but to prevent the autoregressive shortcut. It also resembles teacher forcing with scheduled sampling, where the model learns to be robust to errors in its own predictions by occasionally conditioning on imperfect context. In VLA-0's case, the "imperfect context" is the randomly masked action string, and the robustness gain is against visual disconnection rather than cascading errors.

Ensemble Prediction (Temporal Action Chunking)

Ensemble prediction is an inference-time technique that smooths the robot's actions by averaging multiple temporally overlapping predictions. This is the paper's primary inference innovation, inherited from the Action-Chunking Transformer (ACT) and also used by OpenVLA-OFT.

Procedure. At each inference step, VLA-0 predicts a chunk of $n$ future actions (not just the single next action). This chunk spans timesteps $t, t+1, \ldots, t+n-1$. Because the model predicts chunks at every timestep, there are $n$ separate predictions available for the action at any given timestep $t$:

• The prediction made at time $t$ (the first action in the chunk generated at time $t$)
• The prediction made at time $t-1$ (the second action in the chunk generated at time $t-1$)
• The prediction made at time $t-2$ (the third action in the chunk generated at time $t-2$)
• ...and so on, back to the prediction made at time $t-n+1$ (the $n$-th action in the chunk generated at time $t-n+1$)

For each dimension of the action at timestep $t$, VLA-0 collects these $n$ overlapping predictions — each represented as an integer normalized to the $[0, B]$$ range — and computes their element-wise average to produce the final action value:

$a_t^{\text{final}} = \frac{1}{n} \sum_{k=0}^{n-1} a_{t-k}^{(k)}$

where $a_{t-k}^{(k)}$ is the $k$-th action in the chunk predicted at timestep $t-k$ (using zero-indexing: $k=0$ is the first action in the chunk, predicted at time $t$; $k=1$ is the second action in the chunk, predicted at time $t-1$; and so on). The result $a_t^{\text{final}}$ is a single action vector of dimension $D$ that is executed by the robot at timestep $t$.

What this computes: a temporally smoothed action estimate that averages out noise and inconsistencies across the $n$ overlapping predictions. Each prediction was made from a slightly different observation (images at times $t, t-1, \ldots, t-n+1$), so they capture slightly different information about the scene. Averaging them combines this information while canceling out uncorrelated prediction errors — akin to an ensemble of models or a Kalman filter's integration of multiple noisy measurements.

Why this form: the motivation comes from the Action-Chunking Transformer's observation that predicting a chunk of actions rather than a single action improves temporal consistency and reduces jittery motion. The overlapping ensemble further exploits this chunk structure: rather than only using the most recent prediction (which might be noisy due to a single bad image frame or momentary VLM error), the ensemble incorporates slightly older predictions that were made from different viewpoints or under different conditions. If an error in one prediction is uncorrelated with errors in the others, averaging reduces the error variance by a factor of $n$ (assuming independent errors). In practice, errors are correlated (consecutive observations are similar), so the reduction is smaller than $1/n$, but the paper's ablation shows it is still substantial.

The ablation in Table II (Row 1 vs. Row 0) quantifies this: disabling ensemble prediction drops the average success rate from 94.7% to 92.0%, a decrease of 2.0 percentage points — the largest effect among all ablations. This makes ensemble prediction the single most important component of the VLA-0 recipe. The paper states (Section IV-E): "We find that this technique is a critical component, improving the overall success rate by 2 points."

Practical considerations. The paper notes a limitation of ensemble prediction for real-world deployment: "For simplicity, we do not ensemble actions in real, although it is possible to do so but requires 8 simultaneous running instances of the model" (Section IV-D). This is because the ensemble requires maintaining predictions from the last $n$ timesteps — if $n = 8$, you need eight separate forward passes with different observation histories. This can be done in parallel (eight instances running simultaneously) but doubles the computational requirements. For the real-world experiments, VLA-0 runs at 4 Hz on a desktop with a 5090 GPU without ensembling, suggesting that adding ensembling would either reduce the control frequency or require more hardware. The paper leaves this as a trade-off for practitioners.

History buffer implementation. To implement ensembling, the system maintains a rolling buffer of the last $n$ predicted action chunks. Each new chunk prediction pushes the oldest chunk out of the buffer. At each timestep, the ensemble aggregator indexes into the buffer based on chronological position: the current chunk contributes its first action, the previous chunk contributes its second action, and so on. This requires reverse-indexing (the chunk from $n-1$ steps ago contributes its $n$-th action), which is straightforward to implement with a fixed-size circular buffer.

Summary of Design Choices and Their Justifications

Qwen-VL-2.5-3B as the base model: chosen for competitive performance, computational efficiency, and open-weight accessibility, but the method is explicitly VLM-agnostic — any VLM that accepts images and generates text should work.

Full fine-tuning rather than parameter-efficient methods: gives the model maximum capacity to adapt all representations (vision, language, and the connections between them) to the action prediction task. The trade-off is higher memory and compute requirements during training (8 A100 GPUs for 32 hours), but this is within reach of many research labs.

Integer normalization range of 1000: determined via ablation to provide sufficient action resolution without wasting representational capacity. Resolution 250 degrades performance (93.2% vs. 94.7%), while 4000 provides no additional benefit (94.2% vs. 94.7%), suggesting a saturation point around 10 bits of precision.

Separate vs. tiled images: an implementation detail with negligible impact (0.2 point difference in ablation). Practitioners should choose whichever their VLM and hardware handle most efficiently.

Masked Action Augmentation: motivated by the autoregressive shortcut problem — without it, the model learns to auto-complete action strings from preceding digits rather than grounding them in visual observations. The masking forces visual attention for every action dimension, producing a 1.2-point improvement in the ablation.

Ensemble Prediction: motivated by temporal smoothing — averaging overlapping predictions from consecutive timesteps reduces noise and jitter, producing more stable and accurate robot actions. This is the single most impactful component, contributing 2.0 points in the ablation.

Standard cross-entropy loss: chosen for compatibility with existing VLM training infrastructure and to preserve the model's pretrained knowledge through the same optimization landscape. No auxiliary losses or specialized action prediction heads are needed.

4. Key Insights and Innovations

Innovation 1: Complexity in VLA Design Is Largely Unnecessary — The Null Architecture Is Sufficient

This paper's most fundamental intellectual contribution is not a new technique but a diagnostic null result: it demonstrates that the architectural complexity the field has been adding to Vision-Language-Action models — modified vocabularies, specialized action heads, custom tokenization schemes, hierarchical planning stages — is unnecessary for achieving state-of-the-art performance. VLA-0's architecture is literally nothing added to the base VLM: no new tokens, no new layers, no new heads, no separate decoders. The fact that this zero-modification approach outperforms π0.5-KI (93.3%), SmolVLA (88.8%), and π0-FAST (71.8%) on LIBERO (Table I) — all models that introduced substantial architectural complexity — constitutes a powerful existence proof that the field has been solving problems that don't actually exist, at least for the manipulation tasks represented in LIBERO.

What makes this a genuine diagnostic finding rather than just a strong result is that it isolates architecture from recipe. Prior work conflated the two: when a complex architecture worked better than a simple baseline, the natural conclusion was that the complexity was necessary. But the paper shows that when you equip the simplest possible architecture with the right training recipe (masking) and inference procedure (ensembling), it surpasses the complex architectures. This implies that much of the prior architectural innovation may have been compensating for suboptimal training recipes rather than solving fundamental representational problems. The fact that VLA-0 without large-scale action pretraining (94.7%) beats π0 with large-scale pretraining (94.2%) — π0 being one of the most prominent Generative Action Head VLAs with a sophisticated flow-matching action decoder — makes this point sharply: the pretrained action head that π0 invested so heavily in is providing, at best, no advantage over simply generating digits as text, and possibly a disadvantage given that π0 had access to far more training data.

This is a fundamental reframing of the VLA design space, not an incremental improvement. It suggests that the primary challenge in building VLAs is not representation of actions but rather proper utilization of the VLM's existing capabilities. The paper's key intellectual move is asking "what if the VLM already knows how to represent actions, and we just need to teach it the right output format?" rather than the dominant question "how should we modify the VLM to handle actions?" This shifts the research agenda from architectural innovation toward training methodology — a lesson that echoes the ConvNeXt finding in computer vision, where modern training recipes made standard ConvNets competitive with Vision Transformers. If the paper's finding generalizes to other domains and VLM backbones, it suggests that each new VLM release is already a near-complete VLA, waiting only for the right fine-tuning recipe.

Innovation 2: Masked Action Augmentation as a Diagnostic Tool for Shortcut Learning in Action Generation

The paper introduces Masked Action Augmentation as a training technique, but its deeper contribution is identifying and naming the autoregressive shortcut problem in text-based action generation. The core insight: when a VLM generates a sequence of action digits autoregressively, it can learn to auto-complete the sequence from preceding digits rather than grounding each digit in the visual observation. This is a specific instance of the broader shortcut learning problem in deep learning — the model finds a spurious predictive signal (sequential correlations in the action string) that works on the training distribution but fails under distribution shift or when the visual scene changes.

What distinguishes this contribution is that it diagnoses why previous text-based approaches likely failed. The paper's closest predecessor, LLARVA (Niu et al., 2024), also generates actions as text but uses a two-stage process (2D trajectory plan, then action) and does not report competitive results against state-of-the-art VLAs. The paper's implicit argument is that LLARVA's underperformance (and the field's subsequent abandonment of text-based approaches) was not due to fundamental limitations of text representation, but rather due to the absence of techniques that prevent the autoregressive shortcut. The hierarchical planning stage in LLARVA can be reinterpreted as a different (and less effective) attempt to force visual grounding — by making the model first generate an explicit plan, it ensures the model can't just auto-complete actions. Masked Action Augmentation achieves the same goal more directly and effectively.

The diagnostic power of this technique extends beyond VLA-0. The paper has essentially developed a litmus test for whether a text-based VLA is suffering from shortcut learning: if removing the masking causes a performance drop (the 1.2-point effect in Table II, Row 2), the model was relying on sequential correlations rather than visual grounding for some fraction of its predictions. This concept — that the ratio of masked-to-unmasked performance measures the degree of shortcut dependence — is a methodological contribution that future work on text-based action generation can use as a diagnostic. It transforms masking from a performance-boosting trick into a measurement tool that reveals how the model is solving the task.

This is an incremental technical contribution with fundamental diagnostic implications — the technique itself (random character masking during training) is simple, but the conceptual framing it enables (shortcut detection and prevention in sequential action generation) provides a new lens for understanding VLA behavior that was absent from prior work.

Innovation 3: Temporal Action Ensembling Is More Important Than Architecture — And Its Absence Explains Prior Negative Results

The paper's ablation (Table II) reveals a striking hierarchy: removing ensemble prediction costs 2.0 points (Row 1), while removing all architectural complexity of competing methods (their action heads, custom tokenizers, modified vocabularies) costs... nothing, because VLA-0 never had them and still wins. This inverts the field's assumed importance ordering. The dominant assumption in prior work was that how you represent actions architecturally is the primary determinant of VLA performance — hence the proliferation of custom action heads (π0, SmolVLA), specialized tokenization (π-FAST, RT-2), and modified decoding schemes (OpenVLA-OFT). VLA-0's results suggest that how you aggregate predictions across time matters more than any of these architectural choices.

This is a genuinely surprising finding because temporal ensembling is not a representation choice — it's a post-processing step that could be applied to any VLA, regardless of architecture. The fact that this simple averaging operation over temporally overlapping predictions provides a larger performance boost than all the architectural innovations of competing methods combined (since VLA-0 with just ensembling and masking beats all of them) implies that the primary failure mode of VLAs is not poor action representation but temporal inconsistency — the model produces actions that are individually reasonable but collectively jittery or incoherent across timesteps. Ensemble prediction smooths this temporal noise, and the 2.0-point improvement quantifies just how much noise there is to smooth.

This reframes the VLA problem from "how do we represent actions well?" to "how do we produce temporally coherent action sequences?" — a shift from a static representation problem to a dynamic consistency problem. The fact that OpenVLA-OFT (the strongest baseline at 97.1% with large-scale pretraining) also uses ACT-style ensembling, while earlier underperforming methods like standard OpenVLA (76.5%) do not, corroborates this interpretation. The field may have been attributing OpenVLA-OFT's gains to its custom architecture (specialized ACT head) when in fact the ensembling — a technique orthogonal to architecture — was doing much of the work.

This is a reframing with strong empirical support rather than a fundamentally new technique. The ensembling method itself is inherited from ACT (Zhao et al., 2023). The innovation is in recognizing its outsized importance relative to architectural choices and using ablation to quantify that importance, thereby redirecting attention from representation design to temporal integration strategies.

Innovation 4: Pretrained VLMs Already Possess the Capacity for Fine-Grained Action Generation — We Just Weren't Asking Correctly

Perhaps the deepest implication of VLA-0's results is what they reveal about the pretrained representations inside VLMs. The Qwen-VL-2.5-3B model was trained on natural images and text — photographs, diagrams, web pages, documents. Nothing in its pretraining involved robot camera views, end-effector kinematics, or action trajectories. Yet with only 32 hours of fine-tuning on task-specific robot data (and no large-scale robotic pretraining), it achieves 94.7% average success on LIBERO, outperforming models like π0 that were pretrained on massive robot datasets.

This implies that the gap between "understanding a visual scene" (what VLMs learn from pretraining) and "producing precise motor commands" (what VLAs need to do) is much smaller than previously assumed. The paper's contribution is not proving this gap is small — that's an empirical observation — but rather showing that the gap appears large only when you use the wrong output format. When prior work introduced specialized action heads (π0's flow-matching decoder, SmolVLA's diffusion head), they were implicitly assuming that the VLM's native text generation capability was insufficient for precise action specification — that you needed a dedicated continuous-output mechanism. VLA-0 shows that the VLM's text generation, when properly prompted and trained, produces actions that are more precise than those from dedicated action heads, at least as measured by task success.

This finding has a specific theoretical implication: the VLM's output space is not the bottleneck for action precision. A text string of digits can represent any real number to arbitrary precision (by adding more digits), and the VLM can learn to generate these strings accurately. The bottleneck, if it exists, is in the visual representations — can the VLM perceive the scene with sufficient spatial precision to compute the right action values? VLA-0's strong performance suggests that the answer is yes, at least for the manipulation tasks in LIBERO. The visual features extracted by the ViT and processed by the LLM contain enough geometric and spatial information to specify action coordinates to within 0.1% resolution (with B=1000), and the LLM can successfully decode these features into numerical outputs.

This is a fundamental empirical finding about the nature of VLM representations, not an incremental technique. It challenges the dominant assumption that VLMs need architectural modification to serve as robot policies, and instead suggests that the field's prior negative results with simple approaches may have been due to asking the model to produce actions in suboptimal formats (e.g., forcing discrete bins that lose precision, as in RT-2), or failing to provide the right training incentives (e.g., lacking masking to prevent shortcut learning), rather than any inherent limitation of VLM representations for motor control.

5. Experimental Analysis

Evaluation Methodology

• Dataset. All experiments use the LIBERO benchmark (Liu et al., 2023), a widely adopted benchmark for comparing VLA models. LIBERO consists of four suites — Spatial, Object, Goal, and Long — each containing 10 tasks, with each task evaluated over 50 episodes (500 total test episodes per suite). Each suite is designed to assess a system's capability along a particular dimension: Spatial tests spatial reasoning, Object tests object identification, Goal tests goal-directed behavior, and Long tests long-horizon task completion.

• Base model(s). All VLA-0 experiments use the Qwen-VL-2.5-3B model (Yang et al., 2024), a 3-billion-parameter open-weight Vision-Language Model. The paper states this choice is motivated by competitive performance for its model size, computational efficiency enabling faster training and inference, and open-weight nature promoting accessibility. The model is used with no architectural modifications — the standard ViT vision encoder, projection layer, and decoder-only LLM remain exactly as released.

• Metrics. The primary metric is task success rate (%) — the fraction of evaluation episodes in which the robot successfully completes the specified task (e.g., placing the banana on the plate, pushing the apple to the block). Success is reported per-suite (Spatial, Object, Goal, Long) and as an overall average across the four suites. For real-world evaluation, success rate is reported per-task across varied initial object conditions. The paper also reports average rank across the four LIBERO suites as a summary statistic in Table I.

• Baselines. The paper compares against a comprehensive set of VLA models drawn from all three architectural families:

  • Discrete Token VLAs: OpenVLA (Kim et al., 2024) and MolmoAct (Lee et al., 2025)
  • Generative Action Head VLAs: Octo (Team et al., 2024), π0 (Black et al., 2024), GR00T-N1 (Bjorck et al., 2025), π0.5-KI (Driess et al., 2025), and SmolVLA (Shukor et al., 2025)
  • Custom Architecture VLAs: π0-FAST (Pertsch et al., 2025) and OpenVLA-OFT (Kim et al., 2025)
  • Non-VLA baseline: Diffusion Policy (Chi et al., 2023), a leading from-scratch policy that models actions via conditional diffusion Baseline results for LIBERO (Table I) are drawn from prior publications and organized into two groups: models trained with the same amount of robotic action data as VLA-0 (no large-scale action pretraining), and models that benefited from large-scale action pretraining on additional robotic datasets.

• Generation budget / compute accounting. For simulation experiments, all models are compared on the LIBERO benchmark using the standard evaluation protocol of 50 episodes per task. Training compute is reported in terms of hardware and time: "approximately 32 hours on 8 A100 GPUs" using a batch size of 192 and 64 epochs. Inference speed for real-world experiments is reported as 4 Hz on a desktop with a 5090 GPU. The paper does not attempt to FLOPs-match or budget-equate the training processes of different VLA architectures — the comparison is purely on final task performance.

• Cross-validation / statistical protocol. The paper does not report cross-validation or statistical significance testing for the LIBERO results. Performance is reported as raw success rates aggregated over 50 episodes per task, with no confidence intervals or standard errors. The ablation studies (Table II) report the absolute change in average success rate (∆perf.) without error bounds. For real-world evaluation, each task uses 100 demonstrations for training and is evaluated across "varied initial conditions of the objects to test for robustness" (Section IV-A), but the number of evaluation trials per task is not specified in the main text.

Main Quantitative Results

Simulation Results: LIBERO Benchmark (Table I)

The central quantitative finding is VLA-0's performance on the four LIBERO suites, reported in Table I. The table is organized into two major groups: models trained without large-scale action pretraining (the fair comparison group for VLA-0) and models trained with large-scale action pretraining (included for completeness, to show how VLA-0 stacks up even against models with a data advantage).

Comparison against models without large-scale action pretraining. VLA-0 achieves an average success rate of 94.7% across the four suites, with individual suite scores of:

• Spatial: 97.0%
• Object: 97.8%
• Goal: 96.2%
• Long: 87.6%

This places VLA-0 first among all models in this group, outperforming the second-best method (π0.5-KI at 93.3% average) by 1.4 percentage points. The margin is not uniform across suites — VLA-0 and π0.5-KI are close on Spatial (97.0% vs. 96.6%) and Object (97.8% vs. 97.2%), but VLA-0 pulls ahead on Goal (96.2% vs. 94.6%) and especially Long (87.6% vs. 85.8%). The Long suite, which tests long-horizon task completion and is typically the hardest, shows VLA-0's largest relative advantage within this group.

The remaining baselines in this group trail more substantially: OpenVLA-OFT (91.9% average), SmolVLA-2.25B (88.8%), SmolVLA-0.24B (82.8%), Diffusion Policy (72.4%), and π0-FAST-Paligemma (71.8%). VLA-0's average rank (computed across the four suite-level rankings) is 1.0 — meaning it ranked first on every individual suite — compared to π0.5-KI at 2.3 (ranked second on three suites and third on one), and OpenVLA-OFT at 2.8.

Comparison against models with large-scale action pretraining. Despite having no large-scale action pretraining, VLA-0's 94.7% average outperforms several models that did have access to large-scale robotic data:

• π0 (94.2%): VLA-0 beats π0 by 0.5 points, despite π0 being one of the most prominent Generative Action Head VLAs with extensive action pretraining
• GR00T-N1 (93.9%): VLA-0 leads by 0.8 points
• π0.5-KI with pretraining (94.3%): VLA-0 leads by 0.4 points
• MolmoAct (86.8%): VLA-0 leads by 7.9 points
• π0-FAST with pretraining (86.0%): VLA-0 leads by 8.7 points
• Octo (75.1%) and OpenVLA (76.5%): VLA-0 leads by approximately 18–19 points

VLA-0's average rank among all 14 model configurations in Table I is 2.8, trailing only OpenVLA-OFT with large-scale pretraining (average rank 1.5, 97.1% average success rate). This is the only model that meaningfully outperforms VLA-0. The key detail: OpenVLA-OFT achieves 97.1% with large-scale action pretraining, while VLA-0 achieves 94.7% without it — a 2.4-point gap that might be attributable to OpenVLA-OFT's data advantage, architectural choices, or both.

The practical significance of the 1.4-point margin over π0.5-KI. While 1.4 percentage points may seem small, it represents the gap between VLA-0 (a zero-modification approach) and the best available alternative that also lacks large-scale pretraining. The paper frames this as "highly surprising" and "runs counter to the expectations set by existing literature" (Section IV-C) because prevailing wisdom suggested that architectural complexity was necessary for competitive performance. The fact that VLA-0 doesn't just match but exceeds methods with diffusion action heads, custom tokenizers, and modified vocabularies — while adding zero parameters beyond the base VLM — is the result that challenges the field's assumptions.

Real-World Results: SO-100 Robot (Figure 4)

The real-world experiments test whether VLA-0's simulation performance translates to physical hardware. The comparison is against SmolVLA (Shukor et al., 2025), which the paper describes as "a strong baseline that was specifically trained on the large-scale SO-100 dataset and has been shown to outperform popular methods like π0 and ACT on this platform" (Section IV-D). SmolVLA had access to large-scale real-world action pretraining; VLA-0 was trained only on the 100 demonstrations per task collected for this experiment.

Figure 4 reports task-level success rates on four manipulation tasks:

VLA-0 outperforms SmolVLA on three of four tasks, with particularly large margins on "Push apple to block" (+30 percentage points) and "Place banana on plate" (+25 points). On "Reorient block," SmolVLA outperforms VLA-0 (45% vs. 30%), showing VLA-0 is not universally superior. The average advantage of 12.5 percentage points (60.0% vs. 47.5%) is described by the paper as demonstrating "that our method's effectiveness translates from simulation to real" (Section IV-D).

Several contextual details are important for interpreting these results:

• Data disparity. SmolVLA was pretrained on the large-scale SO-100 dataset (a collection of diverse robot manipulation demonstrations), while VLA-0 was trained from scratch on only 100 demonstrations per task (400 total demonstrations). VLA-0's advantage despite this data deficit strengthens the claim that the text-based approach is data-efficient.

• No ensemble prediction in real. The paper notes: "For simplicity, we do not ensemble actions in real, although it is possible to do so but requires 8 simultaneous running instances of the model" (Section IV-D). Since the ablation (Table II, Row 1) shows ensembling provides a 2.0-point improvement in simulation, the real-world results likely underrepresent VLA-0's potential performance. Adding ensembling (requiring parallel model instances) could increase the margin further.

• Inference speed. VLA-0 achieves 4 Hz on a desktop with a 5090 GPU using standard PyTorch. This is relatively slow for real-time control (many robot policies run at 10–30 Hz), but the paper states this "could be significantly increased through techniques such as model distillation or quantization" (Section IV-D). SmolVLA's inference speed is not reported, making a direct latency comparison impossible.

• Small evaluation scale. The paper does not report the number of evaluation trials per task. With only four tasks and unspecified trial counts, the real-world results should be interpreted as a proof-of-concept that VLA-0 works on physical hardware, not as a statistically rigorous comparison. The 12.5-point average advantage could shift substantially with different task selections or more trials.

Ablation Studies and Robustness Checks

All ablations are conducted on the LIBERO benchmark using the average success rate across the four suites as the metric, with the full VLA-0 configuration (Row 0) serving as the reference at 94.7%. Table II reports the results.

Action Ensembling (Row 1 vs. Row 0): Disabling ensemble prediction — i.e., using only the most recent action prediction rather than averaging overlapping predictions across the temporal chunk — reduces the average success rate from 94.7% to 92.0%, a drop of 2.0 percentage points. This is the largest single-factor effect in the ablation and confirms ensemble prediction as the most critical component of the VLA-0 recipe. The paper states: "We find that this technique is a critical component" (Section IV-E).

The mechanism is temporal smoothing of prediction noise. Without ensembling, the robot executes the raw first-action prediction from the current chunk, which may contain artifacts from a single bad image frame, momentary VLM error, or stochastic sampling. Averaging across n overlapping predictions (each made from a slightly different observation at times t, t-1, ..., t-n+1) cancels uncorrelated errors and produces more stable trajectories. The 2.0-point effect quantifies how large this noise is — suggesting that without ensembling, roughly 2% of episodes that would otherwise succeed fail due to action instability.

Masked Action Augmentation (Row 2 vs. Row 0): Removing masked action augmentation during training — i.e., training on unmasked (fully visible) action strings — reduces the average success rate from 94.7% to 93.5%, a drop of 1.2 percentage points. The paper describes this as providing "a modest but consistent benefit" (Section IV-E).

This result directly supports the paper's claim that masking prevents the autoregressive shortcut. Without masking, the model can learn to auto-complete the action string from preceding digits, reducing its reliance on visual grounding. The 1.2-point effect indicates that this shortcut is learned and does degrade performance — the model makes errors on a small but consistent fraction of episodes where the visual scene has changed in ways that make the sequential shortcut produce incorrect actions. The fact that the effect is smaller than ensembling's (1.2 vs. 2.0 points) suggests that the autoregressive shortcut, while real, is not as damaging as temporal inconsistency — the model can often get away with auto-completing because action sequences are somewhat predictable from context, just not perfectly.

Action Resolution (Rows 3 and 4 vs. Row 0): The action resolution parameter B — the maximum integer value used in the normalization from continuous to discrete actions — is ablated at three levels:

• B = 1000 (Row 0, reference): 94.7% average
• B = 4000 (Row 3): 94.2% average, a drop of 0.5 percentage points
• B = 250 (Row 4): 93.2% average, a drop of 1.5 percentage points

The paper concludes: "For the LIBERO benchmark, we find that a resolution of 1000 is sufficient. Decreasing the resolution to 250 degrades performance... while a higher resolution of 4000 yields no additional performance gains" (Section IV-E).

The interpretation is that there exists a threshold of action precision below which performance degrades (because the robot cannot execute movements with sufficient fidelity), and above which additional resolution provides no benefit (because the tasks don't require sub-0.1% precision). At B = 250, each integer step represents 0.4% of the action range — for a typical joint with a 180° range, this is 0.72° per step. At B = 1000, each step represents 0.1% or 0.18° per step. The drop at 250 suggests that 0.72° precision is insufficient for some LIBERO tasks (likely those requiring precise positioning like insertion or alignment), while 0.18° precision is adequate. The fact that 4000 (0.025% or 0.045° per step) doesn't help suggests a saturation point between 250 and 1000 — the precision actually needed by LIBERO tasks lies somewhere in this range.

Image Tiling (Row 5 vs. Row 0): Comparing tiled composite images (Row 0, 94.7%) against separate image inputs (Row 5, 94.5%) shows a difference of only 0.2 percentage points, which the paper characterizes as: "We find that this decision has no discernible impact on performance" (Section IV-E).

This negative result is practically useful: it means the choice between tiling multiple camera views into a single composite image versus feeding them as separate inputs to the ViT is not consequential for task performance. Practitioners can choose whichever approach is more compatible with their VLM's input processing pipeline or more efficient for their hardware, without worrying about accuracy trade-offs.

Summary of ablation hierarchy. The components of VLA-0, ranked by their contribution to performance:

1. Ensemble prediction: 2.0 points (critical)
2. Action resolution (250 vs. 1000): 1.5 points (important threshold effect)
3. Masked action augmentation: 1.2 points (modest but consistent)
4. Action resolution (1000 vs. 4000): 0.5 points (saturated, no benefit)
5. Image tiling: 0.2 points (negligible)

This hierarchy reveals that VLA-0's success depends primarily on inference-time temporal smoothing (ensembling) and secondarily on training-time shortcut prevention (masking), with sufficient action precision being a prerequisite (the drop at 250 showing what happens when it's inadequate). The 0-point reference — VLA-0's full configuration without any of these components disabled — is a combination of these individually modest factors that collectively produce state-of-the-art performance.

Critical Assessment

Claim 1: "Simple VLA design achieves state-of-the-art results akin to popular alternatives"

This is the paper's central claim, and the LIBERO results in Table I provide strong support with specific caveats.

What is demonstrated: VLA-0 achieves 94.7% average success on LIBERO, outperforming all 7 baselines trained without large-scale action pretraining (by margins ranging from 1.4 to 22.3 points) and 5 of 7 baselines trained with large-scale pretraining. The architecture is genuinely zero-modification — no new tokens, layers, or heads — so the comparison against complex architectures like π0 (flow-matching action head) and OpenVLA (modified vocabulary) is clean.

What is not demonstrated (and matters):

• Single benchmark. All simulation results are on LIBERO. While LIBERO is widely adopted, it consists of tabletop manipulation tasks with relatively simple dynamics and clearly defined success conditions. Whether VLA-0's advantage holds on benchmarks requiring more dexterous manipulation (e.g., RLBench, CALVIN), mobile manipulation, or tasks with continuous dynamics (pushing, sliding, throwing) is completely untested. The claim "state-of-the-art" is specific to LIBERO but is presented as general.

• Single VLM family. All experiments use Qwen-VL-2.5-3B. The paper claims model-agnosticism ("our method is applicable to any other VLM," Section III-A) but provides zero evidence that the approach works with other VLMs (e.g., LLaVA, InternVL, PaliGemma, GPT-4V). Different VLMs have different visual encoders, language model architectures, training data distributions, and output behaviors — the specific properties that make Qwen-VL-2.5-3B work well with text-based actions (digit token handling, spatial reasoning from ViT features, instruction following) might not transfer. This is a significant gap between the claimed generality and the demonstrated specificity.

• Baseline recency. The baselines are drawn from published results and were not re-trained or re-evaluated under identical conditions by the authors. Differences in training data curation, data augmentation (beyond the task demonstrations), hyperparameter tuning effort, and evaluation protocol could confound the comparison. For example, all baselines were presumably optimized for their respective training pipelines by their original authors, but the degree of tuning effort is unknown and likely varies. VLA-0 may benefit from careful hyperparameter tuning that the baselines didn't receive, or the baselines may have been tuned for different trade-offs.

• No temporal ensembling in the baselines (mostly). The paper highlights ensemble prediction as VLA-0's most impactful component (2.0-point ablation). The relevant question is: which baselines also use temporal ensembling? OpenVLA-OFT explicitly uses ACT-style ensembling; it achieves 91.9% (without pretraining) and 97.1% (with pretraining), placing it above and below VLA-0 respectively. π0 and SmolVLA generate action chunks but whether they ensemble overlapping predictions is unclear from the paper's descriptions. If many baselines do not ensemble, the comparison is not fair with respect to inference technique — VLA-0 might be winning because of ensembling, not because of text-based action representation. Since ensembling is architecture-agnostic, the baselines could adopt it and potentially close or reverse the gap. The paper does not ablate ensembling on the baselines, so we cannot disentangle the contribution of architecture from the contribution of inference procedure.

• The 1.4-point margin. The advantage over the strongest comparable baseline (π0.5-KI, 93.3% vs. 94.7%) is modest. Without error bars, confidence intervals, or statistical tests, it's impossible to know whether this difference is statistically reliable or within the noise of finite evaluation (500 episodes per suite = 50 per task; the aggregate average is across 4 tasks × 50 episodes = 200 episodes per suite, but the effective sample may be smaller due to task-level correlations). A 1.4-point advantage could disappear with a different random seed, slight hyperparameter variation, or minor differences in data preprocessing.

Conditional summary: The claim holds for Qwen-VL-2.5-3B on LIBERO, but generalization to other VLMs and benchmarks is asserted without evidence. The contribution of ensembling vs. architecture is not disentangled, so the claim that architecture simplicity drives performance (rather than inference technique) remains partially supported.

Claim 2: "VLA-0 outperforms methods trained on large-scale robotic data"

Table I supports this with strong specific comparisons but the framing requires scrutiny.

What is demonstrated: VLA-0 (94.7%, no large-scale pretraining) outperforms π0 (94.2%, with pretraining), GR00T-N1 (93.9%), π0.5-KI (94.3%), and several others. The existence of these comparisons is the paper's most surprising result.

What is not demonstrated (and matters):

• "Outperforms" does not mean "strictly better." The claimed superiority is 0.4–0.8 points over π0 and GR00T-N1 — margins that are almost certainly within statistical noise given the 500-episode evaluation (50 per task). Without confidence intervals, a more accurate statement would be "VLA-0 is competitive with or slightly ahead of these pretrained methods." The paper's language ("surprisingly... surpasses the performance") overstates the certainty of the ordering.

• Pretraining data scale is not controlled. "Large-scale action pretraining" is a binary category in Table I, but the actual amount and diversity of pretraining data varies enormously across methods. π0 was trained on a massive and diverse robot dataset; GR00T-N1 was trained on humanoid robot data; MolmoAct had a different pretraining corpus. Some methods' pretraining may be poorly matched to LIBERO's tasks and therefore less helpful. The fact that OpenVLA (76.5% with pretraining) performs so poorly while OpenVLA-OFT (97.1% with pretraining) leads the entire table suggests that how pretraining is leveraged matters at least as much as whether it occurs. VLA-0 may be beating methods whose pretraining was suboptimal for LIBERO, not methods whose pretraining was inherently disadvantageous.

• OpenVLA-OFT with pretraining outperforms VLA-0 by 2.4 points. The top of Table I is OpenVLA-OFT (large-scale pretraining) at 97.1% vs. VLA-0 at 94.7%. The paper acknowledges this but frames it as "trailing only OpenVLA-OFT... a custom VLA model" (Section IV-C). However, this 2.4-point gap is larger than VLA-0's 0.5-point advantage over π0. The existence of a method that combines architectural complexity with pretraining and achieves higher performance weakens the claim that architectural simplicity is universally preferable — it suggests that complexity plus pretraining might still have an edge, even if complexity alone (OpenVLA-OFT without pretraining, 91.9%) does not.

Conditional summary: VLA-0 achieves performance in the same tier as large-scale pretrained models despite lacking pretraining — this is genuinely impressive. But "outperforms" overstates a narrow, potentially noisy ordering, and the strongest pretrained method (OpenVLA-OFT) retains a lead, suggesting the ceiling for pretraining + complexity may be higher.

Claim 3: "These findings also translate to the real world"

The real-world experiments (Figure 4) provide encouraging but preliminary support.

What is demonstrated: VLA-0 achieves 60% average success vs. SmolVLA's 47.5% across four SO-100 tasks, with large margins on three tasks.

What is not demonstrated (and matters):

• Four tasks, unknown trial counts. The evaluation is tiny by robotics standards. Four tasks × some unknown number of trials per task is insufficient to establish reliable performance estimates. The paper states "varied initial conditions of the objects to test for robustness" but doesn't quantify the variation or the number of trials. The 12.5-point average gap could be dominated by a single task ("Push apple to block" accounts for 30 of the 50 total percentage-point gap across tasks) and might not replicate with different task sampling.

• Single robot platform, single baseline. All real-world experiments use the SO-100 robot and the LeRobot framework, with SmolVLA as the sole comparison. SmolVLA was chosen as a strong baseline, but the conclusion that the findings "translate to the real world" requires showing robustness across platforms, environments, and comparisons. A single platform × single baseline result is a proof-of-concept, not a robust demonstration of real-world transfer.

• No ensemble prediction in real-world experiments. Since ensembling contributed 2.0 points in simulation ablations, the real-world VLA-0 results are not using the same configuration that achieved state-of-the-art in simulation. The paper acknowledges this (Section IV-D) but doesn't discuss the implications — the real-world results may significantly understate VLA-0's potential, but they also don't validate that the full VLA-0 recipe (including ensembling) works on hardware.

• Inference speed: 4 Hz. This is slow for real-time robotic control, where policies often run at 10–30 Hz. The paper claims this can be improved with distillation or quantization but provides no evidence. If VLA-0 requires running at 4 Hz to achieve these success rates, its applicability to dynamic tasks requiring fast closed-loop control is limited. SmolVLA's inference speed is not reported, so the latency comparison is incomplete.

• Training data: 100 demonstrations per task. This is a modest amount of real-world data, and VLA-0's ability to learn from it is a positive finding. However, the comparison against SmolVLA (which had large-scale SO-100 pretraining) is confounded: SmolVLA may suffer from negative transfer if its pretraining distribution differs from the evaluation tasks, while VLA-0's from-scratch training avoids this issue. The 12.5-point advantage might reflect negative transfer in SmolVLA rather than inherent superiority of VLA-0's architecture.

Conditional summary: The real-world results are a promising existence proof but do not constitute robust validation. The evaluation is too small (4 tasks, 1 robot, 1 baseline) to support strong claims of real-world state-of-the-art performance. The absence of ensemble prediction and the low control frequency further limit the strength of the conclusion.

What would strengthen the paper

Several experiments that are missing would substantially increase confidence in the claims:

1. Multi-VLM validation. Demonstrating VLA-0 with at least one other VLM family (e.g., LLaVA-1.6, InternVL2, or PaliGemma) would test the claimed model-agnosticism. If performance transfers, the approach is genuinely general; if it fails, the method is specific to Qwen-VL-2.5's properties.

2. Second benchmark. Evaluating on a different simulation benchmark (e.g., CALVIN, RLBench, MetaWorld) would test whether the LIBERO results are benchmark-specific. Different benchmarks stress different capabilities (long-horizon, spatial precision, language grounding, etc.) and a method that works across them would have stronger claims to generality.

3. Statistical rigor. Reporting confidence intervals (e.g., via bootstrapping across episodes) and conducting significance tests between VLA-0 and close baselines (especially π0.5-KI at 93.3% and π0 at 94.2%) would clarify whether the observed differences are reliable or within sampling noise.

4. Ensembling ablation on baselines. Adding temporal ensembling to one or two open-weight baselines (e.g., OpenVLA) and reporting the improvement would disentangle the contribution of VLA-0's architecture from its inference technique. If OpenVLA+ensembling approaches VLA-0's performance, the key insight shifts from "architecture simplicity is sufficient" to "ensembling is what matters."

5. Real-world scaling. Testing VLA-0 on more than 4 tasks, more than 100 demonstrations, and more than one robot platform would establish whether the simulation-to-real transfer is robust or fragile. The current real-world results are too limited to support strong conclusions.

6. Latency-matched comparison. Comparing methods at equal control frequencies (e.g., all at 10 Hz, using model distillation if necessary) would address the concern that VLA-0's 4 Hz inference speed gives it an unfair advantage in accuracy at the cost of responsiveness that would matter in dynamic tasks.

7. Negative result: when does text-based action generation fail? The paper shows a single negative case (VLA-0 loses to SmolVLA on "Reorient block," 30% vs. 45%) but doesn't analyze why this task is harder for VLA-0. Understanding failure modes — does text representation struggle with orientation prediction? with precise rotations? with certain object geometries? — would make the results more informative and guide future work.

6. Limitations and Trade-offs

Single VLM Family and Single Benchmark — Generality Is Asserted but Not Demonstrated

The assumption or constraint. VLA-0 is evaluated exclusively with one VLM (Qwen-VL-2.5-3B) on one benchmark (LIBERO). The paper explicitly claims model-agnosticism in Section III-A: "our method is applicable to any other VLM." However, zero experiments support this claim — no other VLM family (LLaVA, InternVL, PaliGemma, GPT-4V) is tested, and no other simulation benchmark (RLBench, CALVIN, MetaWorld) is evaluated.

The consequence. A practitioner considering VLA-0 for their own setup cannot know whether the approach transfers to their VLM of choice. Different VLMs have meaningfully different properties that could break the text-based action approach: some may have weaker spatial reasoning from their ViT features, making precise numerical coordinate prediction unreliable; others may have tokenizers that handle digit sequences differently (e.g., grouping multi-digit numbers into single tokens, which would change the autoregressive dynamics that masked action augmentation is designed to fix); still others may have been pretrained on data distributions (e.g., primarily natural images with limited text) that provide weaker priors for robot control. If VLA-0's performance is specific to Qwen-VL-2.5-3B's architecture or pretraining data, practitioners using other VLMs would replicate the training recipe and get subpar results — wasting 32 hours of 8×A100 compute only to discover the approach doesn't generalize.

The single-benchmark limitation is equally consequential. LIBERO consists of tabletop manipulation tasks with objects on a flat surface, relatively simple dynamics, and well-defined success conditions evaluated over 50 episodes. A VLA that excels at LIBERO may struggle on benchmarks requiring: dexterous in-hand manipulation, mobile manipulation (navigation + interaction), tasks with continuous dynamics (pushing, sliding, throwing), contact-rich tasks (peg insertion, zipping), or tasks where the action space has different structure (e.g., joint velocities rather than delta poses). The paper provides no signal about which task properties VLA-0's text-based approach handles well versus poorly.

What evidence exists in the paper. The evidence for the limitation is precisely the absence of evidence: no multi-VLM experiments appear anywhere in the paper, and no results outside LIBERO are reported. The paper's only gesture at generality is the statement in Section III-A that "our method is applicable to any other VLM" — a claim backed by zero data. The real-world experiments (Figure 4, Section IV-D) add a second evaluation context (SO-100 robot, 4 pick-and-place tasks) but use the same Qwen-VL-2.5-3B model and do not constitute a second benchmark — they test the same architecture in a different domain, not different architectures in the same domain.

Mitigation status. The paper does not acknowledge this as a limitation. Section V (Conclusions and Limitations) frames future work as "how VLA-0 would perform when trained with large-scale action data" and "improve inference speed... using optimization techniques like quantization and distillation" — both valid directions, but neither addresses the single-model, single-benchmark scope. The limitation goes unrecognized in the paper's own limitations section. A reader unfamiliar with the VLA literature would reasonably conclude from the title ("Building State-of-the-Art VLAs") and abstract that the approach is broadly validated, when in fact the evidence is confined to one model on one benchmark.

The practical consequence for deployment decisions is significant: without evidence of transfer, choosing VLA-0 over architecturally complex alternatives is a bet on generality that the paper has not placed.

Difficulty Estimation Cost Is Avoided, Not Solved

The assumption or constraint. VLA-0's training recipe — masked action augmentation and ensemble prediction — improves performance substantially over naive text-based action generation, but requires no special difficulty estimation because it makes no adaptive per-prompt decisions. This is both a strength (simplicity) and a hidden limitation: the model applies the same generation strategy to every timestep and every task, with no mechanism to allocate additional compute to harder states or failure-prone trajectory segments. The paper implicitly assumes that uniform compute allocation across all states is sufficient for LIBERO-level performance.

The consequence. In deployment scenarios where the difficulty distribution is non-uniform — some states require more precision, some tasks have higher stakes, some initial conditions are out-of-distribution — VLA-0 has no mechanism to spend extra inference compute where it would help most. A state where the robot is near a fragile object and needs millimeter-level precision receives the same 4 Hz, single-forward-pass treatment as a state where the robot is in open space with large tolerances. If VLA-0 fails on a particular task (e.g., 30% on "Reorient block" in real-world experiments, Figure 4), the system has no recourse — no way to try multiple samples, no way to refine actions iteratively, no way to flag low-confidence predictions for human intervention. The architecture's simplicity becomes a liability when it encounters states it handles poorly.

This is not a hypothetical concern. The paper's ablation (Table II) shows that without ensemble prediction — which is essentially a form of cheap temporal ensembling, not a dynamic allocation strategy — performance drops by 2.0 points. This suggests that some form of compute amplification (averaging multiple predictions) is critical, but VLA-0 only applies it uniformly in time rather than adaptively in difficulty. The 12.5-point real-world gap between VLA-0 and SmolVLA on "Reorient block" (Figure 4) is a concrete example where uniform allocation fails — the system consistently underperforms on a specific task, and the architecture provides no mechanism to recognize or address this at inference time.

What evidence exists in the paper. The ablation on ensemble prediction (Table II, Row 1 vs. Row 0) implicitly demonstrates that temporal smoothing is critical, but the paper never tests whether adaptive allocation (e.g., more ensembling steps on states with high prediction variance, more samples on tasks where the model is uncertain) would provide additional gains. The real-world results (Figure 4) show significant per-task variance — from 30% to 85% — confirming that difficulty is non-uniform, but the paper does not analyze whether this variance correlates with any measurable property (e.g., action string entropy, visual complexity, distance to training distribution) that could be used for adaptive allocation.

Mitigation status. The paper does not discuss dynamic or adaptive compute allocation. The limitation is structural — VLA-0's design philosophy ("zero modification") explicitly avoids adding mechanisms for test-time adaptation beyond the fixed ensemble prediction and single-pass generation. Section V (Conclusions and Limitations) does not mention this as a limitation or future direction. A practitioner who needs robust performance across varied difficulty levels would need to augment VLA-0 with an external difficulty estimation and allocation mechanism — something the paper provides no guidance for.

The deeper issue is that VLA-0's headline 94.7% on LIBERO represents average performance across a fixed test distribution. In deployment, where the cost of a single failure might be high (e.g., dropping an expensive object, colliding with a human), average performance is insufficient — what matters is worst-case performance and the ability to detect and recover from edge cases. VLA-0 provides neither.

Inference Latency vs. Accuracy: The Ensemble Prediction Trade-off

The assumption or constraint. The paper's strongest single component — ensemble prediction, contributing 2.0 points in ablations (Table II, Row 1) — comes with a fundamental latency cost that the paper acknowledges but does not resolve. At inference time, ensembling requires maintaining a buffer of the last n overlapping action chunk predictions and averaging them for the current timestep. The paper states in Section IV-D: "For simplicity, we do not ensemble actions in real, although it is possible to do so but requires 8 simultaneous running instances of the model." This reveals the core trade-off: to achieve the 2.0-point accuracy gain from ensembling, you must either (a) run multiple model instances in parallel (increasing GPU memory and hardware requirements proportionally) or (b) run the model sequentially for each overlapping prediction (dividing the effective control frequency by n). Neither option is free.

The consequence. A practitioner deploying VLA-0 faces an unpleasant choice: accept the accuracy of the non-ensembled model (92.0% in simulation, unknown but likely lower in real-world, and 60% average in the paper's real-world experiments which were conducted without ensembling) or pay a substantial hardware/latency cost to recover the 2.0-point improvement. The paper's real-world experiments achieve only 4 Hz on a desktop 5090 GPU without ensembling (Section IV-D). If ensembling requires 8 parallel instances, the GPU memory requirement scales 8× — a desktop 5090 (24 GB VRAM) running a 3B-parameter model might not have enough memory for 8 copies, forcing the practitioner to either use multiple GPUs or reduce the model size. If ensembling is done sequentially, the control frequency drops to 4/8 = 0.5 Hz, which is far too slow for real-time manipulation (most robot controllers run at 10–30 Hz).

The paper's real-world results therefore represent a different, lower-performing configuration than the one that achieved state-of-the-art in simulation. The 60% real-world average (Figure 4) is from the non-ensembled VLA-0. We do not know what the ensembled version would achieve in the real world — it could be higher (matching the simulation trend) but cannot be deployed with the same 4 Hz frequency on the same hardware. The comparison against SmolVLA is also confounded: we don't know whether SmolVLA uses ensemble prediction, so the 12.5-point advantage may reflect differences in inference technique rather than architecture.

What evidence exists in the paper. The paper provides evidence for both the importance of ensembling (Table II, Row 1: 2.0-point drop when disabled) and the practical difficulty of deploying it (Section IV-D: "requires 8 simultaneous running instances of the model"). The inference speed of 4 Hz is reported only for the non-ensembled configuration. The paper does not report: (a) the inference speed with ensembling (sequential or parallel), (b) the GPU memory required for 8 parallel instances of Qwen-VL-2.5-3B, (c) whether a smaller model or distillation could recover the ensembling benefit at lower cost, or (d) whether SmolVLA uses ensemble prediction in the real-world comparison.

Mitigation status. The paper suggests future work on "improve inference speed of VLA-0 using optimization techniques like quantization and distillation" (Section V), which could partially address the latency issue — a distilled 1B-parameter model might run fast enough to permit sequential or parallel ensembling within a 10 Hz budget. But this is entirely speculative: no distillation or quantization experiments are reported, and the latency-accuracy trade-off curve is not characterized at any point on the spectrum (e.g., what accuracy does VLA-0 achieve at 2 Hz? 8 Hz? with 4 parallel instances instead of 8?). A practitioner cannot make an informed hardware/latency/accuracy decision based on the paper's data.

The trade-off is fundamental to VLA-0's design — ensemble prediction is the largest single contributor to performance, but it scales poorly with latency constraints. The paper presents the 94.7% LIBERO number as the headline result without prominently noting that this configuration may be impractical for real-time deployment without additional hardware or optimization work that the paper does not provide.

The Hardest Manipulation Tasks Show Significant Weakness — and We Don't Know Why

The assumption or constraint. VLA-0 achieves strong average performance across LIBERO (94.7%) and across real-world tasks (60.0%), but performance on difficult tasks is substantially lower and uneven. On the LIBERO Long suite (long-horizon tasks), VLA-0 achieves 87.6% — the lowest of the four suites by a large margin (Spatial: 97.0%, Object: 97.8%, Goal: 96.2%). In real-world experiments, VLA-0 achieves only 30% on "Reorient block" (Figure 4), compared to 85% on "Place banana on plate" — a 55-percentage-point gap between tasks. This pattern — strong performance on simpler, shorter-horizon tasks with large objects, weak performance on tasks requiring precise orientation changes — is observed but never analyzed.

The consequence. Without understanding why VLA-0 fails on these harder tasks, a practitioner cannot predict whether their target application will work. Is the failure specific to orientation prediction (the "Reorient block" task requires rotating an object, which may be poorly represented by Euler angles in the text string)? Is it a compounding error problem on long-horizon tasks (small action prediction errors accumulating over many timesteps)? Is it a visual grounding failure (the model can't perceive object orientation precisely enough from the camera views)? Or is it a training data issue (100 demonstrations insufficient for certain task types)? Each of these failure modes would suggest a different mitigation — better action representation, temporal consistency losses, improved camera setups, or more data — but the paper provides no diagnostic information.

The Long suite result (87.6%) is particularly concerning because long-horizon manipulation is exactly where VLAs are supposed to excel — their language understanding and visual reasoning should help maintain goal-directed behavior over extended sequences. The fact that VLA-0's largest relative weakness is on the suite designed to test long-horizon reasoning suggests either that text-based action representation has specific difficulty with extended sequences (perhaps due to error accumulation in the autoregressive generation of long action strings) or that Qwen-VL-2.5-3B's pretraining provides less benefit for long-horizon tasks than for shorter ones. Neither hypothesis is tested.

What evidence exists in the paper. The per-suite breakdown in Table I provides the raw performance numbers showing the Long suite gap (87.6% vs. 96.2%+ on other suites). The real-world per-task breakdown in Figure 4 shows the "Reorient block" failure (30% vs. 60–85% on other tasks). The paper does not: (a) analyze which specific Long suite tasks VLA-0 fails on, (b) provide per-task LIBERO breakdowns that would reveal failure patterns, (c) examine whether action prediction error increases with chunk position (which would indicate error accumulation), (d) compare failure modes between VLA-0 and baselines on the same hard tasks, or (e) test whether increased training data or resolution improves performance on the hard tasks specifically.

Mitigation status. The paper does not acknowledge this as a limitation or analyze the failure cases. Section V (Conclusions and Limitations) focuses on scaling to larger training data and improving inference speed, not on understanding or addressing the performance gap on harder tasks. The "Reorient block" real-world result — where SmolVLA outperforms VLA-0 — is the paper's clearest counterexample to its own claims, and it receives no analysis beyond appearing in Figure 4. A practitioner considering VLA-0 for a task involving precise orientation control or long-horizon planning has no data to assess whether the approach will work, and no guidance on what to change if it doesn't.

The gap between easy-task and hard-task performance suggests that VLA-0's state-of-the-art average is driven by very strong performance on easy and medium tasks, with a meaningful deficit on the hardest cases. If a practitioner's application skews toward harder manipulation (dexterous, long-horizon, orientation-sensitive), the 94.7% headline average may be misleadingly optimistic — their effective performance could be closer to the 87.6% Long suite number or the 30% "Reorient block" result.

The 38% Correct-to-Incorrect Reversion Problem Does Not Apply — but an Analogous Problem Goes Uninvestigated

The assumption or constraint. VLA-0 does not use iterative revision (unlike the revision models in the reference paper), so the specific "38% of correct answers get converted back to incorrect ones" limitation is not directly applicable. However, VLA-0 has a structurally analogous problem: the model autoregressively generates a sequence of H × D action integers (where H is the chunk size and D is the action dimensionality), and errors in early digits of the sequence can cascade into incorrect predictions for later digits. This is the autoregressive generation analogue of the revision model's correct-to-incorrect reversion problem — the model "corrupts" its own output by conditioning subsequent predictions on its own potentially erroneous previous predictions.

The consequence. For an action chunk of length H × D (e.g., with H = 8 timesteps and D = 7 dimensions, this is 56 integers, each potentially 1–4 digits), an early digit error — predicting "127" instead of "128" for the first dimension of the first timestep — conditions all subsequent digit predictions on incorrect context. The model generates the remaining 55+ integers while "believing" (via its autoregressive context) that the first action dimension is 127, which may lead it to compensate in later dimensions, producing a coherent but incorrect action trajectory. This is the exact shortcut learning dynamic that masked action augmentation was designed to prevent — but the augmentation only operates during training, not at inference time. At inference, the model generates the full action string without masking, meaning any error in the autoregressive chain can propagate unchecked.

The paper does not measure this error propagation effect. We don't know: (a) whether errors are uniformly distributed across positions in the action string or clustered at later positions (which would indicate cascading), (b) whether the ensemble prediction's temporal averaging mitigates this by providing correction from overlapping predictions, (c) whether the 1.2-point benefit of masked action augmentation (Table II, Row 2) reflects training-time learning that partially carries over to more robust inference-time generation, or (d) whether certain action dimensions (e.g., gripper open/close, which is often binary or low-precision) are more susceptible to cascading errors than others.

What evidence exists in the paper. Indirect evidence comes from the ablation hierarchy: ensemble prediction provides a 2.0-point benefit, which could be partly due to its ability to average out cascaded autoregressive errors (since different chunks were generated with different preceding context, their errors may be decorrelated). The masked action augmentation provides a 1.2-point benefit, which could reflect the model learning to rely less on sequential context and more on visual grounding — reducing but not eliminating the cascading error problem. However, the paper provides no direct measurement of error propagation: no per-position accuracy analysis, no comparison of early-action vs. late-action prediction quality within a chunk, no ablation where the model is given ground-truth preceding actions (teacher forcing at inference) to measure the upper bound if cascading errors were eliminated.

Mitigation status. The paper does not discuss autoregressive error cascading as a limitation. The ensemble prediction mechanism provides partial mitigation — if an error occurs in one chunk prediction, the overlapping predictions from other timesteps may not share that error, and averaging reduces its impact. But this is an indirect fix, not a solution to the underlying problem. Masked action augmentation during training is a more direct intervention, but it only changes the model's learned behavior, not the inference-time autoregressive dynamic. A more principled approach — such as non-autoregressive decoding of action dimensions, iterative refinement of the action string, or inference-time masking of uncertain digits — is not explored.

A practitioner deploying VLA-0 should be aware that action errors may be correlated across timesteps within a chunk: if the robot's predicted first action is slightly off, the model may generate a sequence of subsequent actions that form a coherent but incorrect trajectory, and the temporal ensemble may not fully correct this if the error is correlated across overlapping predictions (e.g., if the visual observation at time t is ambiguous, all chunks that include predictions for time t may share a bias). This is a subtle failure mode that is not captured by the paper's aggregate success rate metric but could manifest in deployment as trajectories that look plausible but systematically miss the target.

No Open-Loop vs. Closed-Loop Analysis — We Don't Know What the VLM Is Actually Using

The assumption or constraint. VLA-0 operates as a closed-loop policy: at each timestep, it receives new camera images and produces a new action chunk. However, the paper provides zero analysis of what information the model is actually using to generate its actions — specifically, whether it relies primarily on the visual observation, the task instruction, the system prompt, the action history (from ensemble buffering), or some combination. The paper assumes the model is visually grounded (indeed, masked action augmentation is designed to enforce this), but never verifies that this is actually the case.

The consequence. Without understanding what drives the model's predictions, a practitioner cannot diagnose failures. If VLA-0 succeeds on a task, is it because it is visually tracking the object, or because it has memorized a trajectory that works for the specific initial conditions in the training demonstrations? If it fails, is the failure due to poor visual perception (the ViT can't see the object clearly), poor language grounding (the model misunderstands the instruction), or poor action generation (the model knows what to do but can't translate it into precise motor commands)? The paper's aggregate success rate metric conflates all of these potential failure modes into a single number, providing no diagnostic signal.

This matters acutely for deployment. A model that has memorized trajectories will fail catastrophically under distribution shift (different initial object positions, different lighting, different background). A model that is genuinely visually grounded will be more robust but might still fail if the camera view is occluded or the object is visually ambiguous. A model that relies heavily on the system prompt's format specification might fail if the prompt is slightly reworded. Without knowing which regime VLA-0 operates in, a practitioner deploying it in a new environment is flying blind — they don't know whether to invest in better cameras, more diverse training data, or prompt engineering.

What evidence exists in the paper. The paper provides only indirect evidence. The masked action augmentation ablation (Table II, Row 2) suggests that removing the technique that enforces visual grounding costs 1.2 points — implying that the model does learn some visual grounding, because degrading it hurts performance. The image tiling ablation (Table II, Rows 0 vs. 5) shows that the choice of how images are presented to the model has negligible impact (0.2 points), which could mean either that visual information is equally accessible in both formats, or that visual information is not the bottleneck for performance. The paper does not conduct the experiments that would disambiguate these interpretations: no perturbation studies (e.g., occluding parts of the image, shifting object positions, changing backgrounds), no attention map analysis (showing which image regions the model attends to when generating specific action dimensions), no comparison of action predictions when the instruction is changed while the visual scene is held constant (or vice versa).

Mitigation status. The paper does not acknowledge this as a limitation. The lack of behavioral analysis is common in VLA papers — aggregate success rate is the standard metric — but for a paper whose central claim is that VLMs already possess the necessary visual reasoning capabilities (they just need the right output format), demonstrating that visual reasoning is actually driving the performance is essential. The paper's title ("Building State-of-the-Art VLAs with Zero Modification") and framing (Section IV-C: "This result is highly surprising and runs counter to the expectations set by existing literature") imply that VLM pretraining is the key enabler, but the paper never isolates how much of VLA-0's performance comes from pretrained visual representations versus from the fine-tuning data itself.

A simple experiment — comparing VLA-0 against the same architecture trained from scratch (random initialization) on the same LIBERO data — would quantify the contribution of VLM pretraining. If from-scratch training achieves, say, 80%, then pretraining contributes ~15 points and fine-tuning contributes ~80 points. If from-scratch achieves 10%, pretraining is doing nearly all the work. The paper reports no such experiment, leaving the central motivating claim — that VLMs are already near-complete VLAs — without direct empirical support.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper fundamentally reframes the Vision-Language-Action model design space by demonstrating that the dominant approach of the past several years — adding architectural complexity to VLMs in the form of modified vocabularies, specialized action heads, and custom tokenization schemes — was solving a problem that doesn't exist, at least for the manipulation tasks represented in LIBERO. This is not an incremental improvement but a diagnostic null result of significant magnitude: VLA-0, with literally zero parameters added beyond the base Qwen-VL-2.5-3B, achieves 94.7% average success on LIBERO, outperforming architecturally complex methods like π0.5-KI (93.3%), SmolVLA (88.8%), and π0-FAST (71.8%) — all of which introduced substantial modifications to their base VLMs. The fact that this zero-modification approach also beats π0 (94.2%), a model with extensive large-scale action pretraining and a sophisticated flow-matching action decoder, despite having no action pretraining of its own, makes the diagnostic result sharper: whatever π0 gained from its architectural investment and pretraining data, VLA-0 matched or exceeded with a standard VLM, a text-based action format, and the right training recipe.

The central conceptual shift is from "how should we modify VLMs to handle actions?" to "what training and inference recipe unlocks the action-generation capability that VLMs already possess?" Prior work implicitly assumed that VLMs needed architectural modification to serve as robot policies — that their native text generation, while sufficient for answering questions about images, was inadequate for producing precise motor commands. VLA-0's results suggest this assumption was wrong. The VLM's output space is not the bottleneck; what matters is how you ask the model to produce actions (as text strings of integers, not as dedicated action tokens or latent vectors) and how you prevent the model from taking shortcuts during training (masked action augmentation) and smooth out temporal noise during inference (ensemble prediction). This reframing echoes a pattern seen in other areas of deep learning — ConvNeXt showing that modern training recipes make standard ConvNets competitive with Vision Transformers, for instance — where the recipe, not the architecture, was the limiting factor all along.

The paper also reconciles a latent contradiction in the VLA literature. The existence of three distinct VLA families (Discrete Token, Generative Action Head, Custom Architecture) with different strengths and weaknesses created the impression that the field was exploring a complex design space where trade-offs were necessary — you could have action precision (Generative Action Head) or language preservation (Discrete Token) or high performance (Custom Architecture), but not all three. VLA-0 shows that this trade-off space was, at least partially, an artifact of suboptimal training recipes. With the right recipe, a simple text-based approach achieves high action precision (resolution 1000, sufficient for LIBERO's precision requirements per Table II), preserves language understanding (no vocabulary modification), and achieves state-of-the-art performance (94.7%) — the trilemma collapses. The field's prior negative results with simple approaches (implicitly, the reason text-based VLAs were "largely unexplored") were likely caused by shortcut learning in autoregressive action generation and temporal inconsistency — both solvable with the techniques VLA-0 introduces.

Specific research directions that become more attractive after this work:

• Training recipe optimization for VLAs rather than architectural innovation. The paper's ablation (Table II) shows that recipe components contribute up to 2.0 points individually, while the gap between VLA-0 and the most architecturally complex baselines is often smaller than this. Future work on VLA performance should prioritize recipe improvements (better augmentation strategies, improved temporal integration, learning rate schedules, data mixing) over architecture design.
• Leveraging VLM progress directly for robotics. Since VLA-0 works with zero architectural modification, every improvement in VLM capabilities — better vision encoders, larger language models, improved multimodal pretraining data — should translate directly to better VLAs without any VLA-specific redesign. A VLA-0 built on Qwen-VL-3 (if and when released) or a larger LLaVA or InternVL model should automatically benefit from those models' improved spatial reasoning and instruction following.
• Understanding VLM representations for motor control. VLA-0's strong performance implies that VLMs already represent spatial and geometric information with sufficient precision for manipulation tasks. Investigating how this information is encoded — which layers, which attention heads, which token positions — could inform better VLA training strategies and reveal whether certain VLM architectures are inherently better suited for robot control.

Research directions that become less attractive:

• Incremental architectural modifications to VLA action heads. If a text-based approach with no action head matches or outperforms flow-matching decoders and diffusion policies, the marginal value of improving action head architecture is called into question. Research effort may be better spent on recipe improvements that benefit any architecture.
• Custom action tokenization schemes. The paper's finding that a simple integer-to-text mapping with resolution 1000 is sufficient (and that 4000 provides no additional benefit per Table II) suggests that sophisticated tokenization methods like Discrete Cosine Transform (π-FAST) or learned action vocabularies may be over-engineered for the precision requirements of current manipulation benchmarks. The burden of proof now shifts to these methods to demonstrate that their complexity provides benefits beyond what a well-tuned text-based approach achieves.

Follow-Up Research This Work Enables

Cross-VLM validation: testing the claimed model-agnosticism. The paper's central claim of VLM-agnosticism — "our method is applicable to any other VLM" (Section III-A) — is entirely untested. A direct follow-up would replicate Table I using at least two other VLM families at comparable parameter scales: for example, LLaVA-1.6-3B and InternVL2-2B. The key question is whether VLA-0's 94.7% transfers, or whether Qwen-VL-2.5-3B has specific properties — its ViT architecture, its pretraining data distribution, its tokenizer's handling of digit sequences — that make text-based action generation work unusually well. A negative result (e.g., LLaVA-1.6-3B achieving only 80% with the same recipe) would reveal that the approach is model-specific and that VLM selection matters more than the paper implies. A positive result (both models achieving 93%+) would validate the claimed generality and make VLA-0 the default starting point for any new VLM's robotics application.

Benchmark diversification: testing beyond LIBERO's tabletop manipulation. All simulation results are on LIBERO, which consists of tabletop pick-and-place and articulation tasks with relatively simple dynamics. A critical stress-test would evaluate VLA-0 on benchmarks that exercise different capability dimensions: (a) CALVIN for long-horizon task chaining with language instructions — does text-based action generation suffer from compounding errors over very long sequences (hundreds of timesteps)? (b) RLBench for contact-rich manipulation (peg insertion, drawer opening, button pressing) — does the 0.1% action resolution (resolution 1000) suffice for tasks requiring sub-millimeter precision? (c) ManiSkill for tasks with continuous dynamics (pushing, sliding) — does the 4 Hz control frequency become a bottleneck when objects are moving? This diversification would map the boundary conditions of text-based action generation: which task properties cause it to fail, and which are handled robustly. The LIBERO Long suite result (87.6%, the lowest of the four suites) and the real-world "Reorient block" failure (30% vs. SmolVLA's 45%) already hint at weak points — long horizons and orientation changes — that a multi-benchmark study would systematically characterize.

Ensembling-to-architecture contribution disentanglement. The paper's ablation shows ensemble prediction contributes 2.0 points (Table II, Row 1 vs. Row 0), the largest single-factor effect. But this technique is orthogonal to architecture — any VLA could ensemble its predictions. A crucial follow-up would add temporal ensembling to open-weight baselines (OpenVLA, SmolVLA) and measure the improvement. If OpenVLA+ensembling jumps from 76.5% to, say, 88%, then the gap between VLA-0 and Discrete Token VLAs is substantially reduced and the remaining difference can be attributed to architecture + recipe rather than inference procedure. If the improvement is small (2–3 points), then VLA-0's architecture is genuinely superior beyond ensembling. This experiment would reveal the true contribution of VLA-0's text-based representation net of the ensembling advantage, and would clarify whether the field's prior negative results with simple approaches were due to architecture or to the absence of temporal smoothing.

Dynamic compute allocation: extending VLA-0 with difficulty-aware ensembling. VLA-0 applies ensemble prediction uniformly at every timestep, but the paper's results show substantial per-task variance — from 30% to 85% in real-world (Figure 4) and a 10-point gap between the Long suite (87.6%) and other LIBERO suites (Table I). A natural extension would add adaptive compute: estimate prediction uncertainty at each timestep (e.g., from the variance of the n overlapping predictions in the ensemble buffer) and allocate additional compute — more ensemble steps, multiple sampled action strings with majority voting, or iterative refinement of the generated action text — when uncertainty is high. The question is whether this recovers performance on the hardest tasks (Long suite, "Reorient block") without increasing average compute proportionally. This would require a metric for action prediction uncertainty (e.g., variance of the ensemble predictions, entropy of the generated token distribution) that correlates with task failure — a correlation the paper does not establish but that could be measured from the existing LIBERO rollout data.

Open-loop vs. closed-loop behavioral analysis. The paper provides no analysis of what information VLA-0 actually uses to generate actions — whether it is visually grounded in the current observation, relying on memorized trajectories, or auto-completing from the action history. A diagnostic study would conduct perturbation experiments: (a) occlude portions of the input image (e.g., mask the object being manipulated, the robot end-effector, or the target location) and measure the impact on action predictions per dimension — if occluding the object causes large errors in position dimensions but not orientation, the model is visually tracking object position but not orientation, which would explain the "Reorient block" failure; (b) shift object positions systematically and measure whether predicted actions adapt accordingly (indicating closed-loop visual servoing) or continue toward the original position (indicating memorized trajectory following); (c) scramble the task instruction while keeping the visual scene fixed, and compare action predictions — if predictions change, the model is using language; if they don't, visual information dominates. These analyses would transform VLA-0 from a black-box policy into a partially understood system and would directly inform which failure modes (visual perception, language grounding, action generation) are responsible for the performance gaps on hard tasks.

Scaling laws for VLM-to-VLA transfer. VLA-0's result that a 3B-parameter VLM fine-tuned on task-specific data matches or exceeds much larger, pretrained VLA-specific architectures raises a natural scaling question: does VLA-0 performance scale predictably with VLM size and capability? A follow-up would train VLA-0 with the same recipe on Qwen-VL-2.5 at multiple scales (0.5B, 1.5B, 3B, 7B, 14B) and on other VLM families with available size variants, measuring LIBERO performance as a function of parameter count and pretraining compute. If performance scales smoothly (e.g., a power law with model size), then VLA-0 provides a path to "VLAs for free" — each new VLM generation automatically yields a better VLA, and the benefit of VLA-specific architecture becomes asymptotic to the VLM scaling curve. If performance saturates or plateaus at 3B, then there are fundamental bottlenecks in VLM representations for motor control that larger models don't address, and architecture innovation may still be needed to break through the ceiling.

Practical Applications and Downstream Use Cases

Rapid VLA prototyping on new robot platforms. The most immediate practical application of VLA-0 is as a default starting point for any team deploying a VLM-based policy on a new robot. The paper demonstrates that with as few as 100 demonstrations per task (the real-world experiments, Section IV-D), 32 hours of training on 8 A100 GPUs, and no architectural engineering, VLA-0 achieves 60% average success across four manipulation tasks, outperforming SmolVLA (a model specifically pretrained on large-scale SO-100 data) by 12.5 points. For a lab or company setting up a new manipulation workcell, VLA-0 eliminates the need to (a) design or select a VLA-specific architecture, (b) acquire or generate large-scale action pretraining data, or (c) implement custom tokenization or action decoding pipelines. A practitioner can take an off-the-shelf VLM, collect a modest number of demonstrations, apply the VLA-0 recipe, and have a working policy within days. The training cost (32 GPU-hours on A100-class hardware) puts this within reach of academic labs and small companies.

Cost-efficient batch data generation for robot learning pipelines. The paper's finding that VLA-0 achieves state-of-the-art performance without architectural complexity has direct implications for generating robot training data at scale. When using VLAs to produce demonstration-quality action trajectories (for distillation into faster policies, for self-improvement loops, or for simulation-to-real transfer), the primary cost is inference compute × number of trajectories. VLA-0's zero-modification design means it can leverage all standard VLM inference optimizations — quantization, distillation, speculative decoding, KV-cache sharing — without architectural rework. A distilled 1B-parameter VLA-0 running at 10+ Hz (the paper's 3B model achieves 4 Hz on a 5090 GPU without optimization; Section IV-D suggests distillation and quantization as paths to higher speed) could generate training trajectories at a fraction of the cost of running a π0-style model with its flow-matching action decoder. For a team generating 10,000 demonstration trajectories, even a 2× inference speedup translates to substantial cost savings.

Deployment on compute-constrained edge hardware. A 3B-parameter VLM is small by current standards (compared to 7B, 13B, or 70B alternatives), and VLA-0's lack of architectural overhead means the entire model fits within the memory budget of a single consumer GPU (the paper uses a desktop 5090 for real-world inference). For applications requiring on-robot deployment — where cloud connectivity is unreliable, latency must be minimal, or data privacy prevents off-device processing — VLA-0 provides a path to running a state-of-the-art VLA on edge hardware that cannot support larger models or complex multi-component architectures. A practitioner with a Jetson Orin or comparable edge device could potentially run a quantized 3B VLA-0 at control-relevant frequencies (10–20 Hz) after applying the distillation and quantization optimizations the paper flags as future work, enabling generalist manipulation capabilities on platforms that would otherwise be limited to narrow task-specific policies.

Bridging VLM research and robotics with minimal friction. VLA-0's key architectural property — zero modification — means that robotics researchers can treat VLMs as interchangeable backbones and test new VLM releases as drop-in replacements without any VLA-specific engineering. When a new VLM is released (e.g., a new version of Qwen-VL, LLaVA, or InternVL), a team can fine-tune it with the VLA-0 recipe on their existing robot dataset and immediately assess whether the VLM improvements (better vision, better reasoning, better instruction following) translate to better robot policies. This dramatically reduces the barrier between VLM research and robotics: previously, adopting a new VLM backbone required retooling the action head, retraining the tokenizer, or redesigning the decoding pipeline. With VLA-0, it requires changing one model checkpoint and rerunning fine-tuning. This accelerates the feedback loop between VLM capability improvements and real-world robot performance, potentially surfacing insights about which VLM properties matter for robotics that are invisible in standard VLM benchmarks.