Vision-Language-Action Models

A vision-language-action (VLA) model is a robot policy that takes camera images and a natural-language instruction and outputs robot actions, built by adapting a model pretrained on web-scale image and text data. Brohan et al. (2023b) introduced the term for RT-2, which fine-tuned large vision–language models to write robot actions as text tokens. Related names are in use: the Octo authors speak of generalist robot policies, a class that includes policies trained without web pretraining (Ghosh et al., 2024), and the π0 authors of robot foundation models (Black et al., 2025).

The embodied AI article places these models in the wider field and tabulates the main ones; visuomotor policy learning covers behaviour cloning, compounding error, action chunking and diffusion policies, which VLAs inherit. This article covers what is specific to VLAs: how continuous actions are represented in a model built for tokens, the RT-1, RT-2 and OpenVLA designs in detail, training across robots, how the models are fine-tuned and evaluated, and the limits their authors report. A small example measures the quantization error of action tokens.

Definition

A VLA is a policy $\pi_\theta(a_t \mid o_t, \ell)$, or $\pi_\theta(A_t \mid o_t, \ell)$ for a chunk of future actions $A_t$, where the observation $o_t$ contains one or more camera images (sometimes with the robot’s joint state), $\ell$ is a language instruction, and the parameters $\theta$ are initialized wholly or partly from a vision–language model. It is trained mainly by imitation on robot demonstrations, often from many robots, and is either used directly or fine-tuned for a new robot or task.

Two things distinguish a VLA from a visuomotor policy trained from scratch. Its backbone carries knowledge from internet data, which its authors use to explain generalization to new objects and instructions (Brohan et al., 2023b; Kim et al., 2024). And it needs an action representation compatible with that backbone: either actions written as discrete tokens in the language model’s vocabulary, or extra output weights that produce continuous actions.

Intuition

A vision–language model already maps an image and a question to a sequence of tokens. If “what action should the robot take to pick up the can?” is answered by a string such as 1 128 91 241 5 101 127 whose numbers index bins of each action dimension, robot control becomes another visual question-answering task, trained with the same next-token loss. The visual and semantic knowledge of the pretrained model then applies to the robot’s camera image: a model that has seen many images of strawberries and bowls can, its authors report, act on “put the strawberry into the correct bowl” although no robot demonstration contained that instruction (Brohan et al., 2023b).

The price of the token interface is that actions become categorical. A dimension split into 256 bins can only be commanded to one of 256 values, and each value is one token to generate. Most later design changes, such as quantile bounds, compressed tokenizers, regression heads and flow-matching experts, respond to that price.

Formal Definition

Uniform binning. RT-1 discretizes each action dimension into 256 bins “uniformly distributed within the bounds of each variable” (Brohan et al., 2023a). For a dimension with bounds $[l, u]$ and $B$ bins of width $w = (u - l)/B$, an action value $a$ is mapped to the index

$$k = \min\left(B - 1, \max\left(0, \left\lfloor \frac{a - l}{w} \right\rfloor\right)\right),$$

and decoded as the bin centre $\hat a = l + (k + \tfrac12) w$. The rounding error $|a - \hat a|$ is at most $w/2$ inside the bounds; if the values are spread evenly within each bin, its root-mean-square value is $w/\sqrt{12}$, the standard result for a uniform error on an interval of length $w$. That assumption is ours, and the example below checks it on its data.

Token likelihood. With $D$ action dimensions, the tokens $k_1, \dots, k_D$ are predicted with the cross-entropy loss. An autoregressive language model factorizes their probability as

$$p_\theta(k_1, \dots, k_D \mid o_t, \ell) = \prod_{d=1}^{D} p_\theta(k_d \mid k_{<d}, o_t, \ell),$$

which is how RT-2 and OpenVLA generate actions, one token after another (Brohan et al., 2023b; Kim et al., 2024). RT-1 predicts its action tokens without conditioning on earlier ones; an ablation with autoregressive actions was no better and more than twice as slow (Brohan et al., 2023a). Each dimension’s categorical distribution can put mass on several separated values, which RT-1’s authors give as the reason discretization handles multimodal demonstrations.

Regression. A continuous head outputs $\hat a = f_\theta(o_t, \ell)$ directly and is trained with a mean squared error or L1 loss. A unimodal loss of this kind fits the conditional mean or median of the demonstrated actions, so where demonstrations disagree it can average incompatible actions.

Flow matching. π0 models the distribution of an action chunk $A_t = [a_t, \dots, a_{t+H-1}]$ with $H = 50$. In training, the network $v_\theta$ is evaluated at a point between noise $\epsilon \sim \mathcal N(0, I)$ and the true chunk,

$$A_t^\tau = \tau A_t + (1 - \tau)\,\epsilon, \qquad L(\theta) = \mathbb{E}\, \big\lVert v_\theta(A_t^\tau, o_t) - (A_t - \epsilon) \big\rVert^2 ,$$

with the flow-matching time $\tau \in [0, 1]$ drawn from a beta distribution that emphasizes noisier values. At inference, a chunk is generated from noise by integrating the learned vector field from $\tau = 0$ to $\tau = 1$ with 10 forward Euler steps, $A_t^{\tau + \delta} = A_t^\tau + \delta\, v_\theta(A_t^\tau, o_t)$, $\delta = 0.1$ (Black et al., 2025). The diffusion model article covers the denoising family to which flow matching is related, and Octo uses a DDPM-style diffusion head in the same role (Ghosh et al., 2024).

