Vision-language-action model

Overview

A vision-language-action (VLA) model maps a camera image and a text instruction to the next robot action. OpenVLA and EventVLA both start from a pretrained vision-language model and train it further on robot demonstrations. OpenVLA states the input and output directly: one image and a sentence in, seven action dimensions out per step 2406.09246 §3.1 2406.09246 §3.2.

Most variants share one invariant: a pretrained vision-language backbone is adapted to output actions. Octo is the exception. It trains a transformer from scratch on robot data and uses only a frozen T5-base encoder for the instruction 2405.12213 §3.1. OpenVLA writes each action dimension as a discrete token, using the same next-token machinery as words [arxiv:2406.09246 §3.2]. GF-VLA also starts from a pretrained language model, a 7B LLaMA 2, and adapts it with LoRA. It adds a scene graph built from human video before planning 2508.05342 §4.2 2508.05342 §3. Other cards use continuous action heads instead: flow matching in DiT4DiT 2603.10448 §4.2, the pi0.6 base model used by MEM 2603.03596 §3.4 and GR00T N1 2503.14734 §2.1, diffusion in Octo and DexVLA 2405.12213 §3.3 2502.05855 §3.1, and an L1 regression head in OFT 2502.19645 §4.2. RT-2-X also writes actions as text tokens of its language model 2310.08864 §4.2.

The cards in this page cover several questions. The policy itself can be single frame, memory-augmented, or a joint video-action model. Training can pool data from many robots into one action space. Action heads can predict chunks at more than one length, or shape how consecutive chunks join up. Runtime monitors and supervisors watch a policy while it runs, and one card lets the policy rewind to an earlier subtask and retry it. Emma-X adds a written plan before each action 2412.11974 §3.3. Evaluation papers score policies on more than a single fixed task. The action head is a separate choice, from discrete tokens to regression, diffusion or flow matching.

Some cards change more than the policy. OXE-AugE changes the training data 2512.13100 §4.2, and RLDG replaces human demonstrations with rollouts of per-task reinforcement-learning experts 2412.09858 §3. STORM keeps a VLA as the action proposer and wraps it in a search over imagined outcomes 2512.18477 §3. RoboScape-R trains a policy inside a learned world model 2512.03556 §3.2. DualVLN targets navigation, and SIMA 2 is a game agent that outputs keyboard and mouse actions 2512.08186 §3.1 2512.04797 §3.2. A survey covers the wider field and reports no experiments of its own 2402.02385 §1. These cards do not all share the invariant above. RoboScape-R's policy in one experiment is an MLP, not a VLM 2512.03556 §4.1.

Variants

Single-frame open VLA with discrete action tokens

The policy sees the current image, the instruction and no history. OpenVLA is a 7B-parameter model built on the Prismatic-7B VLM with fused DINOv2 and SigLIP vision features and a Llama 2 7B backbone. Its 7 action dimensions use 256 bins each, spread over the 1st to 99th percentile of the training data. It was trained on 970k Open X-Embodiment episodes 2406.09246 §3.1 2406.09246 §3.2 2406.09246 §3.3. Card: OpenVLA: An Open-Source Vision-Language-Action Model.

The authors report 70.6% mean success on BridgeData V2 and 85.0% on a Google robot, both above RT-2-X, which is closed and has 55B parameters 2406.09246 app. B.1.3 2406.09246 app. B.2.2. These are author-reported, with 10 and 5 rollouts per task. Fine-tuning is either full or LoRA. LoRA at rank 32 on all linear layers matched full fine-tuning on the Franka-Tabletop tasks while training 1.4% of the parameters [arxiv:2406.09246 §5.3].

Parallel-decoding fine-tuning recipe (OFT)

This variant changes how an existing autoregressive VLA is fine-tuned, and keeps its backbone. OpenVLA decodes its action dimensions one token at a time. The authors measure it at 4.2 Hz on one A100 2502.19645 tab. 2. OFT appends empty action slots for every step of a chunk, makes attention bidirectional, and reads the whole chunk out in one forward pass. A continuous head replaces the token output layer and is trained with an L1 loss 2502.19645 §4.2 2502.19645 app. A.2. Card: Fine-Tuning Vision-Language-Action Models: Optimizing Speed and Success. See also action chunking.

On LIBERO, the authors report 95.3% average with third-person images and language, and 97.1% with a wrist camera and proprioceptive state on the filtered data. Fine-tuned OpenVLA is at 76.5% in the same table [arxiv:2502.19645 tab. 1]. The 97.1% is the best of checkpoints saved every 50k steps, chosen on the evaluation runs, so it is optimistic 2502.19645 §5.1 2502.19645 app. A.4. In the efficiency table, the recipe reaches 109.7 Hz against 4.2 Hz for OpenVLA, and LIBERO-Long success rises from 53.7% to 90.7% 2502.19645 tab. 2. Robot pretraining matters for this recipe: without it, the recipe on the base VLM reaches 91.9% 2502.19645 tab. 15.

Fine-tuning uses LoRA at rank 32, with 279M trainable parameters on LIBERO 2502.19645 tab. 4. The chunk is 8 steps on LIBERO and 25 on ALOHA, and all of it runs open-loop before the next query 2502.19645 tab. 4 2502.19645 tab. 5. A FiLM variant (OFT+) is used only on a bimanual ALOHA robot at 25 Hz. The authors report it matches or exceeds pi0, RDT-1B, ACT and Diffusion Policy on each of its four tasks 2502.19645 §6.3 2502.19645 tab. 10 to 2502.19645 tab. 13. The trial counts are 10 to 24 per task 2502.19645 §6.1.

Use this variant when fine-tuning speed matters and the base model is an OpenVLA-class VLA. Parallel decoding may be less expressive than token-by-token decoding, and L1 regression tends toward the median of multimodal demonstrations. The authors report no loss on their tasks, but they test only these tasks 2502.19645 §4.2 2502.19645 §8.

Cross-embodiment co-trained policy (RT-1-X, RT-2-X)

This variant trains one policy on episodes from many robots. The data is converted to one format, and each dataset's actions are mapped to a shared 7-DoF end-effector action 2310.08864 §4.1. The actions are not aligned between robots: absolute, relative and velocity commands are mixed, so one vector can move two robots differently. The policy gets images and an instruction only, with no robot identity input 2310.08864 §4.1.

The paper trains two policies. RT-1-X is RT-1, a 35M-parameter model, trained on the mixture alone with a 15-frame history 2310.08864 §4.2. RT-2-X uses the RT-2 recipe on the PaLI-X backbone and is co-fine-tuned with web vision-language data at roughly a 1:1 ratio 2310.08864 §4.2 2310.08864 §4.3. Card: Open X-Embodiment: Robotic Learning Datasets and RT-X Models.

The authors report that RT-1-X beats each dataset's original method on 4 of 5 small-data domains. On the large-data domains it does not beat RT-1 2310.08864 §5.1 2310.08864 tab. 1. RT-2-X reaches 75.8% emergent-skill success against 27.3% for RT-2 2310.08864 tab. 2. These are author-reported. The 55B RT-2-X is not in the released repository, and only an RT-1-X checkpoint is linked README.md, so the RT-2-X numbers cannot be reproduced from the repository. The training-mixture code is not in it either.

Generalist transformer with diffusion action head (Octo)

Octo is a transformer policy trained from scratch on robot data, not built on a VLM. Each camera image becomes patch tokens, and the instruction goes through a frozen T5-base encoder. Readout tokens are added for each time step 2405.12213 §3.1. The readout embedding feeds a small diffusion head: three residual MLP blocks of width 256, with 20 denoising steps [arxiv:2405.12213 §3.3] 2405.12213 app. D. The model is pretrained on about 800k trajectories from Open X-Embodiment 2405.12213 §1. A new camera or action space needs only a small new encoder or head, and the transformer is kept 2405.12213 §3.1 2405.12213 §3.3. Card: Octo: An Open-Source Generalist Robot Policy.

