SimVLA: Minimal VLA Baseline

• SimVLA is a minimal vision-language-action framework that decouples perception and control for transparent performance benchmarking.
• Its architecture employs a standard vision-language backbone with a lightweight Transformer action head, achieving state-of-the-art simulation outcomes.
• Experimental results and ablations highlight that controlled training recipes and simple token concatenation can outperform complex, specialized modules.

SimVLA is a streamlined baseline for Vision-Language-Action (VLA) research in robotic manipulation that is designed to establish a transparent reference point for empirical comparison. Its defining premise is strict decoupling of perception from control: a standard vision-language backbone produces a representation from multi-view RGB observations and language, while a lightweight action head performs action decoding under a standardized training recipe. In the reported experiments, this minimal design achieves state-of-the-art performance on standard simulation benchmarks without robot pretraining, and it reaches on-par real-robot performance compared to pi0.5 despite having only 0.5B parameters under the paper’s backbone-counting convention (Luo et al., 20 Feb 2026).

1. Rationale and research role

SimVLA is motivated by a methodological problem in contemporary VLA research: recent systems often combine architectural changes with differences in backbone scale, pretraining data, optimizer schedules, and other training details, making it difficult to determine which factor is responsible for an observed gain. The paper situates SimVLA as a “transparent lower bound” of complexity: a small model with a fixed, standard training recipe that still attains state-of-the-art performance. The intended function is not merely competitive performance, but controlled attribution of empirical gains to future architectural innovations (Luo et al., 20 Feb 2026).

The model’s design philosophy follows directly from that objective. By strictly decoupling perception, implemented through a frozen or lightly finetuned vision-LLM, from control, implemented through a small action head, SimVLA is meant to support plug-and-play replacement of backbones as new VLMs appear, standardization of “silent” implementation details such as data shuffling, normalization, and schedulers, and clearer benchmarking of any additional module introduced by subsequent work.

A common misconception addressed by this framing is that performance gains in VLA systems necessarily arise from increasingly specialized modules such as temporal encoders, 3D priors, or diffusion decoders. SimVLA is explicitly constructed to test the alternative hypothesis that a minimal, carefully standardized design can already recover or exceed the performance of more elaborate systems.

2. Architecture and parameterization

At each control step $t$, SimVLA takes RGB images $(I_t^1,\dots,I_t^m)$, language $\ell_t$, and proprioception $s_t$. These inputs are processed by a VLM encoder into fused vision-language tokens,

$Z_t \in \mathbb{R}^n,$

after which a projection, concatenation with proprioception, and time and noise embeddings are passed to an Action Transformer head that predicts a denoising vector field.

The perception module is defined over

$$o_t = \{I_t^i\}_{i=1\ldots m} \cup \{\ell_t\} \cup \{s_t\},$$

with encoder $E_p$, described as a pretrained ViT-style VLM such as SmolVLM-0.5B or Florence-2 (~0.9B). The encoder output is

$$Z_t = E_p(I_t^1,\dots,I_t^m,\ell_t) \in \mathbb{R}^{T \times d}.$$

Crucially, $Z_t$ is treated purely as a perception-language representation; action decoding is assigned entirely to the downstream head.

The action head is a vanilla Transformer encoder using pure self-attention and no cross-modal blocks. Two configurations are specified. The “Small” head has hidden size 768, depth 12, and 12 heads, for approximately 80M parameters. The “Large” head has hidden size 1024, depth 24, and 16 heads, for approximately 300M parameters. Its input token sequence of length $L$ is

$(I_t^1,\dots,I_t^m)$0

and its output is $(I_t^1,\dots,I_t^m)$1, the predicted denoising vector field.

The paper also clarifies the parameter-count convention. The VLM backbone has 0.5B parameters and the Large action head has approximately 0.3B parameters, for a total of approximately 0.8B. The system is nevertheless usually rounded to “≈ 0.5 B” by counting only the backbone. This distinction is important when comparing SimVLA’s scale to multi-billion-parameter VLA models.

3. Training recipe and datasets

SimVLA emphasizes standardization of training dynamics as a first-class component of the baseline. The simulation regime uses unified training on LIBERO-{Spatial, Object, Goal, Long}, with 10 tasks and 500 demonstrations each, plus SimplerEnv (Fractal & Bridge). Robustness is evaluated by direct zero-shot evaluation on LIBERO-PRO under Obj, Pos, Sem, and Task perturbations relative to the original setting. Real-robot finetuning uses the Galaxea Open-World Dataset, described as 500 h, 100 K trajectories, and a 23-DoF mobile-manipulator (Luo et al., 20 Feb 2026).

The default configuration pairs the Large action head with SmolVLM-0.5B. The action chunk horizon is $(I_t^1,\dots,I_t^m)$2, with ablations at 20 and 30. Image resolution is 128×128 for LIBERO and 224×224 for robot settings. Optimization uses AdamW with $(I_t^1,\dots,I_t^m)$3, $(I_t^1,\dots,I_t^m)$4, and $(I_t^1,\dots,I_t^m)$5. The learning rate is $(I_t^1,\dots,I_t^m)$6 for LIBERO and $(I_t^1,\dots,I_t^m)$7 for real-robot training, with cosine-decay or none. The VLM learning-rate multiplier is 0.1, corresponding to gentle backbone finetuning. The recipe uses no warmup, with optional 1k steps, runs for 150 K steps on LIBERO and Galaxea and 50 K on WidowX, and uses bfloat16 precision.