Action Representations

Discretized action tokens

RT-1’s 11 action dimensions are seven for the arm (position, roll, pitch, yaw and gripper opening), three for the mobile base and a discrete mode that switches between controlling the arm, controlling the base and ending the episode; each continuous dimension gets 256 uniform bins (Brohan et al., 2023a). RT-2 keeps this discretization for the end-effector displacement, gripper extension and termination command, which gives eight integers per action, and it reserves 256 tokens of each vision–language model’s vocabulary for them. PaLI-X has a unique token for every integer up to 1,000, so bin $k$ is simply the token for the number $k$; PaLM-E has no such tokens, so the 256 least frequently used tokens are overwritten (Brohan et al., 2023b). The paper’s sample target string has seven numbers although the text specifies eight; the action strings in its chain-of-thought figure have eight. During decoding for robot tasks, RT-2 samples only from the valid action tokens.

OpenVLA uses 256 bins per dimension but sets each dimension’s interval between the 1st and 99th percentiles of the training actions rather than the minimum and maximum, so that rare outliers do not widen the bins, and it overwrites the last 256 tokens of the Llama tokenizer, which are its least used (Kim et al., 2024). The loss is the cross-entropy on the action tokens only. In the official code, the tokenizer places 256 equally spaced bin edges on the normalized range $[-1, 1]$ and decodes to the 255 midpoints between them, mapping the top index to the last midpoint, so in the code there are 255 reconstruction values per dimension (OpenVLA code, action_tokenizer.py).

The scheme tokenizes each dimension at each time step independently. FAST (Pertsch et al., 2025) shows two costs when actions are predicted in chunks at high control rates. A one-second chunk needs $H \times D$ tokens: 35 for 7-dimensional actions at 5 Hz, but 700 for a 14-dimensional bimanual robot at 50 Hz. And consecutive tokens become nearly predictable from the previous one: in the authors’ case study, a small autoregressive transformer predicting a cubic spline from four points worked at low sampling rates but, as the rate rose, its error increased steeply until it copied the first action, because the information each new token adds approaches zero. FAST instead normalizes each dimension by its 1st and 99th percentiles, applies the discrete cosine transform per dimension over the chunk, scales and rounds the coefficients (scale 10), interleaves the dimensions with low frequencies first, and compresses the integer sequence with byte-pair encoding (vocabulary 1,024). Its token counts for the two examples above were 20 and 53 at comparable reconstruction error, and in its evaluations policies trained with per-step binning made no progress on 20 Hz table bussing and 50 Hz T-shirt folding where FAST policies did.

Continuous heads

Several ablations compare discretized tokens with continuous outputs, with results that depend on the model and data:

• RT-1 replaced its bins by a Gaussian output trained with an MSE loss: seen-task success fell from 97% to 68% and unseen-task success from 76% to 43% (Brohan et al., 2023a, Table XIII). The authors attribute the drop to the Gaussian’s single mode.
• Octo compared heads on its WidowX evaluation (40 trials over four tasks): Octo-Small with its diffusion head reached 83%, MSE regression 35% and discretized actions 18% (Ghosh et al., 2024, Table II). The authors’ explanation is that diffusion models several modes, unlike the MSE head, while keeping the precision of continuous actions, unlike the discrete head.
• OpenVLA-OFT (Kim, Finn and Liang, 2025) fine-tuned OpenVLA on LIBERO with all actions of an 8-step chunk decoded in parallel in one forward pass. With these changes, 256-bin tokens averaged 90.2% success over the four suites, an MLP head trained with an L1 loss 95.3%, and a diffusion head 95.4% (their Table I, third-person image and instruction as inputs, training data filtered as in OpenVLA’s protocol); the authors attribute the gain of continuous actions to higher precision and note that L1 regression matched diffusion while training and running faster.

The ablations do not contradict each other so much as test different things: RT-1 and Octo pretrained on diverse multi-robot or multi-operator data, where multimodality matters, while OFT fine-tuned a 7B pretrained model on single benchmark suites. In our reading, the safe summary is that no representation was best in every reported setting.

Diffusion and flow-matching experts

Octo’s transformer produces readout embeddings, and a small diffusion head denoises a chunk of actions conditioned on them, so the transformer runs once per prediction and only the head runs once per denoising step (Ghosh et al., 2024). π0 adds to the PaliGemma vision–language model (3 billion parameters) a second set of transformer weights, the 300-million-parameter “action expert”, initialized from scratch, which processes the robot state and the noisy action tokens; image and text tokens use the original weights, and the action tokens attend to each other bidirectionally (Black et al., 2025). The authors describe the design as a mixture of experts with two elements. Because the image and language prefix does not depend on $\tau$, its attention keys and values are cached and only the action part is recomputed at each of the 10 integration steps.

RT-1

RT-1, the Robotics Transformer (Brohan et al., 2023a), is the policy whose action format the later VLAs adopted, although it is not built on a vision–language model. A history of six 300 × 300 images passes through an ImageNet-pretrained EfficientNet-B3; the instruction, embedded with the Universal Sentence Encoder, conditions the image encoder through FiLM layers; the layers that produce the FiLM scale and shift are initialized to zero, so that FiLM starts as the identity and the pretrained network is initially unchanged. Each image yields a 9 × 9 feature map, flattened to 81 tokens, which TokenLearner compresses to 8; the 48 tokens of the six images go to a decoder-only transformer of 8 layers that outputs the action tokens. The model has 35 million parameters (16 million in the image and instruction encoder, 19 million in the transformer). The authors needed at least 3 Hz control, because humans took 2–4 s per instruction, which left under 100 ms for the model; TokenLearner and reusing tokens across overlapping history windows sped inference up by 2.4 and 1.7 times.