On six real finetuning setups with about 100 demonstrations each, the authors report 72% average success. Training from scratch with a ResNet and transformer reaches 20%, and a VC-1 encoder with an MSE head reaches 15% [arxiv:2405.12213 tab. 1]. The text says Octo beats the next best baseline "by 52%". Table 1 shows 52 percentage points, not a ratio 2405.12213 §4.2. In design ablations on Octo-Small, the diffusion head reaches 83% aggregate, against 35% for a continuous MSE head and 18% for discretized actions [arxiv:2405.12213 tab. 2]. Those ablations use 40 trials, and the finetuning tables use 10 to 20 per setup 2405.12213 tab. 1 2405.12213 tab. 2.

Use this variant for an open generalist policy with a small, swappable input and action set, where a VLM backbone is not needed. Finetuning took about 5 hours on one A5000 GPU in the authors' setup 2405.12213 §3.4. Wrist-camera data is only 27% of the pretraining mix, and the authors blame this for weak wrist-camera use 2405.12213 §5. The authors also report that adding proprioception made pretrained policies worse 2405.12213 app. E.

Memory-augmented VLA

Two cards give a VLA memory of its own past. They differ in what is kept.

Learned keyframes (EventVLA). The policy keeps fixed visual anchors (the first frame plus frames at fixed offsets) and a small bounded buffer of frames that a learned head chose to store. EventVLA runs this on a Qwen3-VL-4B backbone in simulation. Its keyframe head predicts, for each of the next 50 action steps, the probability that the frame will be task-critical. Frames above a threshold of 0.55 go into a FIFO buffer of five entries 2606.20092 §3.2 2606.20092 app. B.3. Card: EventVLA: Event-Driven Visual Evidence Memory for Long-Horizon Vision-Language-Action Policies.

Use this variant when the information needed for a decision appears only briefly. On the authors' RoboTwin-MeM benchmark, anchors alone reach 18.0% and anchors plus keyframe memory reach 75.2% 2606.20092 tab. 2 2606.20092 tab. 4. On the authors' real bimanual tasks, the figure is 78.8% 2606.20092 §5.3. The paper's real-robot numbers come from code that is not released, so they cannot be reproduced from the repository (see Contradictions).

Two memories, short video and long text (MEM). MEM is built on the pi0.6 VLA. Its short-horizon memory is a video encoder. Each frame is patchified and passed through a ViT whose every fourth layer also attends causally across time, with no new learnable parameters. Past-frame tokens are dropped in the upper layers, so the backbone sees as many tokens as a single-frame VLA 2603.03596 §3.3 2603.03596 fig. 3. Its long-horizon memory is a short text summary. A high-level policy rewrites it from its previous summary, and the training labels come from an LLM that compresses subtask histories 2603.03596 §3.1 2603.03596 §3.2. The authors say a failed attempt does not change the memory until the subtask succeeds [arxiv:2603.03596 §4.1]. Card: MEM: Multi-Scale Embodied Memory for Vision Language Action Models.

The authors report tasks of up to about 15 minutes on real robots, and that the full model is the only one strong across all tested memory capabilities 2603.03596 §4.1 2603.03596 §4.3. Their two core memory-task numbers are set against a pi0.6 baseline without memory: a hidden-item search at 25% (chance) and two-scoop coffee at 50% (chance) 2603.03596 §4.3. MEM's own values for these tasks are only in a figure. Naive concatenated instructions do worse than learned summaries on retried subtasks 2603.03596 §4.1.

Joint video-action VLA (DiT4DiT)

DiT4DiT couples a video diffusion transformer with an action diffusion transformer and trains both with flow-matching losses. The video model is Cosmos-Predict2.5-2B. The action model is adapted from GR00T-N1 [arxiv:2603.10448 §4.2]. The action head reads hidden features from one block of the video model at a fixed flow timestep. Control therefore does not generate frames [arxiv:2603.10448 §4.2] 2603.10448 §4.4. The authors use layer 18 and a single denoising step for those features 2603.10448 app. A.1 2603.10448 §5.4. Card: DiT4DiT: Jointly Modeling Video Dynamics and Actions for Generalizable Robot Control.

On LIBERO, a model trained from scratch on that benchmark's action data reaches 98.6% average success. The authors' RoboCasa-GR1 table gives 50.8% over 24 tasks, against 41.8% for GR00T-N1.5 and 36.2% for a VLM-based baseline that uses the same action head 2603.10448 tab. 1 2603.10448 tab. 2. Those baselines are not all trained the same way, see Contradictions. The authors report 6 Hz control on one A100, against 9 Hz and 13 Hz for their two comparison models 2603.10448 tab. 3.

Vision-language model with a diffusion expert and sub-step text (DexVLA)

DexVLA pairs a Qwen2-VL-2B vision-language model with a separate action expert of about 1B parameters. The expert is a diffusion transformer with 32 blocks, width 1280 and 16 heads 2502.05855 §3.1 2502.05855 app. C.3. The VLM also writes short sub-step text as an extra output. Its next-token loss is added to the expert's diffusion loss with weight 1 2502.05855 §3.1. The authors train in three stages. Stage 1 trains only the expert, on cross-embodiment data of about 100 hours, with its own ResNet-50 and DistilBERT encoders. Stage 2 aligns the model with one embodiment. Stage 3 adapts it to a task 2502.05855 §3.2 2502.05855 app. C.4. Card: DexVLA: Vision-Language Model with Plug-In Diffusion Expert for General Robot Control.

The authors report 0.92 on shirt folding without task-specific training, and 0.4 on laundry folding against 0.2 for pi0 under direct prompting, with 10 trials per task 2502.05855 §4.1 2502.05855 §4.3. Without stage 3, laundry folding drops to 0 2502.05855 §4.4. The LIBERO average of 97.3 uses stage-1 weights only. pi0 reaches 97.1 on the same three suites 2502.05855 app. A.2. On bussing a table, the implicit sub-steps score 0.70, against 0.58 for SayCan as the sub-step source 2502.05855 app. D.2. The sub-step labels came from Grounding-DINO, DINOv2 and Gemini 2.0, and they are not released 2502.05855 app. C.2.

Use this variant for long, multi-stage tasks where you can afford sub-step annotation and three training stages. The released repository carries a non-commercial licence, so do not reuse its code in commercial work, and implement from the paper instead LICENSE. The paper's 60 Hz speed claim does not say what was timed 2502.05855 §1.

Reasoning and movement plan before each action (Emma-X)

Emma-X fine-tunes the 7B OpenVLA on BridgeData V2 demonstrations that were relabelled with Gemini 1.5 Pro 2412.11974 §3.2 2412.11974 §4.1. Each trajectory is cut into segments where a clustering label or the gripper state changes 2412.11974 §3.1. Gemini sees the images of one segment and returns a subtask and a justification for it 2412.11974 §3.2. The authors label segments rather than single frames, because per-frame labels were noisy in their experiments 2412.11974 §3.1. For each frame, the target text holds the segment's reasoning and subtask, the gripper position at the start of the next segment, and a text movement plan toward it. The action tokens come last 2412.11974 §3.2 2412.11974 §3.3. Card: Emma-X: An Embodied Multimodal Action Model with Grounded Chain of Thought and Look-ahead Spatial Reasoning. See also chain of thought.

