---
kind: concept
slug: vision-language-action-model
title: Vision-language-action model
summary: >-
  A policy that takes camera images and a language instruction and outputs robot actions, usually by building on a pretrained vision-language backbone. Covers action heads (tokens, regression, diffusion, flow matching), memory, cross-embodiment and generalist training, fine-tuning recipes, joint video-action models, failure detection, supervision and rollout evaluation.
tags: [robotics, vision-language-action, imitation-learning, cross-embodiment, fine-tuning, flow-matching, failure-detection, failure-recovery, robot-evaluation, world-model, video-generation, navigation, data-augmentation, search-planning]
papers: ["2406.09246", "2310.08864", "2606.20092", "2605.12386", "2603.03596", "2511.19433", "2512.05964", "2603.10448", "2606.21386", "2608.16590", "2506.18123", "2601.02295", "2405.12213", "2502.19645", "2502.05855", "2503.14734", "2508.05342", "2402.02385", "2503.03734", "2509.04018", "2512.03556", "2512.04797", "2512.06963", "2512.08186", "2512.13100", "2512.18007", "2512.18477", "2412.09858", "2412.11974"]
related: [action-tokenization, action-chunking, imitation-learning, chain-of-thought, knowledge-distillation, transfer-learning, mixture-of-experts, flow-matching, diffusion-models, low-rank-adaptation, weight-quantization, robot-simulation, temporal-logic-runtime-monitoring, anomaly-detection, conformal-prediction, bradley-terry-model, human-evaluation, hierarchical-reinforcement-learning, multimodal-language-model, task-decomposition, decoding-strategies, curriculum-learning, foundation-model, scene-graph-generation, learning-from-demonstration, world-model, monte-carlo-tree-search, optical-flow, latent-diffusion, video-generation, vision-language-pretraining, llm-agent, reinforcement-learning-verifiable-rewards, reward-design, model-based-reinforcement-learning, data-augmentation, vision-transformer, object-queries]
status: draft
updated_at: 2026-10-25
---