The data were about 130,000 demonstrations collected with 13 mobile manipulators over 17 months in office kitchens, covering over 700 instructions (744 in their Table I) built from a verb and one or more nouns. In more than 3,000 real-world trials, success was judged by a human rater, and an episode also failed if the robot collided with the environment, touched irrelevant objects, behaved unsafely or did not finish within 100 actions (about 33 s). RT-1 performed 97% of over 200 seen instructions and 76% of 21 unseen combinations of seen objects and skills, ahead of Gato and BC-Z architectures trained on the same data. Adding simulated data raised real-world success on objects seen only in simulation from 23% to 87% at a cost of 2 points on real-object tasks, and adding 209,000 bin-picking episodes from a different robot (a Kuka arm, from QT-Opt) raised bin-picking success on the mobile manipulator from 22% to 39%. In data ablations, removing 25% of the tasks while keeping 97% of the data cost about as much generalization as removing 49% of the data, which the authors summarize as diversity mattering more than quantity. They name four limits: imitation may not surpass the demonstrators, generalization covers new combinations of seen concepts but not new motions, the test kitchens were still similar to the training setup, and the tasks were not very dexterous.

RT-2

RT-2 (Brohan et al., 2023b) fine-tunes two vision–language models: PaLI-X at 5 and 55 billion parameters, whose architecture, as the appendix describes it, encodes images with ViT-22B and generates text with an encoder–decoder based on UL2, and PaLM-E at 12 billion parameters, a decoder-only language model that takes projected image features. Robot data, RT-1’s demonstrations, are posed as visual question answering, “Q: what action should the robot take to [task instruction]? A:”, with the action string as the answer.

Co-fine-tuning. The authors’ key training detail is to keep the original web data (visual question answering, captioning and interleaved image–text data) in the fine-tuning mixture instead of fine-tuning on robot data alone, with the robot data weighted to about 50% of the mixture for PaLI-X and 66% for PaLM-E. In their ablation on unseen objects, backgrounds and environments, the 5B model averaged 9% when trained from scratch, 42% when fine-tuned on robot data and 44% when co-fine-tuned; the 55B model averaged 52% fine-tuned and 63% co-fine-tuned (Appendix Table 7). Table 5 reports the same 55B co-fine-tuned entries with an average of 62%; the six numbers average 62.3. The authors attribute the benefit of co-fine-tuning to the model not forgetting concepts learned in pretraining.

Evaluation. About 6,000 real trials compared the RT-2 models with RT-1, MOO and policies on pretrained visual representations (VC-1, R3M), all trained on the same robot data. On seen tasks the RT-2 models matched RT-1; on unseen categories they averaged 62% against 32% for RT-1, the generalization result that the embodied AI article also cites. Instructions requiring knowledge absent from the robot data were grouped as symbol understanding (“move apple to 3”), reasoning (including arithmetic and instructions in Spanish, German and French) and person recognition; on them RT-2-PaLI-X-55B averaged 60% and RT-2-PaLM-E-12B 40%, against 17% for RT-1 and 11% for VC-1 in A/B evaluations (Appendix Table 6). In the simulated Language-Table environment, a 3B PaLI model with actions written as two integers from −10 to +10 reached 90 ± 10% against 74 ± 13% for RT-1. A variant fine-tuned to write a short natural-language plan before the action tokens could, qualitatively, handle more complex commands.

Inference. The 55B model ran at 1–3 Hz, the 5B model at about 5 Hz, served from a multi-TPU cloud service queried over the network. The authors list as limits that web data teaches no new motions, only new uses of the motions in the robot data; that the computation cost may become a bottleneck for high-frequency control; and that few vision–language models were open to fine-tuning.

OpenVLA

OpenVLA (Kim et al., 2024) is a 7-billion-parameter VLA with released weights and training code. It starts from the Prismatic-7B vision–language model: a 600M-parameter visual encoder that runs SigLIP and DINOv2 on the same patches and concatenates their features channel-wise (DINO describes the self-supervised family of DINOv2), a two-layer MLP projector, and the Llama 2 7B language model. The authors chose Prismatic over IDEFICS-1 and LLaVA, which worked similarly in their early tests, for the spatial reasoning attributed to the DINOv2 features. It is trained on 970,000 episodes curated from Open X-Embodiment, restricted to single-arm end-effector control with a third-person camera and weighted with Octo’s mixture weights. DROID was added at 10% and removed for the last third of training because its action-token accuracy stayed low.

Several design findings, from smaller experiments on BridgeData V2, depart from vision–language model practice: 384 × 384 inputs were no better than 224 × 224 and took three times longer to train; fine-tuning the vision encoder was crucial, where VLM training usually freezes it; and real-robot performance kept improving until training action-token accuracy passed 95%, where language models usually train for one or two epochs; the final run made 27 passes through its data. The final run used 64 A100 GPUs for 14 days (21,500 A100-hours); inference needs 15 GB in bfloat16 and runs at about 6 Hz on an RTX 4090.