On 12 real WidowX tasks with 10 trials each, the authors report 57.5% success and 71.66% half-success, against 33.33% and 45.41% for OpenVLA 2412.11974 tab. 1. The largest gain is on spatial-relation tasks, which the authors put at 35% over OpenVLA in half-success 2412.11974 §4.4. On six prompts in the ablation, removing the movement plan drops spatial-relation success from 70 to 37, and removing the next gripper position drops it to 30 [arxiv:2412.11974 tab. 2]. Those ablation prompts are not the 12 tasks of Table 1.

Use this variant when a wrong target position is the failure you need to fix, and the model can afford many more output tokens per step than OpenVLA. The authors say it writes about ten times as many tokens per step, which raises latency 2412.11974 Limitations. Reproduce the labelling pipeline with care: the released script samples Gemini at temperature 1.5 with no seed, so the reasoning text is not reproducible generate_plans.py (see Contradictions).

Flow-matching humanoid VLA with latent-action pretraining (GR00T N1)

GR00T N1 splits the model into two parts. A vision-language backbone (Eagle-2) reads the images and instruction, and in the released 2.2B model its layer 12 supplies the features. A diffusion transformer attends to those tokens and predicts a chunk of 16 actions 2503.14734 §2.1. The action head is trained with flow matching and sampled with four Euler steps. Sampling 16 actions takes 63.9 ms on one L40 in bf16 2503.14734 §2.1. Each embodiment has its own state and action encoders and decoders, so one transformer serves several bodies 2503.14734 §2.1. Videos with no motor commands are used through latent actions from a VQ-VAE, and through generated neural trajectories labelled by an inverse dynamics model 2503.14734 §2.2 2503.14734 §3.2. Card: GR00T N1: An Open Foundation Model for Generalist Humanoid Robots.

With 10% of the post-training data on a real GR-1 humanoid, the authors report 42.6% average success, against 10.2% for Diffusion Policy. With the full data, the figures are 76.8% and 46.4% 2503.14734 tab. 3. Across three simulation suites, the headline average is 45.0%, against 33.4% for Diffusion Policy 2503.14734 tab. 2. Neural trajectories added as co-training data give +5.8 points averaged over eight real tasks 2503.14734 §4.4.

Use this variant when the target robot has little demonstration data and you can use large-scale pretraining. The authors report about 50,000 H100 GPU hours for pretraining 2503.14734 §2.3. For fine-tuning on a single A6000, they give a batch of up to 200 when only the adapter layers and the DiT are trained, and up to 16 when the vision encoder is also tuned [arxiv:2503.14734 §2.3].

Training-time chunk conditioning for real-time chunking (training-time RTC)

This variant changes the training of a flow-matching policy, not its architecture. Real-time chunking keeps consecutive action chunks continuous by fixing the first actions of a new chunk to the ones the robot has committed to. The inference-time version does this by guidance that needs backpropagation at every denoising step 2512.05964 §4. The training-time version simulates the inference delay during training. It gives the committed prefix as clean actions with flow timestep 1, and computes the loss only on the postfix 2512.05964 §4 2512.05964 alg. 1. It needs a flow timestep for each action position, which the authors implement with adaLN-zero conditioning in a diffusion transformer 2512.05964 §4 2512.05964 fig. 2. Card: Training-Time Action Conditioning for Efficient Real-Time Chunking. See also action chunking.

In simulated Kinetix, the authors report that it beats the inference-time version once the delay is 2 steps or more, and that the gap grows with delay 2512.05964 §5.1 2512.05964 fig. 3. At delays of 0 or 1 it is slightly lower, which the authors attribute to fewer supervised first actions 2512.05964 §5.1. With the pi0.6 base model on box building and espresso, success and speed are about the same as the inference-time version. The average latency falls from 135 ms to 108 ms 2512.05964 §5.2. The real-robot evidence is two tasks and a figure 2512.05964 fig. 5.

Multi-horizon action head (Mixture of Horizons)

Mixture of Horizons (MoH) is a plug-in for an existing action head. Instead of predicting one chunk length, the head predicts several, each the prefix of the same ground-truth chunk 2511.19433 §3.2. The candidates run in one batched pass over a shared observation encoding. A per-step softmax gate, which ignores any horizon too short for that step, fuses them 2511.19433 §3.2 2511.19433 fig. 3. A balance loss stops the gate from collapsing onto one length 2511.19433 §3.2. The paper's default is a maximum horizon of 30 with candidates every three steps 2511.19433 §4.1. Card: Mixture of Horizons in Action Chunking. See also action chunking.

The method applies to flow-matching heads and to one-step heads, which the paper treats as separate loss types 2511.19433 §3.1. On the LIBERO average, the authors report gains of 1.1 to 1.3 points on four base models. The pi0.5 base goes from 97.7 to 99.0 2511.19433 tab. 1. These are single-seed LIBERO differences. RoboCasa is the only setting with reported seed spread 2511.19433 tab. 2. The paper also describes a dynamic-inference rule that uses disagreement between horizons to choose how many steps to run. The sweep is only plotted, not tabulated 2511.19433 §4.4 2511.19433 fig. 6.

The authors call the extra compute negligible 2511.19433 §1. The released JAX model repeats the KV cache once per horizon along the batch dimension pi0_moh.py, so the cost depends on the model and hardware. Measure it on your own setup.

Runtime failure detection without failure data (VLA-FAIL)

VLA-FAIL is a detector for a finetuned VLA, not a new policy. It needs no failure rollouts and no extra model. It combines two scores, and an alarm fires when either passes its own threshold 2606.21386 §3.3. LLMD is the maximum over action tokens of the Mahalanobis distance of last-layer features, computed with one fixed prior noise sample 2606.21386 §3.1. ACC measures how far the unexecuted part of the previous chunk is from the start of the new chunk, scaled by motion speed and smoothed over time 2606.21386 §3.2. Card: VLA-FAIL, a detector for finetuned VLAs.

The authors report added latency of +2.2% on X-VLA and +1.3% on pi0.5 on an RTX 5090 2606.21386 tab. 3. On the Libero-Plus average, their method reaches 0.94 PR and 0.18 PDT on X-VLA and 0.72 PR and 0.47 PDT on pi0.5 2606.21386 tab. 2. These are threshold-independent metrics with higher PR and lower PDT better. The threshold-based results are in an appendix 2606.21386 app. D. LLMD also needs one pass over the finetuning data before deployment 2606.21386 §6, and ACC needs receding-horizon control with overlapping chunks 2606.21386 §6 2606.21386 app. B.

Runtime supervision with evolved critics and recovery (Zetta)

Zetta keeps a frozen VLA and wraps it in runtime critics and recovery skills. These are written as code and evolved from rollout failures. A critic proposes an intervention, and an orchestrator approves it 2608.16590 §2.1. The base policies are pi0.5 on LIBERO-Pro and GR00T N1.5 on RoboCasa [arxiv:2608.16590 §4.1]. Card: Zetta: An Efficient Closed-Loop Embodied Harness for Self-Evolving Physical Intelligence.

The authors report macro success on 18 RoboCasa tasks rising from 73.56% to 93.56%, and on 40 LIBERO-Pro task-setting pairs rising from 32.00% to 71.13% 2608.16590 tab. 2 2608.16590 tab. 3. These come from their own simulated runs. The method requires a simulator that can replay a rollout from its seed, because it validates each change on held-out seeds [arxiv:2608.16590 §4.1]. Use it only where that holds.

Subtask backtracking with a VLM check and MBR retries (CycleVLA)

