StarVLA
StarVLA-α: Reducing Complexity in Vision-Language-Action Systems Jinhui Ye1,†
arXiv:2604.11757v1 [cs.RO] 13 Apr 2026
1
Ning Gao2,† Senqiao Yang3 Jinliang Zheng4 Zixuan Wang1 Pengguang Chen6 Yilun Chen5,‡ Shu Liu6 Jiaya Jia1,6,‡
HKUST
2
XJTU
3
CUHK
4
THU
5
Tongyi Lab, Alibaba Group
6
Yuxin Chen1
SmartMore Ltd.
Abstract Vision-Language-Action (VLA) models have recently emerged as a promising paradigm for building general-purpose robotic agents. However, the VLA landscape remains highly fragmented and complex: as existing approaches vary substantially in architectures, training data, embodiment configurations, and benchmark-specific engineering. In this work, we introduce StarVLA-α, a simple yet strong baseline designed to study VLA design choices under controlled conditions. StarVLA-α deliberately minimizes architectural and pipeline complexity to reduce experimental confounders and enable systematic analysis. Specifically, we re-evaluate several key design axes, including action modeling strategies, robot-specific pretraining, and interface engineering. Across unified multi-benchmark training on LIBERO, SimplerEnv, RoboTwin, and RoboCasa, the same simple baseline remains highly competitive, indicating that a strong VLM backbone combined with minimal design is already sufficient to achieve strong performance without relying on additional architectural complexity or engineering tricks. Notably, our single generalist model outperforms π0.5 by 20% on the public realworld RoboChallenge benchmark. We expect StarVLA-α to serve as a solid starting point for future research in the VLA regime. Code will be released at https://github.com/starVLA/starVLA. Date: April 2026 Project Page: https://starvla.github.io
1
Introduction
Recent progress in robotic manipulation has been increasingly driven by Vision-Language-Action (VLA) models, which aim to move beyond task-specific policies toward general-purpose robotic agents. Since the introduction of RT-series Brohan et al. (2023, 2022); Belkhale et al. (2024) as robotic foundation models, the field has rapidly evolved by leveraging large foundation models, scaling robot data Black et al. (2024a); Wu et al. (2024); Generalist AI (2025) and general multimodal supervision Intelligence et al. (2025a); Brohan et al. (2023); Yang et al. (2025b); Chen et al. (2025b); Ye et al. (2026) to achieve impressive policy transferability and task coverages Brohan et al. (2022, 2023); Kim et al. (2024); Octo Model Team et al. (2024); Black et al. (2024b); Intelligence et al. (2025a). As a result, a growing number of VLA systems demonstrate impressive results across a variety of robotic benchmarks Li et al. (2024d); Liu et al. (2024a); Mees et al. (2022); Mu et al. (2025); Chen et al. (2025a); Gu et al. (2023). Meanwhile, open-source efforts Kim et al. (2024); Intelligence et al. (2025b); Bjorck et al. (2025); Liu et al. (2024c); Cai et al. (2026) have broadened accessibility and accelerated experimentation. Despite the rapid development of VLA systems, the field still lacks a clear understanding of which components actually drive performance gains. Existing systems vary in model architectures, pre-training data, embodiment configurations, and benchmark-specific fine-tuning, making empirical comparison difficult to interpret. Reported improvements are often entangled with dataset choices, preprocessing pipelines, and benchmark-specific engineering, obscuring whether gains arise from modeling innovations or experimental †
Equal contribution
‡
Corresponding author
Heterogeneous robot data ?
StarVLA-𝛼 +
Simple Architecture Qwen+MLP
Minimal Data Processing Raw Action
MLP
CrossBenchmark Single
Arm Dual Arm Humanoid
LIBERO SimplerEnv RoboTwin RoboCasa
Fragmented VLA Design ?
Simple but Strong MLP
VLM
VLM
DiT
Delta Rot6D VLM
VLM
EEF
DiT
Raw Action Data
FAST
Heavy Data Engineering ?
Training strategies
Minimal Data Engineering
Data engineering
Action Type: Joint
Abs
Num.
EEF
Rel
Bin.
Action policy design
Delta Input:
Output:
State
Action Chunk
History
FAST
Rethinking Common Practices in VLA
All-in-One Generalist
Figure 1: Current VLA systems are difficult to compare due to heterogeneous robot datasets, fragmented architectures, and heavy benchmark-specific engineering. StarVLA-α removes these confounders with a simple VLM-based architecture, minimal data processing, and unified cross-benchmark training. This controlled baseline enables systematic analysis of action modeling, robot pretraining, and interface design, revealing that many commonly adopted complexities provide limited context-dependent benefits.
variation. In contrast to vision-language modeling (VLM), where training practices have gradually converged toward standardized recipes Li et al. (2024a); Dai et al. (2023); Liu et al. (2024b), VLA research remains highly fragmented. Establishing clearer methodological consensus is therefore increasingly important for guiding future progress in the field. However, reaching methodological consensus is a challenging and long-standing problem due to substantial heterogeneity across the VLA pipeline as shown in Fig. 1. First, pre-training data and embodiment configurations vary substantially across studies. Rapid evolution of robotic platforms and teleoperation pipelines has led to heterogeneous datasets with incompatible interfaces, action spaces, and normalization schemes Kim et al. (2024); Liu et al. (2024c). Robot embodiments span single-arm manipulators such as Franka and UR5 Franka Emika (2025); Universal Robots (2025), wheeled dual-arm systems Galbot (2025); Galaxea (2025); AgiBot (2025), and humanoid robots Fourier Intelligence (2025); Unitree Robotics (2025); AgiBot (2025), accompanied by differences in camera viewpoints and end-effectors, further entangling modeling choices with embodiment-specific preprocessing. Second, modeling and training strategies lack consensus. Existing VLA systems adopt diverse combinations of vision towers, language backbones, and action experts Octo Model Team et al. (2024); Kim et al. (2024); Li et al. (2024c, 2023b); Black et al. (2024a); Intelligence et al. (2025b); Team (2025), while design choices such as action parameterization and normalization for continuous robot states and controls remain poorly understood. Third, varied evaluation practices complicate comparison. Benchmark-specific hyperparameter tuning, dataset splits, and action chunking strategies are often required to achieve strong performance Li et al. (2024d); Liu et al. (2024a); Mu et al. (2025); Chen et al. (2025a); Nasiriany et al. (2024); Li et al. (2023a), and strong in-benchmark results do not necessarily translate to robustness under broader distribution shifts Pumacay et al. (2024); Nasiriany et al. (2024); Gao et al. (2025). To demystify the essential components of VLA systems, we propose StarVLA-α upon the infrastructure of StarVLA Community (2026), a simple yet strong baseline that serves as a starting point for systematically studying existing VLA paradigms. It is explicitly designed to reduce experimental confounding and isolate modeling effects. Rather than introducing additional architectural complexity, we deliberately minimize structural variations by employing a pre-trained VLM backbone (Qwen3-VL) without robot-specific pretraining or sophisticated action engineering. We follow official evaluation protocols and avoid benchmarkspecific tuning to ensure controlled and reproducible comparisons. The objective is not architectural novelty but methodological clarity: by controlling major sources of variation, StarVLA-α provides a controlled substrate for reassessing widely adopted VLA design choices under comparable conditions. Under this controlled setting, a strong VLM-based baseline matches or exceeds recent VLA systems while keeping the backbone, training data, and training settings identical. Under controlled conditions, we examine 2
the necessity of common VLA design choices along three axes: action head design, robot-specific pretraining, and data/interface engineering. Keeping the backbone, data scale, and training protocol identical, we compare several canonical VLM-to-VLA instantiations within a unified pipeline, including discrete token-based autoregressive decoding (FAST-style), direct continuous action regression with a lightweight MLP head (OpenVLA-OFT-style), diffusion/flow-matching based continuous action generation (π0 -style), and dualsystem designs that couple a VLM with a separate low-level action module (GR00T-style), finding that simple MLP action header remains highly competitive while more complex designs provide only scenariodependent gains (see Sec. 3.1). Robot pretraining by incorporating large-scale action data Collaboration et al. (2023); contributors (2025) is re-assessed. We observe that heterogeneous pretraining may impair crossembodiment generalization and that domain-aligned data yields conditional rather than overall improvements (Sec. 3.2). Finally, we revisit common engineering choices (e.g. auxiliary inputs, action output modeling). Overall, removing major confounders reveals that architectural and engineering complexity offers limited and context-dependent gains (Sec. 3.3). To mitigate potential benchmark-specific bias in single-benchmark evaluation, we further assess robustness under broader generalization regimes. We jointly train a unified model across LIBERO Liu et al. (2024a), SimplerEnv Minderer et al. (2022), RoboTwin 2.0 Chen et al. (2025a), and RoboCasa-GR1 Nasiriany et al. (2024); Bjorck et al. (2025) without benchmark-specific adaptation, using unified action padding across embodiments (Sec. 4). Under this multi-benchmark setting, the same simple baseline remains competitive, and in several cases superior to task-specific models. These results indicate that strong backbone initialization and unified training can support cross-task and cross-embodiment generalization without requiring additional architectural complexity. Our contributions are summarized as follows: • We present a simple yet strong VLA baseline that removes key confounders, showing that a streamlined VLM design can reach leading performance on four benchmarks spanning five embodiments. • Under controlled backbone, data, and training settings, we systematically re-evaluate common VLA design choices and find that added architectural/data engineering complexity yields smaller and more contextdependent gains than often assumed. • We further demonstrate that a single generalist model trained jointly across benchmarks, without taskspecific adaptation, can generalize across tasks and embodiments, supported by strong initialization and a standardized pipeline.
2
StarVLA-α
Since the introduction of RT-1 Brohan et al. (2022) in 2022, Vision–Language–Action (VLA) research has pursued general-purpose embodied agents built on foundation models. Along the way, the community has explored many design dimensions—vision backbones (e.g., SigLIP Zhai et al. (2023), DINO Oquab et al. (2023), CLIP Radford et al. (2021)), action heads (discrete tokens, continuous regression, diffusion, flow matching), and action/data pipelines (delta vs. relative actions; embodiment-specific preprocessing across eef/joint/6D pose). While these choices have driven steady gains, they have also fragmented the field: systems often become complex, hard to reproduce, and tightly tuned to benchmark-specific details, which can hurt transfer to new embodiments. Against this backdrop, we ask a simple question: can we cut through this complexity? Specifically, we test whether a strong VLM backbone can deliver competitive performance without elaborate architectures or heavy data engineering. To study this, we build a clean, transparent, and robust VLA baseline from scratch (Fig. 2). 2.1
A Simple and Unified VLA Framework
Our framework is guided by a minimal-sufficiency hypothesis: a strong VLM paired with a lightweight action head captures most of the benefits commonly attributed to more complex designs. Here, “clean” refers to two aspects: minimal data processing and a simple architecture. Minimal data processing. To promote generalization across diverse robot embodiments and benchmarks, we use a single minimal data pipeline shared across all environments. The model takes raw RGB images and the provided language instructions as input, without benchmark-specific engineering or custom formatting. We normalize actions using the training split only (zero mean, unit variance). For evaluation, we follow each 3
Embodiments
Action Type Choices
Action Chunk
Action Tokenizer
Benchmark-specific Evaluation
VL Backbone / Action Model Design Vision-language Models
Action Head
Bench 1
Flow Matching
Model B ModelB
Bench 2
Autoregressive
Model C ModelB
Bench 3
MLP
Generalist Model
Llama 2
DiT
Dinov2
PaliGemma
CLIP
Eagle 2
Bench 1 Abs Joint
Minimal Data Engineering
Qwen
Simple Model Design
Bench 2 Bench 3
Evaluation as All-in-one Generalist
RoboTwin2 RoboCasa
Model A ModelB
SigLip
LIBERO
History Inputs
Benchmarks
Development of VLAs Regime
SimplerEnv
Heavy Data Engineering
Simplified Pipeline of StarVLA-𝜶
Figure 2: Overview of StarVLA-α. We use a unified VLM backbone (Qwen3-VL) with minimal preprocessing and a lightweight MLP action head. This simple setup avoids specialized vision encoders, benchmarkspecific data pipelines, and complex action heads, while enabling consistent training and evaluation across diverse benchmarks.
benchmark’s official protocol. This unified preprocessing makes the framework directly applicable to new robot embodiments and benchmarks without additional adaptation. Clean architecture. We follow common practice and couple a VLM backbone with a lightweight action head for continuous action prediction. We instantiate the backbone with the Qwen family of models Wang et al. (2024b); Bai et al. (2025), specifically Qwen3-VL. We choose Qwen for two reasons: (i) it is a widely adopted open-source VLM with strong community support; and (ii) its unified design natively processes both vision and language inputs, avoiding the need to separately select and combine vision encoders (e.g., CLIP Radford et al. (2021), SigLIP Zhai et al. (2023)). On top of the VLM, we attach a simple MLP action head that reads the hidden state of a designated action token and regresses a chunk of continuous actions. The modular design also allows us to swap in alternative VLM backbones or action heads with minimal changes. Unified benchmark integration. To enable systematic evaluation, we integrate a diverse suite of manipulation benchmarks (e.g., LIBERO, SimplerEnv, RoboTwin 2.0, and RoboCasa-GR1) into a unified pipeline without benchmark-specific design. For each benchmark, we strictly follow its original data and evaluation protocols, applying only our minimal processing while keeping the action representation consistent. We confine heterogeneity to thin adapters that standardize observation formats, action interfaces, and evaluation entry points. As a result, the same model and training recipe run across all benchmarks without customization, and the framework remains easy to extend to new benchmarks. This setup also enables a more general evaluation regime: training a single model jointly across all benchmarks. We refer readers to Sec. 4 for detailed results in this unified multi-benchmark setting. 2.2
Experimental Setup
We evaluate our models on a diverse set of widely used manipulation benchmarks: LIBERO Liu et al. (2024a), SimplerEnv Li et al. (2024d), the dual-arm benchmark RoboTwin 2.0 Chen et al. (2025a), and the humanoid benchmark RoboCasa-GR1 Nasiriany et al. (2024); Bjorck et al. (2025). Benchmark details are provided in Appendix B. Baselines. We compare StarVLA-α against several representative VLA methods: FAST Pertsch et al. (2025), OpenVLA-OFT Kim et al. (2024), π0 Black et al. (2024a), and GR00T-N1.6 Bjorck et al. (2025). These prior methods are typically trained separately on each benchmark with their own task-specific data processing. For our approach, we consider two training protocols: (1) Specialist training, where we train StarVLA-α independently on each benchmark’s training set using our unified minimal data pipeline , and (2) Generalist training, where we merge all benchmarks’ data into a single training set and train a single model. We note that the Generalist model represents a large-scale unified training scenario and is included for completeness, for direct comparisons under similar computational budgets, we focus primarily on Specialist training. In the unified setting, actions from different robots are simply padded to a maximum dimension (here 32) with zeros, 4
Table 1: Performance comparison of StarVLA-α with existing VLAs. ∗ indicates that both clean and random data are used for training. Default StarVLA-α represents multiple models trained separately on each benchmark-specific dataset, while Generalist represents a single model jointly trained across all datasets. RoboTwin 2.0
RoboCasa-GR1
Spatial
Object
LIBERO Goal
Long
avg
WidowX
Google VA
Google VM
clean
clean∗
random∗
(avg of 24 tasks)
Specialist OpenVLA-OFT π0 π0 +FAST π0.5 GR00T-N1.6 StarVLA-α
97.6 96.8 96.4 98.8 97.5 99.0
98.4 98.8 96.8 98.2 98.5 99.8
97.9 95.8 88.6 98.0 97.5 98.5
94.5 85.2 60.2 92.4 94.4 94.1
97.1 94.1 85.5 96.9 97.0 98.8
31.3 27.1 39.5 46.9 62.0 64.6
54.3 54.8 60.5 68.4 65.3 70.2
63.0 58.8 61.9 72.7 67.7 76.0
– 46.42 – 60.2 – 50.3
– 65.9 – 82.7 – 88.2
– 58.4 – 76.8 – 88.3
– – – 37.0 47.6 53.8
StarVLA-α (Generalist)
98.7
99.7
98.6
94.2
97.8
65.2
69.8
74.3
–
88.7
87.8
57.3
Method
SimplerEnv
requiring no per-task engineering; more details are provided in Sec. 4. Training and implementation details are given in Appendix C. 2.3
Main Results
As shown in Table 1, StarVLA-α performs strongly across all benchmarks relative to prior VLA methods. On LIBERO, StarVLA-α achieves an average success rate of 98.8%, outperforming all previous approaches. On SimplerEnv, it exceeds the best existing method by a substantial margin (e.g., +6.8% on Google VM). On the more challenging dual-arm and humanoid settings, StarVLA-α reaches up to 53.8% success, highlighting the strength of a capable VLM backbone even with a lightweight action head. Moreover, under a unified generalist training setup, we find that training a single model on diverse data achieves competitive per-benchmark performance while notably improving on challenging benchmarks such as RoboCasa-GR1 (Sec. 4). Together, these results support our central hypothesis: a strong VLM, paired with a straightforward action head and minimal data preprocessing, can deliver highly competitive performance. More broadly, they suggest a practical way to reduce the field’s growing complexity: fix the backbone, standardize the data pipeline, and avoid task-specific engineering. This approach yields a strong, reproducible baseline that can serve as a solid foundation for future work.
3
Rethinking Common Practices in VLA Systems
As described in Sec. 2, StarVLA-α baseline is intentionally simple: it pairs a strong VLM (Qwen3-VL) with a lightweight MLP action head, uses minimally processed data, and introduces no state inputs, history frames, or additional pretraining. Despite this minimal design, StarVLA-α achieves state-of-the-art results across multiple benchmarks and substantially outperforms prior methods. This finding motivates a natural question: when a strong backbone is available, what actually drives VLA performance? In this section, we systematically analyze three commonly emphasized design choices: action head architecture, action-specific pretraining, and data engineering. 3.1
Do Different Action Head Designs Matter?
Motivation. Given that our simple MLP head already delivers strong performance, we ask whether more complex action heads (e.g. fast token predictors, diffusion models, or dual-system designs) provide additional benefits when paired with the same strong VLM backbone. Prior comparisons have often been confounded by differences in backbones and training recipes; our unified framework enables us to isolate the effect of the action head itself. Implementation details. As shown in Fig. 3, we evaluate four commonly used designs: (1) StarVLA-αFAST: Discrete action prediction via an autoregressive FAST tokenizer, similar to π0 -FAST Pertsch et al. (2025). (2) StarVLA-α: Continuous action regression with a lightweight MLP head applied to dedicated action tokens, following OpenVLA-OFT Kim et al. (2025). (3) StarVLA-α-GR00T: A dual-system architecture where the VLM serves as System 2 (high-level reasoning) and a flow-matching module acts as System 1 for action execution, following GR00T N1.5 Bjorck et al. (2025). (4) StarVLA-α-π: Diffusion-style continuous action prediction using a flow-matching expert, analogous to π0 Black et al. (2024a). 5
ACT
FAST
FAST
ACT
MLP
VLM Img
ACT
ACT
VLM
Text
Img
Text
VLM CLS
Img
ACT
ACT
DiT
VLM
Text
Img
ACT
DiT
Text
Figure 3: Action expert designs on StarVLA-α. From left to right: StarVLA-α-FAST, StarVLA-α (MLP regression), StarVLA-α -GR00T (dual-system flow matching), and StarVLA-α-PI (diffusion-style flow matching). Table 2: Performance comparison across action head designs. LIBERO
Method StarVLA-α StarVLA-α-FAST StarVLA-α-GR00T StarVLA-α-π
SimplerEnv
RoboTwin 2.0
RoboCasa-GR1
Spatial
Object
Goal
Long
avg
WidowX
Google VA
Google VM
clean
clean∗
random∗
(avg of 24 tasks)
99.0 98.3 98.9 98.0
99.8 98.4 99.6 99.2
98.5 97.3 98.4 98.2
94.1 91.6 95.3 93.6
98.8 97.8 98.7 98.1
64.6 35.6 65.3 65.9
70.2 58.8 70.7 72.8
76.0 60.1 75.3 76.6
50.3 46.4 48.8 50.8
88.2 72.5 88.0 88.1
88.3 83.2 88.5 88.8
53.8 45.0 52.8 48.9
Main results. As shown in Table 2, we compare four action head designs across several settings. Continuous action prediction consistently outperforms discrete action prediction (StarVLA-α-FAST) on nearly all benchmarks. Among the continuous-action variants, however, the three action heads achieve comparable performance. In particular, all methods reach over 98% success on LIBERO and around 65% on WidowX. Notably, the simplest design, StarVLA-α, achieves 53.8% on RoboCasa-GR1. Takeaway. These results suggest two key observations: (1) continuous action prediction is critical for strong performance and consistently outperforms discrete token-based approaches; and (2) given a powerful VLM, the choice of continuous action head has limited impact. Consequently, a lightweight MLP head serves as a simple, efficient, and competitive default. This result indicates that additional architectural complexity in the action head is unnecessary when the underlying VLM backbone is sufficiently strong. 3.2
Does existing action-specific pretraining matter?
Motivation. Most existing VLA models perform large-scale action-specific pretraining before fine-tuning on downstream tasks. For instance, OpenVLA uses the Open X-Embodiment (OXE) dataset Kim et al. (2024), π0.5 leverages diverse robot and multimodal data Intelligence et al. (2025b), and GR00T relies on large-scale simulation datasets Bjorck et al. (2025). Such pretraining is widely regarded as important for strong performance. However, our StarVLA-α baseline, built solely on a pretrained VLM (Qwen3-VL-4B) and without any action-specific data, already achieves competitive results. This observation raises a key question: given a strong VLM backbone, does additional action-specific pretraining provide further benefits? Experimental setups. To answer this question, we use the StarVLA-α architecture and keep all hyperparameters fixed. We compare four pretraining settings and evaluate them on RoboCasa-GR1 and RoboTwin: (1) StarVLA-α (VLM-based): No additional pretraining; the pretrained Qwen3-VL model is directly fine-tuned on task-specific data. (2) +OXE: The pretrained Qwen3-VL model is first trained on the OXE dataset Collaboration et al. (2023) and then fine-tuned on the task-specific data. (3) +InternData-A1: The pretrained Qwen3-VL model is first trained on the InternData-A1 dataset contributors (2025), which shares overlapping embodiments (and partially aligned action interfaces) with RoboTwin, and then fine-tuned on the task-specific data. (4) +RoboTwin-Rand: Qwen3-VL model is pre-trained on RoboTwin randomized data Chen et al. (2025a) (within the same domain) and then fine-tuned on the task-specific data. Results. As shown in Table 3, the StarVLA-α baseline achieves near-best performance when sufficient task-specific data is available, reaching 88.2 and 53.8 on RoboTwin 2.0 and RoboCasa-GR1, respectively. Adding large-scale pretraining data does not consistently improve performance; out-of-domain data such as OXE can even degrade results. Although pretraining with InternData-A1 or RoboTwin data improves 6
Table 3: Effects of additional robotic data pretraining. Mid-Pretraining
Traj. Num.
StarVLA-α + OXE + InternData-A1 + RoboTwin-Rand
232.6k 630k 25k
RoboTwin-Clean
RoboCasa-GR1
Clean 50 × 50
+Random ×100
+Random ×500
24 × 10
24 × 100
24 × 1000
50.3 30.2 63.6 79.7
78.5 40.6 80.4 84.1
88.2 83.6 88.6 88.8
9.8 1.2 2.8 2.2
39.4 17.7 27.6 27.3
53.8 27.8 35.4 33.3
Table 4: Ablation study on data engineering across benchmarks and data scales. Mid-Pretraining StarVLA-α + Proprioception + History frames + Delta action + Relative action
RoboTwin-2.0
RoboCasa-GR1
LIBERO avg
Clean 50 × 50
+Random ×100
+Random ×500
24 × 10
24 × 100
24 × 1000
98.8 98.5 97.8 98.1 98.7
50.3 60.8 44.8 48.7 51.1
78.5 79.6 76.2 77.8 77.9
88.2 88.0 87.4 85.6 87.3
9.8 12.5 10.2 15.8 13.6
39.4 42.1 33.2 43.2 40.6
53.8 54.2 52.6 54.8 55.5
RoboTwin performance, particularly in low-data regimes, it still reduces performance on RoboCasa, suggesting that even in-domain gains may not transfer across embodiments or tasks. Takeaway. Additional action-specific pretraining can improve performance when the pretraining data closely matches the target task, but it may hurt generalization to unseen domains. A strong VLM baseline already provides a solid foundation; further pretraining can therefore act as a double-edged sword and should be applied with caution. 3.3
Is Data Engineering Necessary?
Motivation. Beyond architecture and pretraining, many VLA models rely on various data engineering techniques to improve performance. These include perception-related inputs, such as proprioceptive states and stacked history frames, as well as action representations, such as absolute, delta, or relative actions. While widely used, the necessity of these techniques remains unclear, particularly when a strong VLM backbone is available. In this section, we systematically examine a set of common data engineering choices within StarVLA-α framework. We evaluate them across multiple benchmarks and data scales to determine whether they yield consistent improvements. Experimental setup. We study four commonly used data engineering choices: (1) Proprioception Black et al. (2024a); Bjorck et al. (2025): adding robot joint states as input, concatenated with VLM features before the action head. (2) History frames Li et al. (2025): stacking the previous two frames to provide temporal context. (3) Delta action Feng et al. (2026): predicting relative changes from the current joint position. (4) Relative action Feng et al. (2026): predicting actions in a reference coordinate frame (e.g., end-effector–centric). Each modification is applied to StarVLA-α while keeping all other training hyperparameters unchanged. We report results on three representative benchmarks: LIBERO (average over four tasks), RoboTwin 2.0, and RoboCasa-GR1 under different data scales. For RoboTwin 2.0, the data regimes include Clean 50 × 50, +Random 100, and +Random 500. For RoboCasa, we evaluate with 24 × 10, 24 × 100, and 24 × 1000 demonstrations. Results. As shown in Table 4, when the dataset is small, for example, Clean 50 × 50 on RoboTwin 2.0 or 24 × 10 on RoboCasa-GR1, certain data engineering techniques provide modest improvements. However, once sufficient task-specific data is available, these techniques offer little additional benefit and perform similarly to the baseline without data engineering. Takeaway. When built upon a strong VLM and a clean codebase, data engineering techniques can offer modest benefits when task-specific data is limited. However, their impact becomes negligible once sufficient task-specific data is available. 7
4
All-in-one Evaluation as a Generalist
In Sec. 2, we build a clean VLA framework that achieves strong performance across several individual benchmarks. In Sec. 3, we further rethink several existing techniques and analyze their impact on model training. Hence, after examining the factors that influence training, we move a step further in this section and investigate: What is an effective evaluation paradigm for assessing whether a model truly possesses generalization ability? Existing evaluation patterns. The Embodied AI community shares a unified ambition: to develop a generalist agent that can seamlessly operate across diverse tasks, environments, and robots. In practice, however, the research landscape remains fragmented. Several state-of-the-art systems need to fine-tune their models on benchmark-specific datasets to achieve strong results on individual benchmarks, but their performance drops sharply on others. This leads to a concerning trend in the field: newly proposed policies that excel on one benchmark often suffer sharp performance degradation when transferred to another, making it difficult to demonstrate true generalization ability. All-in-one evaluation as a generalist. In recent years, large language models (LLMs) have achieved remarkable success, demonstrating generalization capabilities across diverse tasks. A unified evaluation paradigm, which requires a single model to handle multiple benchmarks simultaneously, has driven progress in generalization within the LLM field. This suggests that an appropriate evaluation paradigm can meaningfully shape both model development and the broader direction of the field. Hence, intuitively, Embodied AI should undergo a similar paradigm shift: evaluating a single model across a wide range of diverse benchmarks to ensure that its capabilities are not tied to any specific environment. 4.1
Task Settings
In this setting, we utilize all datasets to train a single model jointly and directly evaluate it on multiple benchmarks, without any additional fine-tuning on benchmark-specific datasets. Specifically, we select LIBERO, SimplerEnv, RoboTwin 2.0, and RoboCasa-GR1 as the unified benchmark suite and train the model on the combined training sets of these benchmarks. 4.2
Experiments
Implementation details. We set the learning rate as 1 × 10−4 , batchsize as 256 and train on the 5 datasets. In addition, to address the differences in action dimensions across robots, we do not introduce any task-specific design. Instead, we pad the action space of robots with lower degrees of freedom so that all action vectors are uniformly expanded to 32 dimensions in our setting. Baselines. To further demonstrate the effectiveness of our method and the proposed setting, we report both specialist results, where models are trained only on individual datasets, and results from the generalist training setting. In addition to comparing with our model, we also evaluate several state-of-the-art methods, such as π0.5 and GR00T-N1.6. Results. As shown in Table 5, we compare our model trained under the generalist setting, where all datasets are jointly used for training, with specialist models trained on individual benchmarks. Our generalist model consistently achieves sota or competitive performance across most benchmarks. In particular, on the challenging RoboCasa-GR1 benchmark with 24 sub-tasks, our jointly trained model improves performance by 3.5%. These results suggest that a single model can effectively handle diverse tasks and robot embodiments, supporting the development of more unified evaluation paradigms for embodied AI. 4.3
Discussion and Analysis
Our method is simple: it directly pads all actions to the same dimension and uses Qwen3-VL as the pretrained model, yet achieves strong performance. Therefore, in this section, we discuss and analyze what the most critical factor is in this generalist setting and why such a simple method performs so strongly. We examine this question from multiple perspectives, including action processing, model size, model initialization, and the impact of batch size. Do we truly need specific action designs for each embodiment? Previous studies, such as ABot-VLA Yang et al. (2026) and LingBot-VLA Wu et al. (2026), have proposed complex, robot-specific solutions, includ8
Table 5: Performance comparison between generalist and specialist settings. Specialist represents multiple models trained separately on each benchmark-specific dataset, while Generalist represents a single model jointly trained across all datasets. Settings
LIBERO
Method
SimplerEnv
RoboTwin 2.0
RoboCasa-GR1
Spatial
Object
Goal
Long
avg
WidowX
Google VA
Google VM
clean
clean∗
random∗
(avg of 24 tasks)
π0.5 GR00T-N1.6
98.8 97.5
98.2 98.5
98.0 97.5
92.4 94.4
96.9 94.1
46.9 67.8
68.4 41.5
72.7 35.2
60.2 –
82.7 –
76.8 –
37.0 47.6
Specialist
StarVLA-α-π StarVLA-α-GR00T StarVLA-α
98.0 98.9 99.0
99.2 99.6 99.8
98.2 98.4 98.5
93.6 95.3 94.1
98.1 98.7 98.8
65.9 65.3 64.6
72.8 70.7 70.2
76.6 75.3 76.0
50.8 48.8 53.4
88.1 88.0 88.2
88.8 88.5 88.3
48.9 52.8 53.8
Generalist
StarVLA-α
98.7
99.7
98.6
94.2
97.8
65.2
69.8
74.3
–
88.7
87.8
57.3
Action Head A
Action Head B
Action Head C
Simple Padding
Figure 4: Comparison of action parameterization for multiple embodiments. Left: RDT Action. Middle: Multi-Action Head. Right: Simple Padding strategy.
ing unified action spaces and multi-action heads tailored to each robotic embodiment. However, modern vision–language models (VLMs) possess sufficient intelligence and parameter capacity to handle diverse tasks. Therefore, can we instead adopt a simple padding strategy and allow the VLA model itself to recognize and manage tasks across multiple embodiments? As shown in Table 6, we compare simple padding strategy with RDT Action and the Multi-Action Head (Fig. 4). Our approach achieves comparable performance on LIBERO and RoboTwin 2.0, while improving results on Google Robot VM and RoboCasa-GR1 by 2.9% and 4.8%, respectively. These results suggest that complex specialist designs may be unnecessary for challenging cross-embodiment tasks. What is the influence of model size? To further investigate the impact of model size on VLA performance in this general all-in-one setting, we evaluate three pretrained Qwen3-VL models (2B, 4B, and 8B) under the same experimental setup. As shown in Fig. 5, the 4B model achieves significant performance improvements on Simpler compared with the 2B model. Additional results in Appendix D further show that this improvement generalizes beyond a single benchmark, yielding gains of 18.1% on WidowX and 6.6% on RoboCasaGR1. However, compared with the 4B model, the 8B model does not demonstrate substantial additional improvements, with gains remaining within 1%. These results suggest that, under the current training scale and scenarios, the model size should not be too small, but a 4B parameter scale is sufficient.