In A/B evaluations of 170 rollouts on a WidowX robot (Bridge V2 tasks) and 60 on the Google robot, OpenVLA outperformed RT-2-X on Bridge V2 and was comparable on the Google robot, while RT-1-X and Octo often manipulated the wrong object when distractors were present. Fine-tuned on 10–100 demonstrations of new Franka tasks, Diffusion Policy trained from scratch was competitive or better on narrow single-instruction tasks such as pouring corn into a pot, while OpenVLA was better on tasks with several objects and instructions, and was the only method with at least 50% success on every task. Low-rank adaptation (LoRA, rank 32), training 1.4% of the parameters, reached 68.2% against 69.7% for full fine-tuning on selected Franka-Tabletop tasks (their Table 1, 33 rollouts per method). With model quantization, 4-bit inference matched bfloat16 on Bridge V2 (71.9% and 71.3%) while 8-bit fell to 58.1%; the authors trace the 8-bit drop to slower inference, which changes the system dynamics the policy was trained on. They list as limits single-image input without proprioception, low control frequency, and design choices left unexplored, such as co-training with web data.

Cross-Embodiment Training

Open X-Embodiment. The Open X-Embodiment dataset pooled 60 existing datasets from 34 robotics labs into over a million real trajectories from 22 embodiments, from single arms to bimanual robots and quadrupeds, in the RLDS episode format (Open X-Embodiment Collaboration, project page and dataset documentation). The same page also describes the collaboration as 21 institutions demonstrating 527 skills. The actions are only coarsely aligned: each dataset’s actions become a 7-dimensional end-effector vector (position, orientation, gripper), normalized per dataset before discretization, with coordinate frames not aligned and values that may be absolute or relative positions or velocities, so that “the same action vector may induce very different motions for different robots” (arXiv v9, Section IV). RT-1-X and RT-2-X are RT-1 and RT-2 trained on the mixture. The embodied AI article reports the paper’s main comparison, including that RT-1-X underfit the two large datasets; one further result bears on transfer. On Google-robot tasks whose objects and skills appear only in the WidowX robot’s Bridge data, RT-2-X succeeded in 75.8% of trials against 27.3% for RT-2, and 42.8% when Bridge was removed from its training mix (Table II of arXiv v9).

Octo. Octo (Ghosh et al., 2024) trains a transformer policy from scratch, without web pretraining, on 800,000 trajectories from 25 Open X-Embodiment datasets, keeping those with images and delta end-effector actions and doubling the weight of the more diverse ones. Language is encoded by a pretrained t5-base model (111M parameters) and images by a shallow convolution split into patches; block-wise masked attention means that inputs missing from a dataset are simply masked, and new observation types or action heads can be added for fine-tuning without re-initializing the transformer. Released in 27M and 93M versions, it was fine-tuned with about 100 demonstrations per new setup, including a new force-torque input, joint-position actions and new robots, and averaged 72% over six setups against 20% for a ResNet-and-transformer policy trained from scratch and 15% for a VC-1 representation (their Table I). Its authors trace two weaknesses to the data: wrist cameras were present in 27% of it and language annotations in 56%.

π0. π0 (Black et al., 2025) pretrains on its authors’ own dexterous data, 903 million time steps from 7 robot configurations and 68 tasks (about 10,000 hours), plus 9.1% open data (a subset of Open X-Embodiment, Bridge v2 and DROID), with actions and states zero-padded to the largest robot’s 18 dimensions and missing camera slots masked. Pretraining is followed by post-training on curated data for each task, from 5 to over 100 hours, which the authors compare to the pre-training and post-training phases of language models. In direct prompting after pretraining, π0 outperformed OpenVLA and Octo trained on the same mixture on shirt folding, table bussing, grocery bagging and toast removal, including in a version trained for 160,000 steps, no more than the baselines received. The authors attribute OpenVLA’s weakness here to its token architecture, which does not support action chunks. They name as open problems how to compose and weight pretraining data, how much data a task needs to work reliably, and how much transfer there is across very different tasks and robots.

Fine-Tuning and Evaluation

Fine-tuning recipes. The studies above fine-tune the whole model (Octo, OpenVLA’s main experiments), use LoRA (OpenVLA), or change the output interface during fine-tuning (OpenVLA-OFT’s parallel decoding, chunking and continuous head; Octo’s new heads). OpenVLA-OFT also reports that parallel decoding with 8-step chunks raised action throughput 26-fold over autoregressive OpenVLA on an A100 (Kim, Finn and Liang, 2025). The related procedure for vision–language models, adapting a pretrained model to new instruction formats, is described in instruction tuning for vision–language models.

Real-robot protocols. Real evaluations define their own tasks, trial counts and success criteria: RT-1’s human-rated success with collision and time-limit failures; RT-2’s seen tasks plus unseen objects, backgrounds and environments, each with easy and hard cases; π0’s normalized scores with partial credit, such as the fraction of objects placed in the right bin, averaged over 10 episodes per task. Several papers run candidate policies one after another under the same conditions (A/B evaluation) to reduce variance (Brohan et al., 2023b; Kim et al., 2024). The resulting success rates are comparable only within one paper’s evaluation; the embodied AI article gives the example of RT-1 at 97% in its own paper and 92% in RT-2’s evaluation of seen tasks.