CycleVLA adds two scalar outputs to the action head of a VLA: a stop signal and a progress value for the current subtask 2601.02295 §4.1. The training demonstrations are split into subtasks, using an LLM and the gripper and motion signals in the robot data 2601.02295 §4.1 2601.02295 app. B. At inference, once progress reaches 0.9, a VLM decides whether to move on or to rewind to an earlier subtask. Each subtask may be retried up to three times 2601.02295 §5.1 2601.02295 app. D. A retry draws eight action chunks from the same observation and runs the one with the smallest average distance to the others 2601.02295 §4.2 2601.02295 eq. 4. Card: CycleVLA: Proactive Self-Correcting Vision-Language-Action Models via Subtask Backtracking and Minimum Bayes Risk Decoding.

The authors report average success on LIBERO-Plus rising from 65.0% to 86.0% for the pi0.5 backbone, and on LIBERO from 96.9% to 98.5% [arxiv:2601.02295 tab. 1] 2601.02295 tab. 2. On LIBERO, replacing the MBR choice with a random retry lowers the OFT-Diff variant from 95.3% to 92.5% [arxiv:2601.02295 tab. 6]. Their real-robot tests use one arm, three tasks and 15 trials per setting, and report about 80% correction of injected single errors 2601.02295 §6.2.

Each retry costs eight extra policy passes, and the authors put the added parts at about 30% on top of the base rollout 2601.02295 app. D. The method assumes that robot states can be reversed and does not reset objects, so an irreversible event can make a retry impossible 2601.02295 §4.2 2601.02295 §7. The stop and progress outputs need subtask labels in the training data 2601.02295 §4.1.

Scene-graph planning from human video with a dual-head VLA (GF-VLA)

GF-VLA learns a dual-arm block-assembly policy from one human RGB-D video. It segments the hands and objects, and takes the position of each over time. For each position signal it computes a sliding-window entropy, and for each hand and object pair a mutual information 2508.05342 §3.1. Thresholds on mutual information and distance turn these signals into hand-object and object-object edges, typed as coupled motion, docked, efficient or transitory 2508.05342 §3.2.1 2508.05342 §3.2.2. The result is a scene graph per frame. Card: Information-Theoretic Graph Fusion with Vision-Language-Action Model for Policy Reasoning and Dual Robotic Control.

The graph feeds a VLA with two heads on one LLaMA 2 7B model, each with its own LoRA adapter 2508.05342 §4.2 2508.05342 §4.4. The LLM head writes a behaviour tree once per task. Each node holds an action, its parameters, a reason and a verification condition 2508.05342 §4.3. The action head outputs Cartesian poses and gripper states at 5 Hz, for both arms 2508.05342 §4.2. The authors say the LLM head verifies subtasks and replans locally when one fails 2508.05342 §4.1 2508.05342 §5.2.

The authors report 0.94 grasp success and 0.89 placement success over 120 evaluated block trials 2508.05342 tab. 1. A policy trained from one "R" demonstration reaches 0.90 transfer success over six letter and tower variants 2508.05342 tab. 3. In the ablation, removing the scene graph drops the letter transfer score from 0.88 to 0.48 2508.05342 tab. 2. These are author-reported, and the baseline table reports only transfer success, with no spread 2508.05342 tab. 4.

Use this variant when the task is multi-step bimanual assembly, the plan must be readable, and the only demonstration available is a human video. The authors also assume a calibrated camera-arm alignment and a static workspace 2508.05342 §7. Instruction planning takes 7.56 s on average, separate from the 5 Hz control stream 2508.05342 §4.4. No official code was found, and several values needed to rebuild the graph and the LoRA setup are not stated (see Pitfalls on the card) 2508.05342 §3.2.1 2508.05342 §4.4.

Evaluating VLA rollouts for temporal safety

This is a benchmark, not a model. SafeManip checks recorded manipulation rollouts against eight categories of temporal safety rules, written in LTLf and grounded in simulator state. Each rule is compiled to an automaton and replayed over the trace. Violations are normalised per triggered event, not per rollout 2605.12386 §3.3 2605.12386 §4.2. Card: SafeManip: A Property-Driven Benchmark for Temporal Safety Evaluation in Robotic Manipulation.

Use this variant to compare VLA policies on more than task success. The authors report that on LIBERO, success and violations per event are strongly anti- correlated (r = −0.99, seven policies). On RoboCasa365 the correlation is positive but not significant with five policies 2605.12386 §5.1. The authors also report that, on LIBERO, OpenVLA's worst category is collision [arxiv:2605.12386 §5.2]. The monitor replays traces offline, although the introduction calls it online 2605.12386 §1 2605.12386 app. F.

Distributed real-robot pairwise evaluation (RoboArena)

RoboArena ranks generalist policies from many double-blind, head-to-head real-robot trials. Evaluators at several institutions choose their own scenes and tasks, and each trial ends with a preference and a short reason. The ranking is a task-aware Bradley-Terry model with latent task buckets, fit by EM 2506.18123 §3.2. The paper reports 612 pairwise comparisons, and a ranking closer to an exhaustive oracle than the standard DROID protocol. Under simulated drift the Pearson correlation with the oracle is 0.838, against 0.692 for the standard protocol 2506.18123 §1 2506.18123 tab. 2. The authors say the ranking converges within about 100 comparisons [arxiv:2506.18123 §5.3]. The seven-policy pool uses the DROID platform and the openpi implementation 2506.18123 §4 2506.18123 §5.1. Card: RoboArena: Distributed Real-World Evaluation of Generalist Robot Policies.

Frozen vision-language encoder with text-aware token selection (OTTER)

OTTER keeps CLIP frozen. For each camera, it takes CLIP's last attention output and scores every patch against every instruction token. A softmax over patches gives each word its own weighted visual vector, with a learnable temperature 2503.03734 §3.1. A learned pooling step and a causal transformer then predict chunks of 10-D delta end-effector actions 2503.03734 §3.2. Card: OTTER: A Vision-Language-Action Model with Text-Aware Visual Feature Extraction.

Author-reported: on 70 unseen real pick-and-place trials, OTTER reaches 62%, against 9% for fine-tuned OpenVLA and 12% for fine-tuned Octo. Fine-tuning CLIP instead of freezing it drops unseen success to 15% 2503.03734 §5.1 2503.03734 §5.3. The paper's 50 Hz claim assumes CLIP features are cached at inference, which the card reads as absent from the released PyTorch code 2503.03734 app. B.1. The card also reads that code as failing to build the model as cloned, because a loss field it reads is not defined. The paper does not name its loss 2503.03734 §3.2.

Use this variant when the robot must handle objects and scenes it was not trained on, and you want to keep the VLM's image-text alignment.

Joint video-action VLA from a video generator (VideoVLA)

VideoVLA starts from CogVideoX-5B, a video diffusion transformer, and denoises future video latents and a 6-step, 7-D action chunk in one joint process 2512.06963 §3.2 2512.06963 §4.1. Only the first three actions are executed, then the model is queried again 2512.06963 §4.1. Unlike the DiT4DiT variant above, which reads features from one block at a fixed step and does not generate frames 2603.10448 §4.4, this variant denoises the video latents themselves. Card: VideoVLA: Video Generators Can Be Generalizable Robot Manipulators.

Author-reported: SIMPLER average over 12 tasks is 63.0, against 62.6 for CogACT. Novel-object pick-up reaches 65.2, against 42.4 for CogACT, and new skills reach 48.6, against 20.4 2512.06963 tab. 1 [arxiv:2512.06963 tab. 2] 2512.06963 tab. 3. The in-domain gap is within noise at 24 trials per WidowX task 2512.06963 app. A. Without the video loss, the generalization columns fall to 12.7 and 4.4 2512.06963 tab. 9. Training from scratch instead of from CogVideoX drops the average to 12.6 2512.06963 tab. 7.