## 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 [arxiv:2406.09246 §3.1] [arxiv: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 [arxiv: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
[arxiv:2508.05342 §4.2] [arxiv:2508.05342 §3]. Other cards use continuous action heads instead: flow matching in
DiT4DiT [arxiv:2603.10448 §4.2], the pi0.6 base model used by MEM
[arxiv:2603.03596 §3.4] and GR00T N1 [arxiv:2503.14734 §2.1], diffusion in Octo
and DexVLA [arxiv:2405.12213 §3.3] [arxiv:2502.05855 §3.1], and an L1 regression
head in OFT [arxiv:2502.19645 §4.2]. RT-2-X also writes actions as text tokens
of its language model [arxiv: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 [arxiv: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
[arxiv:2512.13100 §4.2], and RLDG replaces human demonstrations with rollouts
of per-task reinforcement-learning experts [arxiv:2412.09858 §3]. STORM keeps a VLA as the action proposer and wraps it in
a search over imagined outcomes [arxiv:2512.18477 §3]. RoboScape-R trains a
policy inside a learned world model [arxiv:2512.03556 §3.2]. DualVLN targets
navigation, and SIMA 2 is a game agent that outputs keyboard and mouse actions
[arxiv:2512.08186 §3.1] [arxiv:2512.04797 §3.2]. A survey covers the wider field
and reports no experiments of its own [arxiv: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 [arxiv: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 [arxiv:2406.09246 §3.1]
[arxiv:2406.09246 §3.2] [arxiv:2406.09246 §3.3]. Card:
[OpenVLA: An Open-Source Vision-Language-Action Model](/papers/2406.09246).

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
[arxiv:2406.09246 app. B.1.3] [arxiv: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 [arxiv: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 [arxiv:2502.19645 §4.2]
[arxiv:2502.19645 app. A.2]. Card: [Fine-Tuning Vision-Language-Action Models:
Optimizing Speed and Success](/papers/2502.19645). See also [action
chunking](/concepts/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 [arxiv:2502.19645 §5.1]
[arxiv: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%
[arxiv:2502.19645 tab. 2]. Robot pretraining matters for this recipe: without
it, the recipe on the base VLM reaches 91.9% [arxiv:2502.19645 tab. 15].

Fine-tuning uses LoRA at rank 32, with 279M trainable parameters on LIBERO
[arxiv: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 [arxiv:2502.19645 tab. 4]
[arxiv: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 [arxiv:2502.19645 §6.3]
[arxiv:2502.19645 tab. 10] to [arxiv:2502.19645 tab. 13]. The trial counts are
10 to 24 per task [arxiv: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 [arxiv:2502.19645 §4.2] [arxiv: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 [arxiv: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 [arxiv: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 [arxiv: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 [arxiv:2310.08864 §4.2]
[arxiv:2310.08864 §4.3]. Card: [Open X-Embodiment: Robotic Learning Datasets
and RT-X Models](/papers/2310.08864).

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
[arxiv:2310.08864 §5.1] [arxiv:2310.08864 tab. 1]. RT-2-X reaches 75.8%
emergent-skill success against 27.3% for RT-2 [arxiv: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 [code: README.md#L39-L43], 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
[arxiv: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] [arxiv:2405.12213 app. D]. The model is pretrained on about 800k
trajectories from Open X-Embodiment [arxiv:2405.12213 §1]. A new camera or action
space needs only a small new encoder or head, and the transformer is kept
[arxiv:2405.12213 §3.1] [arxiv:2405.12213 §3.3]. Card: [Octo: An Open-Source
Generalist Robot Policy](/papers/2405.12213).

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 [arxiv: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 [arxiv:2405.12213 tab. 1] [arxiv: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 [arxiv:2405.12213 §3.4]. Wrist-camera data is
only 27% of the pretraining mix, and the authors blame this for weak wrist-camera
use [arxiv:2405.12213 §5]. The authors also report that adding proprioception
made pretrained policies worse [arxiv: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 [arxiv:2606.20092 §3.2]
[arxiv:2606.20092 app. B.3]. Card:
[EventVLA: Event-Driven Visual Evidence Memory for Long-Horizon
Vision-Language-Action Policies](/papers/2606.20092).

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% [arxiv:2606.20092 tab. 2]
[arxiv:2606.20092 tab. 4]. On the authors' real bimanual tasks, the figure is
78.8% [arxiv: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
[arxiv:2603.03596 §3.3] [arxiv: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
[arxiv:2603.03596 §3.1] [arxiv: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](/papers/2603.03596).

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
[arxiv:2603.03596 §4.1] [arxiv: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) [arxiv: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 [arxiv: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] [arxiv:2603.10448 §4.4]. The authors use layer 18 and a single denoising
step for those features [arxiv:2603.10448 app. A.1] [arxiv:2603.10448 §5.4].
Card: [DiT4DiT: Jointly Modeling Video Dynamics and Actions for Generalizable
Robot Control](/papers/2603.10448).

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 [arxiv:2603.10448 tab. 1] [arxiv: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 [arxiv: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 [arxiv:2502.05855 §3.1] [arxiv: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 [arxiv: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
[arxiv:2502.05855 §3.2] [arxiv:2502.05855 app. C.4]. Card: [DexVLA: Vision-Language
Model with Plug-In Diffusion Expert for General Robot Control](/papers/2502.05855).

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 [arxiv:2502.05855 §4.1] [arxiv:2502.05855 §4.3]. Without stage 3,
laundry folding drops to 0 [arxiv:2502.05855 §4.4]. The LIBERO average of 97.3
uses stage-1 weights only. pi0 reaches 97.1 on the same three suites
[arxiv: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 [arxiv:2502.05855 app. D.2].
The sub-step labels came from Grounding-DINO, DINOv2 and Gemini 2.0, and they
are not released [arxiv: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 [code: LICENSE]. The paper's 60 Hz speed claim
does not say what was timed [arxiv: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 [arxiv:2412.11974 §3.2] [arxiv:2412.11974 §4.1].
Each trajectory is cut into segments where a clustering label or the gripper
state changes [arxiv:2412.11974 §3.1]. Gemini sees the images of one segment
and returns a subtask and a justification for it [arxiv:2412.11974 §3.2]. The
authors label segments rather than single frames, because per-frame labels were
noisy in their experiments [arxiv: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 [arxiv:2412.11974 §3.2] [arxiv:2412.11974 §3.3]. Card: [Emma-X: An Embodied
Multimodal Action Model with Grounded Chain of Thought and Look-ahead Spatial
Reasoning](/papers/2412.11974). See also [chain of thought](/concepts/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
[arxiv:2412.11974 tab. 1]. The largest gain is on spatial-relation tasks, which the authors put at 35%
over OpenVLA in half-success [arxiv: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 [arxiv: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 [code: GCOT/generate_plans.py#L19-L24]
(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 [arxiv: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 [arxiv:2503.14734 §2.1]. Each embodiment has its own
state and action encoders and decoders, so one transformer serves several
bodies [arxiv: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 [arxiv:2503.14734 §2.2] [arxiv:2503.14734 §3.2].
Card: [GR00T N1: An Open Foundation Model for Generalist Humanoid
Robots](/papers/2503.14734).

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% [arxiv:2503.14734 tab. 3]. Across three simulation
suites, the headline average is 45.0%, against 33.4% for Diffusion Policy
[arxiv:2503.14734 tab. 2]. Neural trajectories added as co-training data give
+5.8 points averaged over eight real tasks [arxiv: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 [arxiv: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 [arxiv: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
[arxiv:2512.05964 §4] [arxiv: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 [arxiv:2512.05964 §4] [arxiv:2512.05964 fig. 2].
Card: [Training-Time Action Conditioning for Efficient Real-Time
Chunking](/papers/2512.05964). See also [action chunking](/concepts/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
[arxiv:2512.05964 §5.1] [arxiv:2512.05964 fig. 3]. At delays of 0 or 1 it is
slightly lower, which the authors attribute to fewer supervised first actions
[arxiv: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 [arxiv:2512.05964 §5.2]. The
real-robot evidence is two tasks and a figure [arxiv: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 [arxiv: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 [arxiv:2511.19433 §3.2]
[arxiv:2511.19433 fig. 3]. A balance loss stops the gate from collapsing onto
one length [arxiv:2511.19433 §3.2]. The paper's default is a maximum horizon of
30 with candidates every three steps [arxiv:2511.19433 §4.1]. Card: [Mixture of
Horizons in Action Chunking](/papers/2511.19433). See also [action
chunking](/concepts/action-chunking).

The method applies to flow-matching heads and to one-step heads, which the
paper treats as separate loss types [arxiv: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 [arxiv:2511.19433 tab. 1]. These are
single-seed LIBERO differences. RoboCasa is the only setting with reported seed
spread [arxiv: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 [arxiv:2511.19433 §4.4]
[arxiv:2511.19433 fig. 6].

The authors call the extra compute negligible [arxiv:2511.19433 §1]. The
released JAX model repeats the KV cache once per horizon along the batch
dimension [code: src/openpi/models/pi0_moh.py#L308-L311], 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 [arxiv: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 [arxiv: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 [arxiv:2606.21386 §3.2].
Card: [VLA-FAIL](/papers/2606.21386), 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 [arxiv: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
[arxiv:2606.21386 tab. 2]. These are threshold-independent metrics with higher
PR and lower PDT better. The threshold-based results are in an appendix
[arxiv:2606.21386 app. D]. LLMD also needs one pass over the finetuning data
before deployment [arxiv:2606.21386 §6], and ACC needs receding-horizon control
with overlapping chunks [arxiv:2606.21386 §6] [arxiv: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 [arxiv: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](/papers/2608.16590).

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%
[arxiv:2608.16590 tab. 2] [arxiv: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 [arxiv:2601.02295 §4.1]. The training
demonstrations are split into subtasks, using an LLM and the gripper and motion
signals in the robot data [arxiv:2601.02295 §4.1] [arxiv: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
[arxiv:2601.02295 §5.1] [arxiv: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 [arxiv:2601.02295 §4.2] [arxiv:2601.02295 eq. 4]. Card:
[CycleVLA: Proactive Self-Correcting Vision-Language-Action Models via Subtask
Backtracking and Minimum Bayes Risk Decoding](/papers/2601.02295).

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] [arxiv: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
[arxiv: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 [arxiv: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 [arxiv:2601.02295 §4.2]
[arxiv:2601.02295 §7]. The stop and progress outputs need subtask labels in
the training data [arxiv: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 [arxiv: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
[arxiv:2508.05342 §3.2.1] [arxiv: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](/papers/2508.05342).

The graph feeds a VLA with two heads on one LLaMA 2 7B model, each with its own
LoRA adapter [arxiv:2508.05342 §4.2] [arxiv: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 [arxiv:2508.05342 §4.3]. The action head
outputs Cartesian poses and gripper states at 5 Hz, for both arms
[arxiv:2508.05342 §4.2]. The authors say the LLM head verifies subtasks and
replans locally when one fails [arxiv:2508.05342 §4.1] [arxiv:2508.05342 §5.2].

The authors report 0.94 grasp success and 0.89 placement success over 120
evaluated block trials [arxiv:2508.05342 tab. 1]. A policy trained from one
"R" demonstration reaches 0.90 transfer success over six letter and tower
variants [arxiv:2508.05342 tab. 3]. In the ablation, removing the scene graph
drops the letter transfer score from 0.88 to 0.48 [arxiv:2508.05342 tab. 2].
These are author-reported, and the baseline table reports only transfer
success, with no spread [arxiv: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
[arxiv:2508.05342 §7]. Instruction planning takes 7.56 s on average, separate
from the 5 Hz control stream [arxiv: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) [arxiv:2508.05342 §3.2.1] [arxiv: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 [arxiv:2605.12386 §3.3] [arxiv:2605.12386 §4.2]. Card:
[SafeManip: A Property-Driven Benchmark for Temporal Safety Evaluation in Robotic
Manipulation](/papers/2605.12386).

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 [arxiv: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 [arxiv:2605.12386 §1] [arxiv: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 [arxiv: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 [arxiv:2506.18123 §1] [arxiv: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 [arxiv:2506.18123 §4] [arxiv:2506.18123 §5.1]. Card:
[RoboArena: Distributed Real-World Evaluation of Generalist Robot
Policies](/papers/2506.18123).

### 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 [arxiv:2503.03734 §3.1]. A learned pooling step and a causal
transformer then predict chunks of 10-D delta end-effector actions
[arxiv:2503.03734 §3.2]. Card: [OTTER: A Vision-Language-Action Model with
Text-Aware Visual Feature Extraction](/papers/2503.03734).

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% [arxiv:2503.03734 §5.1]
[arxiv: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 [arxiv: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 [arxiv: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
[arxiv:2512.06963 §3.2] [arxiv:2512.06963 §4.1]. Only the first three actions
are executed, then the model is queried again [arxiv:2512.06963 §4.1]. Unlike
the DiT4DiT variant above, which reads features from one block at a fixed step
and does not generate frames [arxiv:2603.10448 §4.4], this variant denoises
the video latents themselves. Card: [VideoVLA: Video Generators Can Be
Generalizable Robot Manipulators](/papers/2512.06963).

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 [arxiv:2512.06963 tab. 1] [arxiv:2512.06963
tab. 2] [arxiv:2512.06963 tab. 3]. The in-domain gap is within noise at 24
trials per WidowX task [arxiv:2512.06963 app. A]. Without the video loss, the
generalization columns fall to 12.7 and 4.4 [arxiv:2512.06963 tab. 9]. Training
from scratch instead of from CogVideoX drops the average to 12.6
[arxiv: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
[arxiv: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 [arxiv:2512.18007 §3.2] [arxiv:2512.18007 §1]. Targets are RAFT flow
between two frames, mapped to colour and encoded by a frozen SDXL-VAE
[arxiv:2512.18007 app. A.1] [arxiv:2512.18007 app. A.2]. Card: [Robotic VLA
Benefits from Joint Learning with Motion Image Diffusion](/papers/2512.18007).

Author-reported: LIBERO average 97.5% for pi0.5, against 96.9%, and 94.7% for
pi0, against 94.2% [arxiv:2512.18007 tab. 1]. On RoboTwin easy mode the pi0
average is 58.0%, against 45.1% [arxiv: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 [arxiv:2512.18007 §4.3] [arxiv: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 [arxiv:2512.18007 tab. 3]. The real-robot test is three tasks at
43% average [arxiv: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 [arxiv:2509.04018 §3.5] [arxiv: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
[arxiv:2509.04018 §3.4] [arxiv: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 [arxiv:2509.04018 §3.3]. Card:
[FPC-VLA: A Vision-Language-Action Framework with a Supervisor for Failure
Prediction and Correction](/papers/2509.04018).

Author-reported: SIMPLER WidowX task average 64.6% against 51.8% for CogACT, and
real-robot task average 86.0% against 78.4% [arxiv:2509.04018 tab. 3]
[arxiv:2509.04018 tab. 6]. In a four-task ablation, the task average is 82.1
with the supervisor and 74.4 without it [arxiv: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% [arxiv:2509.04018 §4.6] [arxiv:2509.04018 tab. 7]. With the stated
constants the similarity term moves the pose weights by about 10% at most (our
arithmetic from [arxiv:2509.04018 eq. 8] and [arxiv: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
[arxiv:2509.04018 §4.1]. Slips after a successful grasp are not covered
[arxiv: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
[arxiv: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 [arxiv:2512.03556 eq. 5] [arxiv:2512.03556 eq. 7]. Any RL
algorithm can consume the rollouts, and the paper uses PPO [arxiv:2512.03556
§3.2] [arxiv:2512.03556 §4.3]. Card: [RoboScape-R: Unified Reward-Observation
World Models for Generalizable Robotics Training via RL](/papers/2512.03556).

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
[arxiv:2512.03556 tab. 1]. In-domain differences are at most 3.0 points, and
the table has no seeds or error bars [arxiv:2512.03556 tab. 1]. Every
evaluation runs in ManiSkill, and no real-robot test is reported
[arxiv:2512.03556 §5]. World-model training took about 96 hours on an H20
cluster [arxiv: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 [arxiv:2512.03556 §3.1] [arxiv: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 [arxiv:2512.18477 §3] [arxiv:2512.18477
alg. 1] [arxiv:2512.18477 eq. 5]. The paper uses 8 simulations per decision,
planning depth 3 and discount 0.9 [arxiv:2512.18477 §4.1]. Card: [STORM:
Search-Guided Generative World Models for Robotic Manipulation](/papers/2512.18477).

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
[arxiv:2512.18477 tab. 1] [arxiv: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 [arxiv: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 [arxiv:2512.08186 §3.1] [arxiv: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 [arxiv:2512.08186 §3.2]. Card:
[Ground Slow, Move Fast: A Dual-System Foundation Model for Generalizable
Vision-and-Language Navigation](/papers/2512.08186).

Author-reported: 64.3 success on R2R-CE val-unseen with RGB only, against 56.9
for StreamVLN [arxiv:2512.08186 tab. 1]. On VLN-PE val-unseen, without training
on VLN-PE, it reaches 51.60, against 22.42 for NaVid [arxiv: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 [arxiv: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
[arxiv: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 [arxiv: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
[arxiv:2512.13100 §6] [arxiv:2512.13100 app. A.2]. Card: [OXE-AugE: A
Large-Scale Robot Augmentation of OXE for Scaling Cross-Embodiment Policy
Learning](/papers/2512.13100).

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 [arxiv: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
[arxiv:2512.13100 app. A.5]. Diffusion-based augmentation of the same images
lowered policy performance by 27 to 30% in the authors' test
[arxiv:2512.13100 §6.2]. The method assumes similar grippers and known frame
transforms [arxiv: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%
[arxiv:2412.09858 §3.1] [arxiv: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
[arxiv:2412.09858 §3.2] [arxiv: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 [arxiv:2412.09858 §3.2]. Card: [RLDG: Robotic
Generalist Policy Distillation via Reinforcement Learning](/papers/2412.09858).
See also [imitation learning](/concepts/imitation-learning) and [knowledge
distillation](/concepts/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 [arxiv:2412.09858 §4.2] [arxiv: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 [arxiv:2412.09858 §4.3]. Most conditions use 20 trials and the paper
reports no error bars [arxiv: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 [arxiv:2412.09858 app. B]. The paper names reward specification for
new tasks as its main limitation [arxiv:2412.09858 §6]. The repository releases
only the RL-expert stage. Generalist fine-tuning and data collection are marked
"Coming soon" [code: README.md#L24-L28], 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
[arxiv:2512.04797 §3.2] [arxiv: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 [arxiv:2512.04797 §3.3]. A self-improvement loop has
Gemini propose tasks and score the trajectories from 0 to 100, with 50 as
success [arxiv:2512.04797 §4.5]. Card: [SIMA 2: A Generalist Embodied Agent for
Virtual Worlds](/papers/2512.04797).

Author-reported: about twice SIMA 1's average success on the training games, with
the values only in a figure [arxiv:2512.04797 §4.2.1] [arxiv:2512.04797 fig. 6].
On held-out ASKA and MineDojo, success is more than 10% higher
[arxiv: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
[arxiv:2512.04797 §4.3] [arxiv:2512.04797 tab. 1]. No code is released, the base
model is closed, and the RL settings are not stated [arxiv:2512.04797 §3.3].
Treat the paper as a description of the approach, not a recipe.

## When to use which

| Situation | Use | Why |
|---|---|---|
| Single robot, one task, no history needed, need released weights | Single-frame open VLA | Weights and training code are published, and the authors report LoRA fine-tuning on a single GPU [arxiv:2406.09246 §3.5] [arxiv:2406.09246 §5.3] |
| Task depends on a cue that leaves the camera view, briefly | Learned-keyframe memory | Anchors without keyframes reach 18.0% on RoboTwin-MeM, against 75.2% with them [arxiv:2606.20092 tab. 2] |
| Task runs for minutes and needs subtask progress or retries | Two-memory VLA (MEM) | The authors report tasks of up to about 15 minutes and retry behaviour with a summary memory [arxiv:2603.03596 §4.1] |
| Real-time control with a delay the policy must respect, flow-matching policy | Training-time chunk conditioning | No inference overhead, and the authors report lower latency than inference-time RTC on their real setup [arxiv:2512.05964 §4] [arxiv:2512.05964 §5.2] |
| Flow-matching or one-step action head, want better chunk predictions without changing the backbone | Multi-horizon head (MoH) | The authors report pi0.5 at 99.0 on LIBERO against 97.7 without it, from a single seed [arxiv:2511.19433 tab. 1] [arxiv:2511.19433 §4.1] |
| Several robots or datasets, want one policy with a shared action space, and no per-robot model | Cross-embodiment co-training | The authors report RT-1-X beats each dataset's own baseline on 4 of 5 small-data domains [arxiv:2310.08864 §5.1]. It does not beat RT-1 on large domains [arxiv:2310.08864 tab. 1] |
| Have a video backbone and want actions from its features, with a low control rate acceptable | Joint video-action model | The authors report 98.6% on LIBERO and 50.8% on RoboCasa-GR1, at 6 Hz on one A100 [arxiv:2603.10448 tab. 1] [arxiv:2603.10448 tab. 3] |
| Task has clear subtask boundaries where failures happen, retries are physically reversible, and the robot can afford a VLM call and eight extra policy passes per retry | CycleVLA-style backtracking | Removing MBR drops LIBERO from 95.3% to 92.5% [arxiv:2601.02295 tab. 6]. Needs subtask labels and two extra outputs [arxiv:2601.02295 §4.1], and adds about 30% to rollout time [arxiv:2601.02295 app. D] |
| Need an alarm for failures without failure data, and can run the finetuning data once | VLA-FAIL | Failure detection with about 1–2% extra latency and no failure rollouts [arxiv:2606.21386 §3] [arxiv:2606.21386 tab. 3] |
| Frozen policy, many simulated rollouts, want interventions during execution | Zetta-style harness | Reported gains on RoboCasa and LIBERO-Pro, with seed-replayable simulation required [arxiv:2608.16590 tab. 2] [arxiv:2608.16590 §4.1] |
| Bimanual assembly from a few human videos, readable plan needed, and a 7B model with LoRA is affordable | Scene-graph planning with a dual-head VLA (GF-VLA) | Author-reported 0.90 transfer success from one demonstration [arxiv:2508.05342 tab. 3]. Removing the scene graph drops letter transfer to 0.48 [arxiv:2508.05342 tab. 2]. No code released |
| Need to show a policy is safe, not only successful | Temporal-safety benchmark | Task success and per-event violations can rank policies differently [arxiv:2605.12386 §5.1] |
| Need to compare policies on real hardware across many tasks | Distributed pairwise arena | The authors report stable rankings after about 100 comparisons [arxiv:2506.18123 §5.3] |
| Open generalist policy with swappable cameras and action spaces, and no VLM backbone needed | Octo-style transformer with diffusion head | The authors report 72% average over six finetuning setups, against 20% from scratch [arxiv:2405.12213 tab. 1]. Wrist-camera data is 27% of pretraining [arxiv:2405.12213 §5] |
| Have an OpenVLA-class model and need faster control or a better fine-tuning recipe | Parallel-decoding recipe (OFT) | Third-person LIBERO average rises from 76.5% to 95.3%, and the same recipe runs at 109.7 Hz against 4.2 Hz [arxiv:2502.19645 tab. 1] [arxiv:2502.19645 tab. 2] |
| Long multi-stage task, sub-step annotation affordable, three training stages possible | DexVLA-style VLM with diffusion expert | Laundry folding 0.4 against 0.2 for pi0 under direct prompting [arxiv:2502.05855 §4.3]. Without stage 3 it drops to 0 [arxiv:2502.05855 §4.4] |
| Humanoid or multi-embodiment data, little target data, access to large pretraining compute | GR00T N1-style flow-matching VLA | 42.6% against 10.2% for Diffusion Policy with 10% of post-training data [arxiv:2503.14734 tab. 3]. Pretraining used about 50,000 H100 GPU hours [arxiv:2503.14734 §2.3] |
| Limited inference latency or GPU memory | Check measured numbers per variant | EventVLA reports about 0.42 s per chunk and about 7 GB on an A100 [arxiv:2606.20092 tab. 11]. OpenVLA reports about 6 Hz on an RTX 4090 in bfloat16 [arxiv:2406.09246 §3.5]. OFT measures 4.2 Hz for OpenVLA and 109.7 Hz for its recipe, both on one A100 [arxiv:2502.19645 tab. 2]. GR00T N1 reports 63.9 ms per 16-action chunk on one L40 [arxiv:2503.14734 §2.1]. VideoVLA reports about 1.1 s per chunk with 10 steps on an H100 [arxiv:2512.06963 app. D]. DualVLN's System 2 takes 0.7 s per output and System 1 takes 0.03 s, on an RTX 4090 [arxiv:2512.08186 §5.2]. FPC-VLA reports 0.176 s per non-keyframe step and 1.766 s per keyframe, on unstated hardware [arxiv:2509.04018 §4.1]. Hardware and output shape differ across cards, so these are not a like-for-like comparison |
| Task needs proprioception or observation history | Memory-augmented VLA, or check first | OpenVLA takes one image, no proprioception and no history [arxiv:2406.09246 §6]. SafeManip's monitor reads privileged simulator state the policy never sees [arxiv:2605.12386 app. F] |
| Few arms in your demonstration data, and you need a new arm or gripper without re-collecting | Cross-painting augmentation (OXE-AugE) | Author-reported gains of 24% (OpenVLA-OFT) and 45% (pi0) on the average partial score for unseen gripper pairs, with the unit unstated [arxiv:2512.13100 §6.2] |
| Frozen VLM must keep its image-text alignment, and generalization to new objects matters | Frozen-encoder text-aware selection (OTTER) | 62% against 9% for fine-tuned OpenVLA on 70 unseen pick-and-place trials [arxiv:2503.03734 §5.1]. Fine-tuning CLIP lowers unseen success to 15% [arxiv:2503.03734 §5.3] |
| Video generator available, and control at a few hertz is acceptable | Video-backbone joint model (VideoVLA) | 65.2 against 42.4 for CogACT on novel objects, but a tie in-domain at 63.0 against 62.6 [arxiv:2512.06963 tab. 1] [arxiv:2512.06963 tab. 2]. About 1.1 s per chunk [arxiv:2512.06963 app. D] |
| Pi-series VLA, can retrain it, and the third-person camera shows the motion | Auxiliary motion head (motion-image diffusion) | LIBERO average 97.5% against 96.9% for pi0.5, without a change at inference [arxiv:2512.18007 tab. 1] [arxiv:2512.18007 §4.3]. Real-robot test is small [arxiv:2512.18007 §4.5] |
| Failures cluster at grasp and release, and a second model call at each gripper event is affordable | Runtime supervisor (FPC-VLA) | Four-task task average 82.1 with the supervisor against 74.4 without [arxiv:2509.04018 tab. 7] |
| Simulator reward is hard to write, and video data exists to train a world model | World-model RL (RoboScape-R) | 84.1% against 54.5% out-of-domain for OpenVLA with the simulator reward, evaluated only in simulation [arxiv:2512.03556 tab. 1] |
| Reactive policy keeps repeating one failed action, and many imagined rollouts per step are affordable | Search over imagined futures (STORM) | 51.0% against 47.9% for CogACT on four WidowX tasks, a small gain [arxiv:2512.18477 tab. 1]. No latency reported |
| Navigation with obstacle avoidance in real time, and a slow VLM planner is affordable | Dual-system navigation VLA (DualVLN) | 64.3% success against 56.9% for StreamVLN on R2R-CE val-unseen, RGB only [arxiv:2512.08186 tab. 1] |
| Human demonstrations are slow or uneven, the task has a learnable success signal, and 1 to 3 hours of real-robot RL per task is affordable | RL-expert distillation (RLDG) | 10% to 37% higher success than fine-tuning on the same number of human demonstrations on insertion tasks [arxiv:2412.09858 §4.2]. Released code covers only the RL stage [code: README.md#L24-L28] |
| Failures come from a wrong gripper target in spatial-relation tasks, and several times more output tokens per step are affordable | Reasoning and movement-plan VLA (Emma-X) | 57.5% success against 33.3% for OpenVLA on 12 real WidowX tasks [arxiv:2412.11974 tab. 1]. Removing the movement plan drops spatial-relation success from 70 to 37 in the ablation [arxiv:2412.11974 tab. 2] |
| Game or GUI agent from pixels and keyboard-and-mouse, with text reasoning | Game-playing agent (SIMA 2) | About twice SIMA 1 on training games, values only in a figure, and not reproducible [arxiv:2512.04797 §4.2.1] [arxiv:2512.04797 §3.3] |

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 [arxiv:2406.09246 §3.2]
[arxiv:2606.20092 §3.2].

```pseudocode
# 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 [arxiv:2512.05964 alg. 1]. The sampler overwrites the prefix at
every denoising step [arxiv:2512.05964 alg. 1]. VLA-FAIL needs no change to
the policy. It reads features at one flow timestep and compares overlapping
chunks [arxiv:2606.21386 §3.1] [arxiv:2606.21386 §3.2]. MoH keeps the
per-horizon flow-matching loss and adds a gate-weighted fused loss and a
balance term [arxiv: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 [arxiv: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 [arxiv:2502.19645 §4.2]. Octo uses a
noise-prediction diffusion loss with a cosine schedule [arxiv:2405.12213 §3.3].
DexVLA's paper does not state its diffusion schedule or prediction target
[arxiv: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 [arxiv:2503.14734 §2.1]
[code: gr00t/model/gr00t_n1d7/gr00t_n1d7.py#L233-L235].

Training is next-token cross-entropy on the action tokens in OpenVLA
[arxiv:2406.09246 §3.2]. EventVLA adds a keyframe loss with a weight λ
[arxiv: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) [arxiv: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
  [arxiv:2603.10448 app. A.3]. OFT measures OpenVLA at 4.2 Hz on one A100
  [arxiv: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
  [arxiv:2406.09246 §1] [arxiv: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 [arxiv:2606.20092 tab. 1] [arxiv:2606.20092 tab. 2].
- **Released code vs paper.** EventVLA's paper gives a keyframe loss weight of
  0.1 [arxiv:2606.20092 tab. 7], while its released sim config uses 1.0
  [code: EventVLA/examples/RoboTwin-Mem/train_files/eventvla_robotwin_mem.yaml#L56].
  Its real-robot code is not released [arxiv:2606.20092 §5.3]. OpenVLA's paper
  gives no fine-tuning learning rate, and the released script defaults to 5e-4
  [code: vla-scripts/finetune.py#L90].
- **Joint training gradient (DiT4DiT).** Algorithm 1 updates both diffusion
  models from the total loss, so the action loss reaches the video model
  [arxiv:2603.10448 alg. 1] [arxiv: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
  [arxiv:2603.10448 tab. 2]. The comparison is not like-for-like.
- **Feature timestep (DiT4DiT).** The paper calls the feature timestep fixed
  [arxiv:2603.10448 §4.3] [arxiv:2603.10448 §4.4]. Its Algorithm 1 samples it
  per step [arxiv:2603.10448 alg. 1], and the code uses the first step of a
  schedule [code: DiT4DiT/model/modules/vlm/Cosmos25.py#L609].
- **Memory horizon (MEM).** The post-training horizon is 54 s in one place and
  "up to 1 minute" in another [arxiv:2603.03596 §3.4] [arxiv: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
  [arxiv:2608.16590 tab. 3] [arxiv: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 [arxiv:2608.16590 §4.1] [arxiv:2608.16590 §4.6].
- **Live leaderboard vs paper (RoboArena).** The paper's ranking is the
  task-aware model [arxiv:2506.18123 §3.2]. The public code runs a plain
  Bradley-Terry fit with Davidson ties, and its EM routine is marked as
  disabled [code: central_server/central_server.py#L655-656]
  [code: central_server/central_server.py#L1058-1060]. 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
  [arxiv: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
  [arxiv:2508.05342 §8]. No table reports those baselines, so the claim is
  not supported in the paper [arxiv:2508.05342 tab. 4].
- **Smoothing in VLA-FAIL.** The method text says an ACC smoothing weight of 0.9
  is required [arxiv:2606.21386 §3.2]. The ablation says a fixed 0.1 was used
  throughout [arxiv:2606.21386 app. B], and the hyperparameter tables give 0.9
  [arxiv: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 [arxiv:2310.08864 §4.2]. The released code
  emits 11 tokens, and its inference script builds the model with 512 bins
  [code: models/rt1.py#L293-L299] [code: models/rt1_inference_example.py#L153].
- **Emergent-skill ratio (RT-2-X).** The text says RT-2-X is about 3 times RT-2
  on emergent skills [arxiv:2310.08864 §5.2]. The table gives 75.8 against 27.3,
  about 2.8 times [arxiv:2310.08864 tab. 2].
- **Model size or history (RT-2-X).** The text credits the gap between the 55B
  and 5B models to size [arxiv:2310.08864 §5.3]. The comparison it relies on
  also changes history, from none to two frames [arxiv: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 [arxiv: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
  [arxiv:2511.19433 §3.2]. The PyTorch forward pass adds learned gate noise
  during training [code: src/openpi/models_pytorch/pi0_pytorch_moh.py#L137-L142].
  The JAX model has none [code: src/openpi/models/pi0_moh.py#L379-L407].
- **Horizon set and dynamic inference (MoH).** The paper's default is the
  stride-3 set up to 30 [arxiv:2511.19433 §4.1]. The JAX config default is
  [5, 10, ..., 30] [code: src/openpi/models/pi0moh_config.py#L59] and the
  PyTorch default is [10, 20, 30] [code: src/openpi/training/config.py#L531].
  The paper defines disagreement on the final chunk [arxiv:2511.19433 alg. 1],
  while the PyTorch sampler sums it over denoising steps
  [code: src/openpi/models_pytorch/pi0_pytorch_moh.py#L696-L706].
- **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 [code: scripts/configs/octo_pretrain_config.py#L132]
  [code: scripts/train.py#L156]. 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 [code: README.md#L101] [code: gr00t/configs/model/gr00t_n1d7.py#L76].
  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 [arxiv:2503.14734 tab. 2].
  The DexMG score is 66.5% in tab. 2 and 58.5% when averaged from tab. 4
  [arxiv:2503.14734 tab. 4].
- **DexVLA paper vs code.** The paper freezes the VLM's visual encoder in stage 2
  [arxiv: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 [arxiv:2502.05855 §3.1], but the policy head has one output layer
  [code: policy_heads/models/transformer_diffusion/modeling_scaledp.py#L246]. The
  paper's Adam beta2 is 0.95 [arxiv:2502.05855 §3.2], while the trainer path the
  card traced uses 0.98 [code: train_vla.py#L79].
- **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 [arxiv: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 [arxiv:2606.21386 §6].
- **Retry selection (CycleVLA).** The paper's MBR rule is the plain
  average-distance argmin [arxiv:2601.02295 eq. 4] [arxiv: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]
  [code: experiments/robot/libero/run_libero_eval_decomposed_progress_mbr.py#L1081].
  The paper does not say which rule produced its selection tables
  [arxiv:2601.02295 tab. 4] [arxiv:2601.02295 tab. 5].
- **Confirmation rule (CycleVLA).** The paper uses one stop and progress rule for
  all tasks [arxiv: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
  [arxiv:2412.09858 §4.2]. The introduction's averages of 30% and 50% are not
  derived in the text [arxiv: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 [arxiv:2412.09858 §4.2] [arxiv:2412.09858 fig. 5]. The real-robot time for the
  RL experts is not counted in the comparison [arxiv:2412.09858 app. B].
- **Emma-X training mix.** The paper's output order is reasoning, subtask,
  gripper target, movement plan and actions [arxiv:2412.11974 §3.3]
  [arxiv: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
  [arxiv:2412.11974 §3.1]. The plan-generation script clusters poses only
  [code: GCOT/generate_plans.py#L13-L16].
- **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 [arxiv:2412.11974 §4.1]. The
  `movement_policy` config sets 200 [code: prismatic/conf/vla.py#L310].
- **ECoT average (Emma-X).** Table 1 prints 28.75 for ECoT's half-success
  average, while its twelve rows average 29.17 [arxiv: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 [arxiv:2512.18477 tab. 1]. VideoVLA reports 71.7, 50.8, 15.0
  and 67.5, with a WidowX average of 51.3 [arxiv:2512.06963 tab. 1]. FPC-VLA
  reports a WidowX task average of 51.8 [arxiv:2509.04018 tab. 3]. On the Google
  Robot, VideoVLA gives 75.2 and 61.4 for CogACT [arxiv:2512.06963 tab. 1], and
  FPC-VLA gives 74.8 and 61.3 [arxiv: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
  [arxiv:2511.19433 tab. 1]. The motion-head paper reports 96.9 for pi0.5
  [arxiv: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 [arxiv:2512.18007 §4.3] [arxiv:2512.18007 tab. 2].

## Papers

- [OpenVLA: An Open-Source Vision-Language-Action Model](/papers/2406.09246):
  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](/papers/2502.19645):
  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](/papers/2606.20092): 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](/papers/2310.08864):
  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](/papers/2405.12213): 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](/papers/2605.12386): scores recorded manipulation
  rollouts for temporal safety, using LTLf rules, and audits seven policies.
- [MEM: Multi-Scale Embodied Memory for Vision Language Action Models](/papers/2603.03596):
  adds a short-horizon video encoder and a long-horizon language memory to pi0.6.
- [Mixture of Horizons in Action Chunking](/papers/2511.19433): trains one
  action head on several chunk lengths and fuses them with a learned gate.
- [Training-Time Action Conditioning for Efficient Real-Time Chunking](/papers/2512.05964):
  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](/papers/2601.02295):
  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](/papers/2603.10448): 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](/papers/2502.05855): 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](/papers/2503.14734):
  a VLM with a flow-matching diffusion transformer for humanoid robots, pretrained
  on real, simulated, neural and human-video data.
- [VLA-FAIL](/papers/2606.21386): 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](/papers/2508.05342):
  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](/papers/2608.16590): evolves code-based runtime critics and
  recovery skills around a frozen VLA.
- [RoboArena: Distributed Real-World Evaluation of Generalist Robot
  Policies](/papers/2506.18123): ranks generalist policies from distributed,
  double-blind real-robot pairwise trials.
- [A Survey on Robotics with Foundation Models: toward Embodied AI](/papers/2402.02385):
  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](/papers/2503.03734):
  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](/papers/2509.04018):
  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](/papers/2512.03556):
  trains policies with RL inside a learned action-conditioned video model.
- [SIMA 2: A Generalist Embodied Agent for Virtual Worlds](/papers/2512.04797):
  a Gemini-based agent for 3D games, trained on human play and with self-improvement.
- [VideoVLA: Video Generators Can Be Generalizable Robot Manipulators](/papers/2512.06963):
  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](/papers/2512.08186):
  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](/papers/2512.13100):
  cross-paints Open X-Embodiment demonstrations onto nine robot embodiments in simulation.
- [Robotic VLA Benefits from Joint Learning with Motion Image Diffusion](/papers/2512.18007):
  adds an optical-flow diffusion head to pi0 and pi0.5 during training only.
- [STORM: Search-Guided Generative World Models for Robotic Manipulation](/papers/2512.18477):
  wraps a diffusion VLA in Monte Carlo tree search over video-model rollouts.
- [RLDG: Robotic Generalist Policy Distillation via Reinforcement Learning](/papers/2412.09858):
  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](/papers/2412.11974):
  fine-tunes OpenVLA to write a subtask, reasoning and movement plan before each action.