SIMPLER. Li et al. (2024) build simulated copies of the Google robot and WidowX evaluation setups. They reduce the control gap by system identification of the simulated controller against real trajectories and the visual gap by “visual matching”, overlaying the real background behind the simulated scene (“green-screening”) and projecting real textures onto simulated objects; the alternative, “variant aggregation”, randomizes visuals and averages over variants. Policies’ real and simulated success rates are compared with the Pearson correlation and with the mean maximum rank violation (MMRV),

$$\text{MMRV} = \frac{1}{N} \sum_{i=1}^{N} \max_{1 \le j \le N} |R_i - R_j|\, \mathbb{1}\big[(R^S_i < R^S_j) \ne (R_i < R_j)\big],$$

where $R_i$ and $R^S_i$ are policy $i$’s real and simulated success rates, so a pair whose order flips is penalized by how far apart the two policies are in the real world. On six Google-robot policy checkpoints, averaged over three tasks, visual matching gave an MMRV of 0.056 and Pearson $r$ of 0.924, variant aggregation 0.143 and 0.778, and ranking by validation action MSE, the usual offline model-selection score, 0.375 and 0.308 (their Table 1). Offline action error, in other words, ranked these policies poorly. The authors list as limits rigid objects only, fixed cameras for visual matching (which also misses shadows), and manual effort to build each environment.

LIBERO. LIBERO (Liu et al., 2023) is a simulated benchmark built for lifelong learning; the visuomotor policy learning article describes its suites and original metrics. OpenVLA and later VLA papers use four of its suites, each with 10 tasks and 50 human demonstrations per task, for supervised fine-tuning. OpenVLA’s protocol changed the training data, not the test environments: demonstrations re-rendered at 256 × 256, near-zero “no-op” actions removed (without which, the authors found, the policy imitated them and froze), images rotated 180° (at training and test time) because the environments returned them upside down on the authors’ hardware, failed demonstrations removed, and only the third-person camera used; each method was evaluated over 500 trials per suite and three seeds. The averages were 76.5% for OpenVLA, 75.1% for Octo and 72.4% for Diffusion Policy trained from scratch, a smaller margin than on real robots, which the authors attribute to OpenVLA having been pretrained only on real data (Kim et al., 2024, Table 12). Results on LIBERO are therefore comparable only between papers that use the same inputs and data filtering; OpenVLA-OFT’s Table I groups its comparisons this way.

Examples

Example: quantization error of action tokens

The example trains a tiny image-and-instruction-to-action model from scratch and compares discretized action tokens with continuous regression. Each 32 × 32 image shows three of four objects (a red disc, a green square, a blue triangle and a yellow ring) at random positions and a white cross marking the end effector; the instruction is a token naming one of the three. The action is the end effector’s 2D displacement in a unit-square workspace, given by an expert that moves halfway to the target, capped at a step of 0.1: $a = 0.5(g - p)$, scaled down when $\lVert a \rVert > 0.1$.

The network is a three-layer convolutional encoder with two coordinate channels, conditioned on the instruction by FiLM as in RT-1, in miniature, followed by one of five heads: 4, 16 or 256 uniform bins per action dimension over the bounds $[-0.1, 0.1]$, trained with cross-entropy and decoded to the centre of the most probable bin, or a continuous head trained with MSE or with L1. Training states are sampled independently rather than along expert trajectories, half of them within 0.12 of the target so that small corrective actions are well represented; this keeps the compounding error of behaviour cloning, which the visuomotor policy learning example measures, out of the comparison. Each policy is scored by its action RMSE on 2,000 held-out states and by closed-loop success over 300 episodes of 30 steps, in which the image is re-rendered after every move; success is a final distance to the target below 0.02 (about two-thirds of a pixel) or below 0.05, two tolerances because the right one is a choice. A reference block runs the expert itself with its actions quantized to 2–256 bins, with no learning, to separate the quantization error from the learning error. The script loops over seeds 0, 1 and 2, each with its own data and initialization.

The example uses PyTorch 2.14.1 and NumPy 2.5.4. It trains 15 networks (five heads, three seeds) for 12 epochs each, and took about 20 minutes on a laptop CPU; two runs gave identical output. The budget was fixed before the first run: the plan had eight heads and 15 epochs, and after timing and a full-scale pilot of the MSE regression head, three bin counts were dropped from training (they stay in the reference block) and the epochs were cut to 12. No bin head was piloted.

import numpy as np
import torch
import torch.nn as nn

torch.set_num_threads(4)
R = 32                                            # image size in pixels
COLORS = np.array([[1.0, 0.2, 0.2], [0.2, 0.9, 0.2], [0.3, 0.4, 1.0], [1.0, 0.9, 0.2]])
NAMES = ["red disc", "green square", "blue triangle", "yellow ring"]
yy, xx = (np.mgrid[0:R, 0:R] + 0.5) / R           # pixel centres in the unit-square workspace
AMAX = 0.1                                        # action bounds [-0.1, 0.1] per axis

def sdf(kind, c):                                 # signed distance to each object type (negative inside)
    dx, dy = xx - c[:, 0, None, None], yy - c[:, 1, None, None]
    if kind == 0:
        return np.hypot(dx, dy) - 0.07
    if kind == 1:
        return np.maximum(np.abs(dx), np.abs(dy)) - 0.06
    if kind == 2:
        return np.maximum.reduce([dy - 0.06, -0.866 * dx - 0.5 * dy - 0.035, 0.866 * dx - 0.5 * dy - 0.035])
    return np.abs(np.hypot(dx, dy) - 0.055) - 0.018