Use this variant when a video generator is available and control at a few hertz is acceptable. The authors report about 1.1 s per chunk with 10 steps on one H100. The repository's default is 50 steps, which is slower 2512.06963 app. D.

Auxiliary motion-prediction head (motion-image diffusion)

This variant adds a second diffusion transformer to a pi-series VLA, pi0 or pi0.5. The second head predicts optical-flow images of the next second. Both heads train with the same flow-matching loss, and only the action head runs at inference 2512.18007 §3.2 2512.18007 §1. Targets are RAFT flow between two frames, mapped to colour and encoded by a frozen SDXL-VAE 2512.18007 app. A.1 2512.18007 app. A.2. Card: Robotic VLA Benefits from Joint Learning with Motion Image Diffusion.

Author-reported: LIBERO average 97.5% for pi0.5, against 96.9%, and 94.7% for pi0, against 94.2% 2512.18007 tab. 1. On RoboTwin easy mode the pi0 average is 58.0%, against 45.1% 2512.18007 tab. 2. On the hard mode the gains are small, and the text's claim of consistent hard-mode gains does not match the table 2512.18007 §4.3 2512.18007 tab. 2. Future RGB frames as the auxiliary target give 95.7 on LIBERO with pi0.5, against 97.5 for motion images 2512.18007 tab. 3. The real-robot test is three tasks at 43% average 2512.18007 §4.5. The paper reports no seeds or confidence intervals for its sims. No code is released.

Runtime supervisor that checks and corrects actions (FPC-VLA)

FPC-VLA queries a supervisor only when the gripper state changes by more than a threshold. The supervisor is a Qwen2.5-VL 7B model that answers Yes or No. A No reply adds a directional correction to the translation and yaw components of the action 2509.04018 §3.5 2509.04018 alg. 2. The supervisor is trained with LoRA on failure-correction question-answer pairs, generated from robot data and annotated from simulation and teleoperation 2509.04018 §3.4 2509.04018 §4.1. A dual-stream fusion averages recent action predictions. Poses are weighted by cosine similarity and time decay, and the gripper by time decay alone 2509.04018 §3.3. Card: FPC-VLA: A Vision-Language-Action Framework with a Supervisor for Failure Prediction and Correction.

Author-reported: SIMPLER WidowX task average 64.6% against 51.8% for CogACT, and real-robot task average 86.0% against 78.4% 2509.04018 tab. 3 2509.04018 tab. 6. In a four-task ablation, the task average is 82.1 with the supervisor and 74.4 without it 2509.04018 tab. 7. The text's drops of 31.3% and 16% do not match the table, which gives about 31.7% and 19.5% 2509.04018 §4.6 2509.04018 tab. 7. With the stated constants the similarity term moves the pose weights by about 10% at most (our arithmetic from 2509.04018 eq. 8 and 2509.04018 §4.1).

Use this variant when failures cluster at grasp and release moments, and a second model call at each such moment is affordable. The authors report 0.176 s per non-keyframe step and 1.766 s per keyframe, on unstated hardware 2509.04018 §4.1. Slips after a successful grasp are not covered 2509.04018 §6. No official code was found.

Policy trained inside a learned world model (RoboScape-R)

RoboScape-R trains a policy with reinforcement learning inside a learned video model rather than a simulator. An action model predicts the next frame from the policy's actions, and a text model imagines a goal frame from the instruction 2512.03556 §3.1. The reward is the sum of a sparse term, set when the predicted done signal passes a threshold, and a dense term, the LPIPS distance to the goal frame 2512.03556 eq. 5 2512.03556 eq. 7. Any RL algorithm can consume the rollouts, and the paper uses PPO [arxiv:2512.03556 §3.2] 2512.03556 §4.3. Card: RoboScape-R: Unified Reward-Observation World Models for Generalizable Robotics Training via RL.

Author-reported: out-of-domain pick-and-place with OpenVLA reaches 84.1% when trained with the world-model reward, against 54.5% with the simulator reward 2512.03556 tab. 1. In-domain differences are at most 3.0 points, and the table has no seeds or error bars 2512.03556 tab. 1. Every evaluation runs in ManiSkill, and no real-robot test is reported 2512.03556 §5. World-model training took about 96 hours on an H20 cluster 2512.03556 §4.2.

Use this variant when a per-task reward is hard to write but video data exists to train the world model. The LPIPS term is a distance, and the paper does not say how its sign is handled 2512.03556 §3.1 2512.03556 alg. 1.

Search over imagined futures (STORM)

STORM runs Monte Carlo tree search around a diffusion VLA at each step. The VLA proposes 8 candidate actions with priors. A video world model, iVideoGPT-medium fine-tuned on Bridge with a reward head, imagines the outcome of each candidate. The most-visited root action is executed 2512.18477 §3 [arxiv:2512.18477 alg. 1] 2512.18477 eq. 5. The paper uses 8 simulations per decision, planning depth 3 and discount 0.9 2512.18477 §4.1. Card: STORM: Search-Guided Generative World Models for Robotic Manipulation.

Author-reported: 51.0% average on four SimplerEnv WidowX tasks, against 47.9% for CogACT, a gain of 3.1 points that the authors call numerically modest 2512.18477 tab. 1 2512.18477 §4.3. The paper reports no seeds or variance. The value of a depth-3 rollout is not defined [arxiv:2512.18477 §3.3], and no latency is given 2512.18477 §5.

Use this variant when a reactive policy keeps repeating one failed action and the budget allows many world-model calls per step. It is not a fit for latency-critical control.

Dual-system navigation VLA (DualVLN)

DualVLN is a navigation policy, not an arm controller. System 2 is a Qwen2.5-VL 7B planner. It outputs a pixel goal or a view-adjustment action. System 1 is a 384-wide diffusion transformer that outputs a 32-waypoint trajectory, with four latent tokens from System 2's last hidden layer and 32 visual memory tokens as conditions 2512.08186 §3.1 2512.08186 §3.2 [arxiv:2512.08186 §3.3]. The two run asynchronously. System 1 uses the latent goal from an earlier System 2 step together with the newest frame 2512.08186 §3.2. Card: Ground Slow, Move Fast: A Dual-System Foundation Model for Generalizable Vision-and-Language Navigation.

Author-reported: 64.3 success on R2R-CE val-unseen with RGB only, against 56.9 for StreamVLN 2512.08186 tab. 1. On VLN-PE val-unseen, without training on VLN-PE, it reaches 51.60, against 22.42 for NaVid 2512.08186 tab. 2. The authors report 0.7 s per System 2 output and 0.03 s per System 1 call, on an RTX 4090 2512.08186 §5.2. The released code multiplies x and y by 4 at data preparation and divides them at inference. The paper does not mention this, so a reimplementation that skips it gets trajectories of the wrong length 2512.08186 §3.2.

Use this variant when a navigation agent must avoid moving obstacles in real time, and a slow VLM planner can run now and then.

Cross-embodiment data augmentation (OXE-AugE)

This variant keeps the demonstrations and changes the robot in them. AugE-Toolkit masks the source arm in each frame with a fused SAM2 and simulation mask, inpaints the background, and replays the same trajectory on a simulated target arm 2512.13100 §4.2. Applied to 16 Open X-Embodiment datasets, it adds up to nine target robots and yields over 4.4 million trajectories 2512.13100 §6 2512.13100 app. A.2. Card: OXE-AugE: A Large-Scale Robot Augmentation of OXE for Scaling Cross-Embodiment Policy Learning.

Author-reported: fine-tuning OpenVLA-OFT and pi0 on the augmented data raises the average partial score on unseen gripper pairs by 24% and 45%, against Bridge data alone 2512.13100 §6.2. The scores are partial, from 0.3 to 1.0, and the text does not say whether the 24% and 45% are absolute or relative 2512.13100 app. A.5. Diffusion-based augmentation of the same images lowered policy performance by 27 to 30% in the authors' test 2512.13100 §6.2. The method assumes similar grippers and known frame transforms 2512.13100 §3.