Setting	Value
LIBERO batch size	64×4 GPUs = 256
WidowX & Google batch size	80×4 = 320
Galaxea batch size	32×64 = 2048
Action chunk horizon	10
LIBERO image resolution	128×128
Robot image resolution	224×224
Optimizer	AdamW
LIBERO learning rate	2e-4
Real-robot learning rate	1e-4
VLM LR multiplier	0.1
Total steps	150 K or 50 K
Precision	bfloat16

The paper’s broader claim is that these apparently secondary choices are not incidental implementation details. Rather, they are treated as part of the experimental object itself, because uncontrolled differences in these settings can confound architectural comparisons.

4. Mathematical formulation and inference

SimVLA models an action chunk

$(I_t^1,\dots,I_t^m)$8

conditioned on $(I_t^1,\dots,I_t^m)$9. The learning objective is formulated via conditional flow matching. Let

$\ell_t$0

and sample $\ell_t$1. The noised chunk is defined as

$\ell_t$2

The action head is trained to minimize

$\ell_t$3

The normalization step scales actions to zero mean and unit variance (Luo et al., 20 Feb 2026).

Inference follows an ODE-based generation procedure. Starting from Gaussian noise, SimVLA integrates

$\ell_t$4

from $\ell_t$5 to $\ell_t$6 using $\ell_t$7 Euler steps, after which the final action chunk is denormalized and sent to the robot controller. In algorithmic terms, the VLM encoder first computes $\ell_t$8, a noisy action chunk $\ell_t$9 is initialized from Gaussian noise, the Action Transformer repeatedly predicts $s_t$0 conditioned on projected perception tokens, proprioception, the time embedding, and the current noised action, and the resulting state is updated by Euler integration until the final chunk is produced.

This formulation makes the action head an explicit denoising field predictor rather than a direct autoregressive decoder. A plausible implication is that the architecture’s simplicity is partly preserved because the conditional structure is concentrated in the input tokenization and objective, rather than in specialized cross-modal control blocks.

5. Benchmark performance

On the official LIBERO test set, SimVLA reports success rates of 99.4 on Spatial, 99.8 on Object, 98.6 on Goal, and 96.4 on Long, for an average of 98.6. In the same comparison, X-VLA (0.9 B) reports 98.1 average, VLA-Adapter (0.5 B) 97.3, OpenVLA-OFT (7 B) 97.1, and MemoryVLA (2 B) 96.7. These results are the basis for the paper’s claim that a minimal design can outperform larger and more complex models in simulation (Luo et al., 20 Feb 2026).

On LIBERO-PRO, the zero-shot robustness results averaged across suites under five perturbations are reported as 99 for Ori, 98 for Obj, 29 for Pos, 98 for Sem, and 10 for Task. The corresponding figures listed for TTO.5 (0.5 B) are 98, 98, 17, 96, and 1, and for OpenVLA (7 B) are 98, 97, 0, 97, and 0. The Pos and Task columns indicate that perturbation robustness is not uniformly saturated even when nominal benchmark performance is high.

On SimplerEnv WidowX tasks, SimVLA achieves 95.8 average success across spoon→towel, carrot→bowl, stack block, and eggplant→basket, compared with 91.7 for X-VLA, 71.9 for MemoryVLA, and 64.6 for FPC-VLA. On the Google Robot variant-aggregation benchmark over pick, move, and open subtasks, SimVLA reports 76.1 average success, slightly above X-VLA at 75.7, and ahead of SpatialVLA at 67.5 and RT-2-X at 65.6.

For real-robot zero-shot evaluation on the Galaxea R1 Lite, the reported setting comprises eight multi-stage tasks: store dolls, arrange egg, put flowers, put pens, wipe desktop, fold clothes, pick garbage, and open drawer. SimVLA is reported to achieve average success of approximately 80% on six tasks, while two tasks—“fold clothes” and “insert pen/flower”—are approximately 50–60% but match or exceed a heavily pretrained 70.5 baseline. The abstract separately states that SimVLA reaches on-par real-robot performance compared to pi0.5.

6. Ablations, interpretation, and limitations

The ablation study varies one factor at a time on LIBERO with fixed 150 K steps and the default Large head plus SmolVLM-0.5B. The default SimVLA score is 98.6 average success. Removing data shuffling reduces this to 9.9, removing action normalization to 12.3, setting the learning rate to $s_t$1 to 90.6, setting it to $s_t$2 to 72.7, and using a VLM LR multiplier of 1.0 to 44.2. By contrast, using the small action head yields 98.0, swapping to Florence-2 yields 97.7, using cross-attention injection yields 91.5, and using conditional AdaLN injection yields 91.1 (Luo et al., 20 Feb 2026).

Knob change	Avg (% success)
Default SimVLA	98.6
No data shuffling	9.9
No action normalization	12.3
LR = 5×10⁻⁵	90.6
LR = 5×10⁻⁴	72.7
VLM LR multiplier = 1.0	44.2
Use small action head (768×12×12)	98.0
Use cross-attention injection	91.5
Use conditional AdaLN injection	91.1
Swap to Florence-2 backbone	97.7

The paper’s stated takeaways are threefold. First, silent implementation details such as shuffling, normalization, and backbone LR scaling can move performance by 50+ points, in some cases more than introducing a new architectural module. Second, reducing the action-transformer scale or changing the VLM backbone degrades performance only marginally, by less than 1%, which is presented as evidence that major gains come from the training recipe rather than exotic control heads. Third, simple token concatenation plus self-attention outperforms more specialized conditioning layers under the same recipe.

These results sharpen two interpretive points. One is a caution against attributing benchmark gains to architectural novelty when training dynamics are not tightly controlled. The other is that SimVLA is best understood as a reproducible baseline rather than a claim that architectural innovation is unnecessary. Its stated purpose is to expose which factors materially drive performance so that future contributions can be evaluated against a stable, transparent reference.