def render(objs, kinds, ee, rng):                 # anti-aliased objects plus a white cross for the gripper
    img = np.full((len(ee), R, R, 3), 0.12)
    for k in range(objs.shape[1]):
        for kind in range(4):
            sel = kinds[:, k] == kind
            if sel.any():
                m = 1 / (1 + np.exp(sdf(kind, objs[sel, k]) * R / 0.5))
                img[sel] = img[sel] * (1 - m[..., None]) + m[..., None] * COLORS[kind]
    dx, dy = np.abs(xx - ee[:, 0, None, None]), np.abs(yy - ee[:, 1, None, None])
    d = np.minimum(np.maximum(dx - 0.06, dy - 0.01), np.maximum(dx - 0.01, dy - 0.06))
    m = 1 / (1 + np.exp(d * R / 0.5))
    img = img * (1 - m[..., None]) + m[..., None] + rng.normal(0, 0.03, img.shape)
    return torch.tensor(img, dtype=torch.float32).permute(0, 3, 1, 2)

def scenes(n, rng):                               # 3 of 4 object types; the instruction names one of them
    objs, kinds = np.zeros((n, 3, 2)), np.zeros((n, 3), int)
    for i in range(n):
        kinds[i] = rng.choice(4, 3, replace=False)
        while True:
            p = rng.uniform(0.15, 0.85, (3, 2))
            if min(np.linalg.norm(p[a] - p[b]) for a, b in ((0, 1), (0, 2), (1, 2))) >= 0.2:
                break
        objs[i] = p
    slot = rng.integers(0, 3, n)
    return objs, kinds, kinds[np.arange(n), slot], objs[np.arange(n), slot]

def expert(p, g):                                 # proportional step towards the target, length <= 0.1
    a = 0.5 * (g - p)
    return a * np.minimum(1, AMAX / np.maximum(np.linalg.norm(a, axis=1, keepdims=True), 1e-12))

def states(n, rng):                               # i.i.d. states: half anywhere, half within 0.12 of the target
    objs, kinds, ins, g = scenes(n, rng)
    ee = rng.uniform(0.05, 0.95, (n, 2))
    near = rng.random(n) < 0.5
    r, th = 0.12 * np.sqrt(rng.random(n)), rng.uniform(0, 2 * np.pi, n)
    ee[near] = np.clip(g[near] + np.c_[r * np.cos(th), r * np.sin(th)][near], 0, 1)
    return render(objs, kinds, ee, rng), torch.tensor(ins), expert(ee, g)

def to_bins(a, B):                                # uniform bins over [-AMAX, AMAX], as in RT-1 and RT-2
    return np.clip(np.floor((a + AMAX) / (2 * AMAX / B)), 0, B - 1).astype(int)

def from_bins(q, B):                              # bin index -> bin centre
    return -AMAX + (q + 0.5) * 2 * AMAX / B

class Net(nn.Module):                             # small CNN, instruction applied by FiLM, one output head
    def __init__(self, out):
        super().__init__()
        self.emb = nn.Embedding(4, 16)
        self.convs = nn.ModuleList([nn.Conv2d(5, 32, 3, 2, 1), nn.Conv2d(32, 64, 3, 2, 1), nn.Conv2d(64, 64, 3, 1, 1)])
        self.films = nn.ModuleList([nn.Linear(16, 2 * c) for c in (32, 64, 64)])
        self.fc = nn.Sequential(nn.Flatten(), nn.Linear(64 * 8 * 8, 256), nn.ReLU(), nn.Linear(256, out))
        cy, cx = torch.meshgrid(torch.linspace(0, 1, R), torch.linspace(0, 1, R), indexing="ij")
        self.register_buffer("coord", torch.stack([cx, cy])[None])

    def forward(self, img, ins):
        x = torch.cat([img, self.coord.expand(len(img), -1, -1, -1)], 1)
        e = self.emb(ins)
        for conv, film in zip(self.convs, self.films):
            gm, bt = film(e).chunk(2, 1)
            x = torch.relu(conv(x) * (1 + gm[..., None, None]) + bt[..., None, None])
        return self.fc(x)

def make_policy(head, X, I, A, seed, epochs=12):
    torch.manual_seed(seed)
    B = 0 if head in ("mse", "l1") else head
    net = Net(2 if B == 0 else 2 * B)
    opt = torch.optim.Adam(net.parameters(), 1e-3)
    T = torch.tensor(A, dtype=torch.float32) if B == 0 else torch.tensor(to_bins(A, B))
    for _ in range(epochs):
        perm = torch.randperm(len(X))
        for i in range(0, len(X), 128):
            b = perm[i:i + 128]
            out = net(X[b], I[b])
            if head == "mse":
                loss = ((out - T[b]) ** 2).mean()
            elif head == "l1":
                loss = (out - T[b]).abs().mean()
            else:                                 # cross-entropy on each action dimension's bin
                loss = nn.functional.cross_entropy(out.view(-1, B), T[b].view(-1))
            opt.zero_grad(); loss.backward(); opt.step()

    def act(img, ins):                            # continuous output, or argmax bin decoded to its centre
        with torch.no_grad():
            out = net(img, ins)
        return out.numpy() if B == 0 else from_bins(out.view(-1, 2, B).argmax(-1).numpy(), B)
    return act