Fine-tuning data from per-task RL experts (RLDG)

This variant changes where the fine-tuning data comes from. For each task, a reinforcement-learning expert is trained on the real robot with HIL-SERL, starting from 20 demonstrations and running until its success rate reaches 100% 2412.09858 §3.1 2412.09858 app. B. The successful rollouts of each converged expert are the dataset. OpenVLA (with LoRA) or Octo is then fine-tuned on them with a supervised action log-likelihood loss, not with RL 2412.09858 §3.2 2412.09858 §3.3. The reward is a binary success classifier trained on teleoperated positive and negative examples [arxiv:2412.09858 app. B]. For a multi-stage task, the expert covers only the critical phase and human demonstrations cover the rest 2412.09858 §3.2. Card: RLDG: Robotic Generalist Policy Distillation via Reinforcement Learning. See also imitation learning and knowledge distillation.

Against fine-tuning on the same number of successful human-demonstration episodes, the authors report 10% to 37% higher success on precise insertion tasks 2412.09858 §4.2 2412.09858 fig. 4. On unseen connectors, OpenVLA trained on RLDG data succeeds 73 times in 80, against 49 in 80 for the best single-connector RL policy 2412.09858 §4.3. Most conditions use 20 trials and the paper reports no error bars 2412.09858 §4.2.

Use this variant when human teleoperation is slow or uneven in quality, the task has a success signal you can learn, and each task can afford 1 to 3 hours of real-robot RL 2412.09858 app. B. The paper names reward specification for new tasks as its main limitation 2412.09858 §6. The repository releases only the RL-expert stage. Generalist fine-tuning and data collection are marked "Coming soon" README.md, so the distillation step must be implemented from the paper.

Game-playing generalist agent (SIMA 2)

SIMA 2 is a Gemini Flash-Lite agent that plays 3D games from 720p frames. It outputs keyboard keys, mouse clicks, relative mouse moves and text 2512.04797 §3.2 2512.04797 §3.3. It is trained first by supervised fine-tuning on human play, Gemini-written reasoning and dialogue, then by RL on verifiable tasks 2512.04797 §3.3. A self-improvement loop has Gemini propose tasks and score the trajectories from 0 to 100, with 50 as success 2512.04797 §4.5. Card: SIMA 2: A Generalist Embodied Agent for Virtual Worlds.

Author-reported: about twice SIMA 1's average success on the training games, with the values only in a figure 2512.04797 §4.2.1 2512.04797 fig. 6. On held-out ASKA and MineDojo, success is more than 10% higher 2512.04797 §4.2.2. The paper calls its capability losses on code, math and STEM minor, but its table shows -25.5% on AIME after SFT 2512.04797 §4.3 2512.04797 tab. 1. No code is released, the base model is closed, and the RL settings are not stated 2512.04797 §3.3. Treat the paper as a description of the approach, not a recipe.

When to use which

Before you copy any number from a card, read its Paper vs code section. Several cards list released-code settings that differ from the paper, for example the OpenVLA fine-tuning learning rate, the EventVLA keyframe loss weight and the DiT4DiT feature path (see Contradictions).

Implementation sketch

The common core is the same for the discrete-token policies: encode the observation, predict action tokens, decode them to continuous actions. The memory variants add a buffer and a write rule. The OpenVLA tokenizer is shown, with the EventVLA buffer marked where it differs 2406.09246 §3.2 2606.20092 §3.2.

# Discretise one action dimension into 256 bins over the 1st-99th percentile
# [arxiv:2406.09246 §3.2]
def action_to_token(action, low, high, bins=256):
    scaled = clip(2 * (action - low) / (high - low) - 1, -1, 1)
    return digitize(scaled, edges(bins))     # ids 1..256, one per dimension

# Predict action tokens autoregressively from image, instruction and any
# memory frames  [arxiv:2406.09246 §3.2] [arxiv:2606.20092 eq. 4]
def act(images, instruction, memory):
    tokens = vla_model(images, instruction, memory)   # (7,) action token ids
    return decode_to_bin_centres(tokens)              # (7,) normalised

# Memory variant only: store the frame if a learned head is confident
# [arxiv:2606.20092 §3.2] [arxiv:2606.20092 app. B.3]
def maybe_store(memory, frame, keyframe_prob, tau=0.55, n_max=5):
    if keyframe_prob >= tau:                          # tau = 0.55 in the paper
        memory.append(frame)
        if len(memory) > n_max:                       # FIFO, N_max = 5
            memory.pop(0)
    return memory

The flow-matching variants differ in the loss. In training-time chunk conditioning, the committed prefix gets timestep 1 and the loss covers only the postfix 2512.05964 alg. 1. The sampler overwrites the prefix at every denoising step 2512.05964 alg. 1. VLA-FAIL needs no change to the policy. It reads features at one flow timestep and compares overlapping chunks 2606.21386 §3.1 2606.21386 §3.2. MoH keeps the per-horizon flow-matching loss and adds a gate-weighted fused loss and a balance term 2511.19433 §3.2. CycleVLA's subtask retry uses a separate selection step: it keeps the chunk with the smallest average distance to the others 2601.02295 eq. 4.

The heads that the new variants use differ mainly in the loss. OFT trains a continuous head with an L1 loss on the whole chunk, and reads it out from one forward pass over empty action slots 2502.19645 §4.2. Octo uses a noise-prediction diffusion loss with a cosine schedule 2405.12213 §3.3. DexVLA's paper does not state its diffusion schedule or prediction target 2502.05855 §3.1. GR00T N1's paper uses signs that do not agree with each other in its interpolation, regression target and Euler update. The released code of a later release uses one consistent convention, with the noisy sample as a blend of noise and actions and a velocity of actions minus noise. Check any implementation on a toy example before training 2503.14734 §2.1 gr00t_n1d7.py.

Training is next-token cross-entropy on the action tokens in OpenVLA 2406.09246 §3.2. EventVLA adds a keyframe loss with a weight λ 2606.20092 §3.3. DiT4DiT trains two diffusion models jointly, with a scalar weight on the video loss that its paper does not give [arxiv:2603.10448 §4.3]. The variant pages cite each paper's own settings, which are author-reported.

Contradictions

The benchmarks overlap only partly. The first point below is a case where two papers report the same per-suite numbers and average them differently. The other points are where a paper's numbers, or its paper and code, do not line up.

• LIBERO averages across papers. OFT and DexVLA report the same per-suite values for OpenVLA (84.7, 88.4 and 79.2 on Spatial, Object and Goal) and for pi0 (96.8, 98.8 and 95.8) 2502.19645 tab. 1 [arxiv:2502.05855 app. A.2]. OFT averages four suites, including Long, and gets 76.5 for OpenVLA and 94.2 for pi0. DexVLA averages the three suites and gets 84.1 and 97.1. Compare LIBERO averages only when the suite set is the same.

• Latency. OpenVLA reports about 6 Hz on one RTX 4090 [arxiv:2406.09246 §3.5]. EventVLA reports 0.42 s per chunk on an A100 [arxiv:2606.20092 tab. 11]. DiT4DiT reports 6 Hz on one A100 in its efficiency table [arxiv:2603.10448 tab. 3], but its appendix says the real-robot inference ran on an RTX 4090 2603.10448 app. A.3. OFT measures OpenVLA at 4.2 Hz on one A100 2502.19645 tab. 2, against about 6 Hz on an RTX 4090 in the OpenVLA paper. The units and hardware differ, so these are not comparable.

