VLA-0: Can Integer Action Decoding Simplify Robot Manipulation?. VLA-0: Building State-of-the-Art VLAs with Zero Modification • Ankit Goyal, Hugo Hadfield, Xuning Yang, Valts Blukis, Fabio Ramos • NVIDIA • arXiv • 2025. Cold Open. Your robot sees a cupcake and a bowl. The instruction is straightforward: put one inside the other. Now comes the architectural decision. Do you attach a flow-matching expert to your vision-language model? Reserve vocabulary entries for action tokens? Build another network to translate visual features into motion?. VLA-0 takes a different route: teach the model to answer with ordinary integers, then translate those integers back into robot commands. The vocabulary and network architecture stay intact. The authors demonstrate this approach in simulated manipulation and on an SO-100 arm. Picture the debugging session. The output you inspect is a numerical string. An answer field that could contain an image description instead contains a sequence of movements. That creates an appealing engineering question. How much specialized machinery do we need between a pretrained vision-language model and a robot? What happens if we invest our effort in training the simplest output interface properly?. That is the experiment at the center of this episode. The Idea. NVIDIA starts with Qwen2.5-VL-3B. “Zero modification” describes the architecture: the authors fully fine-tune the model on robot demonstrations using a standard next-token prediction objective. General vision-language pretraining supplies the starting weights; demonstrations supply the control supervision. There is no intervening large-scale robot-action pretraining stage. The input follows the familiar multimodal conversation format: camera images, a task instruction, and a system prompt specifying the action dimensions and prediction horizon. The output is a space-separated numerical sequence, ordered by timestep and action dimension. To construct it, the implementation normalizes continuous actions using dataset statistics, scales and rounds them into integers, and serializes them. After generation, the decoder reverses the process. The important representational choice is compositionality. Ordinary digits can spell many possible values. Increasing numerical resolution therefore changes the action encoding convention rather than requiring another dedicated vocabulary entry for every new bin. The tokenizer remains the tokenizer; the robot-specific meaning lives in the data transformation around it. This approach extends an established lineage. RT-2 already represented robot commands as textual sequences. Its PaLI-X version used existing integer tokens, while its PaLM-E version reassigned infrequently used tokens. That earlier work established a powerful connection: action learning could use the same sequence-prediction interface as language learning. VLA-0 revisits that connection with a modern, publicly available backbone and a focused training-and-execution recipe. The next ingredient is temporal structure. Instead of predicting only the immediate command, generate a short chunk of future actions. The relevant precedent is Action Chunking with Transformers, or ACT. Its temporal ensembling combines overlapping forecasts: a command for the current instant might have been predicted just now, one step earlier, or several steps earlier. Those forecasts all refer to the same execution time. Averaging them produces a smoother command without averaging together different phases of the task. You are reconciling several predictions of the grasp, not blending the grasp with the later lift. The released VLA-0 simulation evaluation makes a fresh prediction at every environment step and combines eight overlapping predictions. This is one policy forecasting across time, rather than an ensemble of separately trained networks. The final ingredient is masked action augmentation. During training, parts of the numerical action text are hidden from the autoregressive context. The intention is to strengthen dependence on the images and instruction, rather than letting later predictions rely too heavily on completing an already informative numerical prefix. Masking changes the training examples while leaving the model architecture intact. Together, these choices connect three different concerns: how to represent a command, how to learn it from demonstrations, and how to stabilize its execution. That combination is the interesting contribution. It turns an appealingly simple output format into a complete policy recipe. For practitioners, the conceptual shift is useful: start by treating robot control as supervised multimodal sequence prediction, then make the surrounding representation and execution choices explicit. The Result. The headline result is 94.7% average success on LIBERO. In the authors’ October 2025 comparison, VLA-0 has the highest average among the listed models without large-scale robot-action pretraining. That group includes corresponding versions of π0.5-KI, OpenVLA-OFT, and SmolVLA. LIBERO supplies language-described manipulation tasks and human teleoperation demonstrations. Its benchmark design separates knowledge about spatial relationships, objects, and goals, alongside more involved manipulation sequences. That gives researchers a shared environment in which to compare policies trained from demonstrations. VLA-0 evaluates forty tasks across the Spatial, Object, Goal, and Long suites, with fifty episodes per task. The reported metric is completed-task success during rollouts. That distinction matters. A model can produce plausible-looking numbers, or achieve a low prediction loss, without completing a manipulation sequence. Here, generated commands enter the environment, change what the cameras observe, and influence subsequent decisions. The headline measures the outcome of that entire loop. The result makes integer-text decoding worth taking seriously as a control interface. The physical experiments use an SO-100 arm and LeRobot, with a hundred demonstrations collected for each task. The tasks cover banana and cupcake pick-and-place, apple pushing, and block reorientation. These are separately trained real-world policies, alongside the simulation study. On those physical tasks, VLA-0 achieves 60% average success, ahead of SmolVLA in the authors’ comparison. The real-robot implementation executes without the temporal ensembling used for the headline simulation result. The ablations identify where the recipe earns its performance. Removing temporal ensembling produces the largest decline among the tested changes. Removing masked augmentation also lowers success. Adequate action resolution helps, while arranging camera images as a composite or as separate inputs produces similar outcomes. The practical lesson is about allocating attention. The useful decisions concern action precision, training context, and temporal execution. Those are substantial robotics decisions even when the neural-network diagram stays unchanged. For a researcher choosing a baseline, this changes the starting point. Native text decoding deserves a competitive training recipe of its own. The relevant comparison is between complete, carefully configured policies—not between a mature action-head system and a minimally fine-tuned numerical prompt. The Biggest Weakness. The biggest gap is evidence of generalization beyond the demonstrated tasks. Preserving a VLM’s vocabulary and architecture does not, by itself, establish that its pretrained understanding survives robot fine-tuning or governs its actions. The standard LIBERO evaluation used here stays close to the training tasks. LIBERO-PRO directly investigated this issue by perturbing object placement, task instructions, objects, and environments. Its experiments found that high-scoring policies could become brittle under relocation or continue following familiar behavior when the requested task changed. Those experiments examined other VLAs, not VLA-0. They establish a risk in interpreting the benchmark, not a measured failure of this particular method. The distinction is important: there is no basis for claiming that VLA-0 must exhibit the same behavior. The threat to the broader argument is straightforward. A model can become excellent at recognizing a familiar scene and reproducing its associated action sequence. That can generate strong task-success numbers without demonstrating flexible use of language or visual relationships. An unchanged tokenizer cannot distinguish those explanations. RT-2 approached semantic transfer through both its training mixture and evaluations involving unfamiliar objects, backgrounds, and environments. Its results reinforce that transferring vision-language knowledge is an empirical question about training and behavior. The decisive experiment for VLA-0 would freeze the trained checkpoint and action mapping, then systematically change object locations and valid instructions. Keep the physical skills familiar while changing which skill must be applied, to which object, and where. Measure whether the policy follows those changes rather than repeating the original trajectory. That would test the missing connection between architectural simplicity and flexible grounded control. The current evidence establishes strong performance on the evaluated tasks. The generalization advantage suggested by keeping the VLM intact remains an open question. Verdict. VLA-0 should interest researchers who already understand VLM fine-tuning and want a direct route into robot policy learning. It should also interest robotics teams evaluating whether their next architectural component is doing indispensable work. The strongest reason to adopt it as a baseline is experimental clarity. You can make the action representation explicit, inspect the serialized targets, and reason separately about prediction and execution. That gives a research team a concrete starting point for asking where an improvement actually enters the system. There is a usable release behind that recommendation. NVIDIA provides training and evaluation code, a downloadable LIBERO checkpoint, and configuration guidance for custom LeRobot datasets. The repository also documents deployment through direct integration or an inference service. The community extension VLA-0-Smol adds useful evidence that the design can travel. Its authors build on SmolVLM2-500M, integrate the policy into LeRobot, and report LIBERO performance close to the original model. Their variant masks whole action values rather than individual characters. They also find that temporal ensembling improves their LIBERO evaluation. This is a concrete extension of the design to another backbone and implementation. For a lab comparing pretrained models, that portability is the attractive research direction. Keep a common action interface and ask what changes when the visual-language backbone changes. For a lab studying imitation learning, use the same setup to investigate masking, action representations, or temporal aggregation. The broader payoff is a better allocation of engineering effort. A simple, competitive baseline gives every proposed addition a clear job: demonstrate what capability it contributes. It also makes useful negative results easier to recognize—sometimes the extra module was solving a problem that the existing model could already learn. The takeaway: treat integer-text action decoding as a serious default baseline, and make architectural complexity earn its place. Outro. Next, watch whether action-as-text recipes become a common way to evaluate new vision-language backbones on robot learning. That would make backbone comparisons easier to organize around a shared control interface. Return to the cupcake and the bowl. The physical objective is unchanged. What VLA-0 changes is the experiment you might run first: teach the existing model a precise numerical answer format, then evaluate the resulting policy as a complete system. This is Embodied AI 101. Before designing your next action head, give supervised integer decoding a serious baseline run.