def rollout(policy, test, seed, steps=30):        # closed loop: render, act, move, repeat
    objs, kinds, ins, g, ee0 = test
    rng, ee = np.random.default_rng(seed), ee0.copy()
    for _ in range(steps):
        ee = np.clip(ee + policy(render(objs, kinds, ee, rng), torch.tensor(ins), ee, g), 0, 1)
    return np.linalg.norm(ee - g, axis=1)

def summary(d):
    return np.mean(d < 0.02) * 100, np.mean(d < 0.05) * 100, d.mean()

rmse = lambda p, t: np.sqrt(((p - t) ** 2).mean())
heads, results, tests = [4, 16, 256, "mse", "l1"], {}, []
for seed in (0, 1, 2):
    rng = np.random.default_rng(seed)
    X, I, A = states(20000, rng)                  # training states
    Xv, Iv, Av = states(2000, rng)                # held-out states for action error
    objs, kinds, ins, g = scenes(300, rng)        # closed-loop test episodes
    test = (objs, kinds, ins, g, rng.uniform(0.05, 0.95, (300, 2)))
    tests.append(test)
    for h in heads:
        act = make_policy(h, X, I, A, seed)
        d = rollout(lambda img, ins, ee, g: act(img, ins), test, 1000 + seed)
        results.setdefault(h, []).append((rmse(act(Xv, Iv), Av),) + summary(d))

print("quantized expert, no learning (900 episodes): label RMSE, success <0.02, <0.05, mean final distance")
Aq = np.concatenate([states(2000, np.random.default_rng(s))[2] for s in (0, 1, 2)])
for B in (2, 4, 8, 16, 64, 256, "continuous"):
    q = (lambda a: a) if B == "continuous" else (lambda a, B=B: from_bins(to_bins(a, B), B))
    d = np.concatenate([rollout(lambda img, ins, ee, g: q(expert(ee, g)), t, 1000 + s) for s, t in enumerate(tests)])
    print(f"  {str(B):>10}  RMSE {rmse(q(Aq), Aq):.4f}   success {summary(d)[0]:5.1f}% {summary(d)[1]:5.1f}%"
          f"   final dist {summary(d)[2]:.4f}")
print("learned policies, mean over seeds 0-2 [min, max]")
for h in heads:
    r = np.array(results[h])
    name = f"{h} bins" if isinstance(h, int) else f"regression {h.upper()}"
    cell = lambda j, f: f"{r[:, j].mean():{f}} [{r[:, j].min():{f}}, {r[:, j].max():{f}}]"
    print(f"  {name:>15}  action RMSE {cell(0, '.4f')}  success <0.02 {cell(1, '5.1f')}"
          f"  <0.05 {cell(2, '5.1f')}  final dist {cell(3, '.4f')}")

quantized expert, no learning (900 episodes): label RMSE, success <0.02, <0.05, mean final distance
           2  RMSE 0.0309   success  11.7%  77.9%   final dist 0.0385
           4  RMSE 0.0153   success  46.4% 100.0%   final dist 0.0194
           8  RMSE 0.0075   success 100.0% 100.0%   final dist 0.0097
          16  RMSE 0.0037   success 100.0% 100.0%   final dist 0.0049
          64  RMSE 0.0009   success 100.0% 100.0%   final dist 0.0012
         256  RMSE 0.0002   success 100.0% 100.0%   final dist 0.0003
  continuous  RMSE 0.0000   success 100.0% 100.0%   final dist 0.0000
learned policies, mean over seeds 0-2 [min, max]
           4 bins  action RMSE 0.0161 [0.0159, 0.0163]  success <0.02  42.0 [ 41.0,  43.7]  <0.05  99.4 [ 99.0, 100.0]  final dist 0.0222 [0.0219, 0.0225]
          16 bins  action RMSE 0.0385 [0.0077, 0.0546]  success <0.02  28.8 [  0.0,  86.3]  <0.05  33.4 [  0.0,  99.7]  final dist 0.3440 [0.0128, 0.5433]
         256 bins  action RMSE 0.1016 [0.0875, 0.1119]  success <0.02   0.1 [  0.0,   0.3]  <0.05   0.3 [  0.0,   1.0]  final dist 0.7206 [0.7197, 0.7217]
   regression MSE  action RMSE 0.0121 [0.0083, 0.0175]  success <0.02  55.1 [ 37.7,  70.3]  <0.05  91.0 [ 74.7,  99.3]  final dist 0.0246 [0.0162, 0.0380]
    regression L1  action RMSE 0.0080 [0.0062, 0.0090]  success <0.02  81.7 [ 73.0,  93.3]  <0.05  99.6 [ 99.0, 100.0]  final dist 0.0138 [0.0102, 0.0164]

The reference block isolates the quantization error. The RMSE of the quantized labels halves with each doubling of the bin count, as $w/\sqrt{12}$ predicts, but sits slightly above it for coarse bins (0.0153 against 0.0144 for 4 bins); in our reading, because the near-target states put many small actions next to zero, which with an even number of bins is a bin edge rather than a bin centre, so the errors are not spread evenly within the bins. In closed loop, two bins give a smallest move of 0.05 per axis and four bins 0.025, so the quantized expert cannot settle on the target: it oscillates around it, ending within 0.05 in every episode with four bins but within 0.02 in fewer than half. From eight bins on, the quantized expert succeeds in every episode at both tolerances, so for this task the representation itself needs about eight bins; how many a task needs depends on its tolerance relative to the bin width.