• Headline gains. OpenVLA's 16.5-point gain over RT-2-X reproduces only when rollouts are pooled. Averaging per-task rates gives a 14.5-point gap 2406.09246 §1 2406.09246 app. B.1.3. EventVLA's "+40%" average gain does not appear in any of its tables and is computed from them, not stated by the authors 2606.20092 tab. 1 2606.20092 tab. 2.

• Released code vs paper. EventVLA's paper gives a keyframe loss weight of 0.1 2606.20092 tab. 7, while its released sim config uses 1.0 eventvla_robotwin_mem.yaml. Its real-robot code is not released 2606.20092 §5.3. OpenVLA's paper gives no fine-tuning learning rate, and the released script defaults to 5e-4 finetune.py.

• Joint training gradient (DiT4DiT). Algorithm 1 updates both diffusion models from the total loss, so the action loss reaches the video model 2603.10448 alg. 1 2603.10448 §4.3. The released code detaches the features, so the video model is trained only by its own loss [code: DiT4DiT/model/modules/vlm/Cosmos25.py#L162]. The paper and code are not the same training method.

• Baselines in DiT4DiT's tables. GR00T-N1.5 and N1.6 are fine-tuned from pretrained weights, while DiT4DiT and Qwen3DiT are trained from scratch 2603.10448 tab. 2. The comparison is not like-for-like.

• Feature timestep (DiT4DiT). The paper calls the feature timestep fixed 2603.10448 §4.3 2603.10448 §4.4. Its Algorithm 1 samples it per step 2603.10448 alg. 1, and the code uses the first step of a schedule Cosmos25.py.

• Memory horizon (MEM). The post-training horizon is 54 s in one place and "up to 1 minute" in another 2603.03596 §3.4 2603.03596 §4.3.

• Abstract vs body (Zetta). The abstract and introduction give 90.8% on LIBERO-Pro. The body gives 71.13% as the macro average over 40 pairs 2608.16590 tab. 3 2608.16590 §4.4. No table or sentence in the body supports 90.8%. The paper also gives two hardware setups, 8 RTX 4090 in §4.1 and 8 A100 in §4.6 2608.16590 §4.1 2608.16590 §4.6.

• Live leaderboard vs paper (RoboArena). The paper's ranking is the task-aware model 2506.18123 §3.2. The public code runs a plain Bradley-Terry fit with Davidson ties, and its EM routine is marked as disabled central_server.py central_server.py. The public leaderboard therefore does not reproduce the paper's ranking method.

• Window length (GF-VLA). The paper calls the 1 s sliding window 40 frames 2508.05342 §5.1, but 1 s at the stated 30 Hz is 30 frames. The paper does not say which one its runs used.

• Headline claim (GF-VLA). The conclusion says the method halves the 6D pose error against imitation-learning and language-only baselines 2508.05342 §8. No table reports those baselines, so the claim is not supported in the paper 2508.05342 tab. 4.

• Smoothing in VLA-FAIL. The method text says an ACC smoothing weight of 0.9 is required 2606.21386 §3.2. The ablation says a fixed 0.1 was used throughout 2606.21386 app. B, and the hyperparameter tables give 0.9 2606.21386 app. F. The paper does not resolve this.

• Action dimensions (Open X-Embodiment). The paper uses 8 action dimensions with 256 bins each 2310.08864 §4.2. The released code emits 11 tokens, and its inference script builds the model with 512 bins rt1.py rt1_inference_example.py.

• Emergent-skill ratio (RT-2-X). The text says RT-2-X is about 3 times RT-2 on emergent skills 2310.08864 §5.2. The table gives 75.8 against 27.3, about 2.8 times 2310.08864 tab. 2.

• Model size or history (RT-2-X). The text credits the gap between the 55B and 5B models to size 2310.08864 §5.3. The comparison it relies on also changes history, from none to two frames 2310.08864 tab. 2.

• Co-training on this metric. Rows (4) and (7) of the 5B ablation differ only in web co-training. Emergent-skill success is 44.4% with it and 48.7% without it 2310.08864 tab. 2. Check this row before claiming a co-training benefit on this metric.

• Gate noise (MoH). The paper's gate is a linear layer and a softmax 2511.19433 §3.2. The PyTorch forward pass adds learned gate noise during training pi0_pytorch_moh.py. The JAX model has none pi0_moh.py.

• Horizon set and dynamic inference (MoH). The paper's default is the stride-3 set up to 30 2511.19433 §4.1. The JAX config default is [5, 10, ..., 30] pi0moh_config.py and the PyTorch default is [10, 20, 30] config.py. The paper defines disagreement on the final chunk 2511.19433 alg. 1, while the PyTorch sampler sums it over denoising steps pi0_pytorch_moh.py.

• Octo batch size. The paper gives a pretraining batch of 2048 [arxiv:2405.12213 §3.4]. The released pretraining config sets 512, and the training script treats that as a global batch octo_pretrain_config.py train.py. The released config does not reproduce the paper's batch.

• Octo sampler. Eq. 1 adds noise at every denoising step [arxiv:2405.12213 eq. 1]. The released sampler adds none on the last step, and clips every iterate to [-5, 5], which the paper does not mention [code: octo/model/components/action_heads.py#L575] [code: octo/model/components/action_heads.py#L577].

• GR00T N1 release. The repository linked from the paper, at the cited commit, holds GR00T N1.7. That release has a different backbone and an action horizon of 40, not 16 README.md gr00t_n1d7.py. The N1 model code is not in that checkout, so the N1 claims are paper-only.

• GR00T N1 simulation average. The 45.0% average is not the mean of its three suites, which gives 49.5 from 32.1, 66.5 and 50.0 2503.14734 tab. 2. The DexMG score is 66.5% in tab. 2 and 58.5% when averaged from tab. 4 2503.14734 tab. 4.

• DexVLA paper vs code. The paper freezes the VLM's visual encoder in stage 2 2502.05855 §3.2, but the stage-2 script leaves it trainable [code: scripts/train_dexvla_stage2.sh#L32]. The paper gives one output head per robot configuration 2502.05855 §3.1, but the policy head has one output layer modeling_scaledp.py. The paper's Adam beta2 is 0.95 2502.05855 §3.2, while the trainer path the card traced uses 0.98 train_vla.py.

• DexVLA sub-step ablation. The text gives 0.07 for direct prompting of the expert, and 0 for direct prompting in both stages. The table has no row for the second case 2502.05855 app. D.1. Read these numbers with caution.

• Failure-detection scope. VLA-FAIL's authors state it cannot guarantee safety, and that it misses failures whose features and actions both look normal 2606.21386 §6.

• Retry selection (CycleVLA). The paper's MBR rule is the plain average-distance argmin 2601.02295 eq. 4 2601.02295 app. C. The released code runs a density-based rule by default, and keeps the plain rule as an option that is off by default [code: experiments/robot/libero/run_libero_eval_decomposed_progress_mbr.py#L894-L906] run_libero_eval_decomposed_progress_mbr.py. The paper does not say which rule produced its selection tables 2601.02295 tab. 4 2601.02295 tab. 5.

• Confirmation rule (CycleVLA). The paper uses one stop and progress rule for all tasks 2601.02295 app. D. The code applies the stricter rule only to two LIBERO suites, and counts the others cumulatively [code: experiments/robot/libero/run_libero_eval_decomposed_progress_mbr.py#L1052-L1053].

• RLDG headline gain. The abstract's "up to 40%" is not reproduced by the per-task figures, which reach 37% for Octo on connector insertion 2412.09858 §4.2. The introduction's averages of 30% and 50% are not derived in the text 2412.09858 §1.

• RLDG sample-efficiency claim. The introduction says 6 to 10 times less data. The only count the paper gives is 45 RL episodes against 300 demonstrations, about 6.7 times 2412.09858 §4.2 2412.09858 fig. 5. The real-robot time for the RL experts is not counted in the comparison 2412.09858 app. B.

• Emma-X training mix. The paper's output order is reasoning, subtask, gripper target, movement plan and actions 2412.11974 §3.3 2412.11974 app. F. The README's training run uses a config that trains on the movement plan and actions only [code: prismatic/conf/vla.py#L303-L310]. The code does not say which mix produced the released weights.

• Emma-X segmentation. The paper combines HDBSCAN with gripper breakpoints 2412.11974 §3.1. The plan-generation script clusters poses only generate_plans.py.

• Emma-X gripper detector. The paper says OWLv2 and SAM [arxiv:2412.11974 §3.2]. Inference code uses OWL-ViT base [code: experiments/robot/bridge/gripper_position.py#L7], and the Bridge eval prompt leaves out the gripper line [code: experiments/robot/bridge/run_bridgev2_eval.py#L167-L168].

• Emma-X epochs. The paper says 3 epochs 2412.11974 §4.1. The movement_policy config sets 200 vla.py.

• ECoT average (Emma-X). Table 1 prints 28.75 for ECoT's half-success average, while its twelve rows average 29.17 2412.11974 tab. 1.

• CogACT on SIMPLER WidowX. Three cards give three different CogACT numbers for the same four tasks. STORM reports 75.0, 45.9, 12.5 and 58.3, with a mean of 47.9 2512.18477 tab. 1. VideoVLA reports 71.7, 50.8, 15.0 and 67.5, with a WidowX average of 51.3 2512.06963 tab. 1. FPC-VLA reports a WidowX task average of 51.8 2509.04018 tab. 3. On the Google Robot, VideoVLA gives 75.2 and 61.4 for CogACT 2512.06963 tab. 1, and FPC-VLA gives 74.8 and 61.3 2509.04018 tab. 4. Compare SIMPLER numbers only inside one paper's table.

• pi0.5 on LIBERO. The MoH paper's pi0.5 base scores 97.7 2511.19433 tab. 1. The motion-head paper reports 96.9 for pi0.5 2512.18007 tab. 1. The two baselines differ by 0.8 points, so MoH's gain of 1.3 points and the motion head's gain of 0.6 points are not measured against the same number.

• Motion head and the hard mode. The text says the motion head gains in both RoboTwin modes, but its own table gives lower hard-mode scores than pi0 on three tasks 2512.18007 §4.3 2512.18007 tab. 2.

Papers

• OpenVLA: An Open-Source Vision-Language-Action Model: a 7B single-frame VLA with 256-bin action tokens, open weights and LoRA fine-tuning.
• Fine-Tuning Vision-Language-Action Models: Optimizing Speed and Success: a fine-tuning recipe for OpenVLA with parallel decoding, action chunks and an L1 head, plus a FiLM variant for bimanual ALOHA.
• EventVLA: Event-Driven Visual Evidence Memory for Long-Horizon Vision-Language-Action Policies: adds visual anchors and a learned keyframe memory to a VLA for tasks with briefly visible cues.
• Open X-Embodiment: Robotic Learning Datasets and RT-X Models: pools 60 robot datasets from 22 embodiments and trains RT-1-X and RT-2-X on the mixture.
• Octo: An Open-Source Generalist Robot Policy: a transformer trained from scratch on Open X-Embodiment data, with a diffusion action head and finetuning to new sensors and action spaces.
• SafeManip: A Property-Driven Benchmark for Temporal Safety Evaluation in Robotic Manipulation: scores recorded manipulation rollouts for temporal safety, using LTLf rules, and audits seven policies.
• MEM: Multi-Scale Embodied Memory for Vision Language Action Models: adds a short-horizon video encoder and a long-horizon language memory to pi0.6.
• Mixture of Horizons in Action Chunking: trains one action head on several chunk lengths and fuses them with a learned gate.
• Training-Time Action Conditioning for Efficient Real-Time Chunking: simulates inference delay in training, so chunk prefixes need no inference-time guidance.
• CycleVLA: Proactive Self-Correcting Vision-Language-Action Models via Subtask Backtracking and Minimum Bayes Risk Decoding: adds stop and progress outputs to a VLA, and retries earlier subtasks after a VLM check, with MBR-selected chunks.
• DiT4DiT: Jointly Modeling Video Dynamics and Actions for Generalizable Robot Control: couples a video diffusion transformer to an action diffusion transformer, reading the action head from one video block.
• DexVLA: Vision-Language Model with Plug-In Diffusion Expert for General Robot Control: pairs a Qwen2-VL-2B VLM with a diffusion expert, trained in three stages with generated sub-step text.
• GR00T N1: An Open Foundation Model for Generalist Humanoid Robots: a VLM with a flow-matching diffusion transformer for humanoid robots, pretrained on real, simulated, neural and human-video data.
• VLA-FAIL: detects failures from last-layer feature distance and chunk consistency, with no failure data.
• Information-Theoretic Graph Fusion with Vision-Language-Action Model for Policy Reasoning and Dual Robotic Control: builds per-frame scene graphs from one human RGB-D video, and plans with a LoRA-tuned LLaMA 2 7B on a dual-arm robot.
• Zetta: An Efficient Closed-Loop Embodied Harness for Self-Evolving Physical Intelligence: evolves code-based runtime critics and recovery skills around a frozen VLA.
• RoboArena: Distributed Real-World Evaluation of Generalist Robot Policies: ranks generalist policies from distributed, double-blind real-robot pairwise trials.
• A Survey on Robotics with Foundation Models: toward Embodied AI: a taxonomy of LLM and VLM use in robot planning and control, with catalogues of datasets and simulators. No experiments.
• OTTER: A Vision-Language-Action Model with Text-Aware Visual Feature Extraction: keeps CLIP frozen and selects patch features by instruction-word similarity.
• FPC-VLA: A Vision-Language-Action Framework with a Supervisor for Failure Prediction and Correction: adds a VLM supervisor that checks actions at gripper changes, and an action fusion step.
• RoboScape-R: Unified Reward-Observation World Models for Generalizable Robotics Training via RL: trains policies with RL inside a learned action-conditioned video model.
• SIMA 2: A Generalist Embodied Agent for Virtual Worlds: a Gemini-based agent for 3D games, trained on human play and with self-improvement.
• VideoVLA: Video Generators Can Be Generalizable Robot Manipulators: jointly denoises future video latents and action chunks from CogVideoX-5B.
• Ground Slow, Move Fast: A Dual-System Foundation Model for Generalizable Vision-and-Language Navigation: a Qwen2.5-VL planner with an asynchronous diffusion trajectory head, for navigation.
• OXE-AugE: A Large-Scale Robot Augmentation of OXE for Scaling Cross-Embodiment Policy Learning: cross-paints Open X-Embodiment demonstrations onto nine robot embodiments in simulation.
• Robotic VLA Benefits from Joint Learning with Motion Image Diffusion: adds an optical-flow diffusion head to pi0 and pi0.5 during training only.
• STORM: Search-Guided Generative World Models for Robotic Manipulation: wraps a diffusion VLA in Monte Carlo tree search over video-model rollouts.
• RLDG: Robotic Generalist Policy Distillation via Reinforcement Learning: fine-tunes OpenVLA and Octo on successful rollouts of per-task RL experts.
• Emma-X: An Embodied Multimodal Action Model with Grounded Chain of Thought and Look-ahead Spatial Reasoning: fine-tunes OpenVLA to write a subtask, reasoning and movement plan before each action.