The learned 4-bin heads come close to that ceiling: their action RMSE (0.0161) is near the labels’ own quantization error and their success within 0.02 (42.0%) near the quantized expert’s 46.4%, consistently over the three seeds. The network learned almost everything the representation can express, and the bins are its limit. The continuous heads have no such ceiling; the L1 head has the lowest action error and the highest success within 0.02, while the MSE head varies more between seeds (37.7% to 70.3%). The output does not show why the two losses differ here.

The finer bin heads went against the plan’s hypothesis for the learned heads, “success saturates by ~16 bins; 256 bins similar to regression”. A 16-bin head learned in one seed, with an action RMSE of 0.0077 and better success than any 4-bin head, and failed in the other two; the 256-bin heads failed in all three seeds, with action errors as large as the action bounds and episodes ending far from the target. Their quantization error is negligible, so the failure is one of learning. In our reading, cross-entropy treats the bins as unrelated classes: a prediction one bin off costs as much as one a hundred bins off, so the loss carries no information about distance in action space, and each bin must be learned from its own examples, about 80 per bin and dimension on average here (20,000 states over 256 bins). Within the fixed budget of 12 epochs, set from the regression head’s pilot, the finer the bins, the less often training got past that stage. The example does not test longer training, and it says nothing about the scale of the cited models, which train on hundreds of thousands of episodes (OpenVLA for 27 epochs). What it shows is the trade-off at small scale: coarse bins are easy to learn but limit precision, fine bins remove the quantization error but are harder to learn, and regression avoids the choice. Because the expert is deterministic, the example cannot show the advantage the RT-1 and Octo authors give to multimodal action distributions; there was only one correct action per state.

Common Misconceptions

• “A VLA is a language model that plans.” Using a language model to choose among a robot’s existing skills, as SayCan does, is a different design; a VLA outputs the low-level actions itself, although RT-2’s chain-of-thought variant writes a short plan before them.
• “Web pretraining gives the robot new skills.” RT-2’s authors report the opposite for motions: the model deploys the skills in its robot data in new situations but acquires no new motions from web data (Brohan et al., 2023b).
• “256 bins means 8-bit precision of the motion.” The bins cover each dimension’s bounds; their width depends on those bounds, which RT-1 sets from each variable’s range and OpenVLA from the 1st and 99th percentiles, and OpenVLA’s released code reconstructs 255 values. Nor are more bins simply better: in the example above, 256 bins removed the quantization error but did not learn the task within the same budget that sufficed for four bins and for regression.
• “Lower offline action error means a better policy.” SIMPLER found validation action MSE a poor predictor of the real-world ranking of six policy checkpoints (Li et al., 2024). In the small example action RMSE ranked the heads in the same order as success within 0.02, but not within 0.05, where the 4-bin heads beat the MSE head despite a larger action error.
• “Success rates can be compared across papers.” Real-robot evaluations differ in tasks, trial counts, scoring and hardware, and LIBERO results depend on inputs and data filtering; comparisons hold within one evaluation.

Documented Limits

The limits below are those the cited authors report for their own models; they are statements about the evaluated systems at the time of each paper.

• Motions bounded by the robot data. RT-1 and RT-2 generalize to new combinations of objects, scenes and instructions but not to new motions (Brohan et al., 2023a; 2023b).
• Inference rate. RT-2’s 55B model runs at 1–3 Hz from a cloud service and OpenVLA at about 6 Hz on a desktop GPU; both groups name inference speed as a limit for high-frequency control (Brohan et al., 2023b; Kim et al., 2024). Chunked outputs (π0, OpenVLA-OFT) and compressed tokens (FAST) are the responses reported; edge inference and model compression cover the general tools.
• Inputs. OpenVLA takes one image without proprioception; Octo handles wrist cameras poorly and follows goal images better than language, which its authors trace to the composition of its data (Kim et al., 2024; Ghosh et al., 2024).
• Data composition. π0’s authors call the composition and weighting of pretraining data an open problem; OpenVLA’s action-token accuracy on DROID stayed low, which FAST later cites as an instance of the difficulty of binning high-frequency data (Black et al., 2025; Kim et al., 2024; Pertsch et al., 2025).
• Imitation only. The datasets are demonstrations, so the policies inherit imitation learning’s ceiling of the demonstrators’ performance (Brohan et al., 2023a); Octo’s authors list learning from sub-optimal or online data as future work.
• Evaluation. Real evaluations are run by the authors on their own robots; SIMPLER’s authors describe real-world evaluation as hard to scale and reproduce, and their simulated copies cover rigid objects and fixed cameras (Li et al., 2024).

Where It Is Used

VLAs are studied mainly for table-top and mobile manipulation, including grasping, drawer opening, sorting and dexterous bimanual tasks such as laundry folding. Their action interfaces build on visuomotor policy learning, their backbones on vision–language pretraining and the vision transformer, and their evaluation increasingly on simulation, which sim-to-real transfer treats in the other direction, training in simulation for real robots. The π0 authors leave open whether such models extend to autonomous driving, navigation and legged locomotion, and end-to-end autonomous driving describes the corresponding single-network approach for vehicles; vision-and-language navigation applies language instructions to movement through 3D environments.