Building generalist embodied agents requires integrating perception, language understanding, and action, which are core capabilities addressed by Vision-Language-Action (VLA) approaches based on multimodal foundation models, including recent advances in vision-language models and world models. Despite rapid progress, VLA methods remain fragmented across incompatible architectures, codebases, and evaluation protocols, hindering principled comparison and reproducibility. We present StarVLA, an open-source codebase for VLA research. StarVLA addresses these challenges in three aspects.

First, it provides a modular backbone–action-head architecture that supports both VLM backbones (e.g., Qwen-VL) and world-model backbones (e.g., Cosmos) alongside four representative action-decoding paradigms, all under a shared abstraction in which backbone and action head can each be swapped independently. Second, it provides reusable training strategies, including cross-embodiment learning and multimodal co-training, that apply consistently across supported paradigms. Third, it integrates major benchmarks, including LIBERO, SimplerEnv, RoboTwin 2.0, RoboCasa-GR1, and BEHAVIOR-1K, through a unified evaluation interface that supports both simulation and real-robot deployment.

StarVLA also ships simple, fully reproducible single-benchmark training recipes that, despite minimal data engineering, already match or surpass prior methods on multiple benchmarks with both VLM and world-model backbones. To our best knowledge, StarVLA is one of the most comprehensive open-source VLA frameworks available, and we expect it to lower the barrier for reproducing existing methods and prototyping new ones. StarVLA is being actively maintained and expanded; we will update this report as the project evolves. The code and documentation are available at github.com/starVLA/starVLA.

Embodied AI is advancing toward general-purpose agents that integrate perception, language understanding, and action in the physical world, driven in part by recent breakthroughs in large foundation models (OpenAI, 2023; Bai et al., 2025a; Gao et al., 2025). Vision-Language-Action (VLA) models have emerged as a dominant paradigm for this goal, with a diverse range of design choices. Existing approaches can be broadly grouped into two families: VLM-based methods, which repurpose the language model's representational capacity for action decoding, and world-model-based methods, which employ generative architectures to jointly model action distributions and future observations. While both directions have shown strong promise, they are often developed in isolation, with different codebases, interface assumptions, and evaluation protocols, making it challenging to systematically compare them and understand the trade-offs between different design choices.

Fragmentation hinders systematic exploration. Despite this progress, VLA research remains hindered by fragmentation at multiple levels. At the architecture level, existing approaches (Kim et al., 2025; Brohan et al., 2022, 2023; Bjorck et al., 2025; Black et al., 2024; Intelligence et al., 2025a; Wu et al., 2026; Li et al., 2026) adopt diverse action-decoding designs, from VLM-native methods (autoregressive tokenization, parallel regression) to generative-model-based methods (diffusion, flow matching), making systematic comparison across paradigm families difficult. At the system level, methods are released with tightly coupled assumptions on model architecture, data processing, and training pipelines, limiting component reuse across projects. At the evaluation level, results are reported on disjoint subsets of benchmarks with inconsistent protocols, making fair comparison infeasible.

Together, these issues create a “Tower of Babel” for VLA research, where ideas are difficult to compare, reproduce, or recombine. We attribute this fragmentation to the lack of a unified abstraction for VLA systems. Existing codebases (Bjorck et al., 2025; Black et al., 2024) are largely method-specific and do not support (i) modular composition across different action-decoding paradigms, (ii) reusable training across heterogeneous data sources, or (iii) standardized evaluation and deployment across benchmarks and embodiments.

StarVLA: a unified platform for exploring embodied intelligence. We introduce StarVLA, an open-source research platform that brings VLM-based and world-model-based VLA paradigms into a unified modular framework. The core design is a backbone–action-head decomposition, where a shared vision-language backbone encodes the scene and instruction, and a pluggable action head maps the resulting representation to motor commands. This formulation is flexible enough to support a wide range of existing approaches, including autoregressive tokenization, parallel regression, flow-matching denoising, and dual-system reasoning, with re-implementations that match or in some cases exceed reported performance. In practice, StarVLA provides three core capabilities:

• Unified VLA frameworks: StarVLA implements four representative paradigms under the shared backbone–action-head abstraction (Section 2): StarVLA-FAST (autoregressive tokenization), StarVLA-OFT (parallel regression), StarVLA-\pi (flow-matching denoising), and StarVLA-GR00T (dual-system reasoning). Crucially, both VLM backbones (e.g., Qwen3-VL) and world-model backbones (e.g., Cosmos-Predict2) are supported as drop-in alternatives, enabling direct comparison between VLM-based and world-model-based research paths under identical training and evaluation conditions. All variants share the same data interface and downstream infrastructure; only the backbone or the action head differs, enabling researchers to isolate the effect of any single design choice while holding all others constant.

• Flexible training recipes: StarVLA treats cross-embodiment learning and multimodal co-training as reusable, paradigm-agnostic configurations rather than method-specific add-ons. The same training infrastructure supports supervised action learning, co-training with web-scale vision-language data to preserve multimodal reasoning, and cross-embodiment pretraining across heterogeneous robot datasets. Every recipe applies uniformly to all supported paradigms, making it straightforward to study how training strategies interact with different architectural choices.

• Broad benchmark integration: StarVLA integrates five mainstream benchmarks (LIBERO, SimplerEnv, RoboTwin 2.0, RoboCasa-GR1, and BEHAVIOR-1K) through a unified server-client testing interface, enabling controlled comparison across environments and embodiments. For each benchmark, we provide simple, fully reproducible training recipes with minimal data engineering that already achieve competitive or state-of-the-art performance under both VLM and world-model backbones, lowering the barrier for the community to build upon. The same interface supports both simulation evaluation and real-robot deployment without code changes, closing the gap between research exploration and practical deployment.

To position StarVLA within the existing ecosystem, we compare it with representative open-source VLA systems across key capabilities in Table 1. To the best of our knowledge, StarVLA is the first platform to bring these capabilities together within a unified interface. Leveraging the controlled comparisons enabled by this framework, StarVLA achieves competitive, and in some cases state-of-the-art, performance across multiple benchmarks with both VLM and world-model backbones, demonstrating that the platform serves not only as a research toolkit but also as a provider of strong, easy-to-reproduce baselines.

A generalized VLA perspective. Beyond its engineering utility, StarVLA also suggests a broader perspective on unifying diverse VLA approaches. Empirically, we find that a single backbone–action-head abstraction can accommodate VLM-based decoding, generative-model-based decoding, and dual-system architectures, all within a shared data pipeline, training loop, and evaluation protocol. This observation indicates that VLM-based and world-model-based methods may be better understood not as fundamentally distinct paradigms, but as variations within a common structural framework, differing primarily in the form of auxiliary learning signals (e.g., language-aligned reasoning or future observation prediction). We refer to this as the generalized VLA perspective. Rather than a purely conceptual viewpoint, it arises from the practical unification enabled by StarVLA: when differences in infrastructure are minimized, underlying commonalities become more apparent. We hope this perspective encourages more systematic and cumulative exploration of robotic foundation models.

The rapid evolution of Vision-Language-Action (VLA) models has led to a wide range of heterogeneous designs, with varying preprocessing pipelines, model boundaries, and inference assumptions. While this diversity enables rapid exploration, it often hinders reproducibility and makes fair comparison difficult. To address this, StarVLA adopts a unified framework abstraction at the system level: each method is implemented as a modular component with explicit training and inference interfaces, such that algorithmic differences are isolated to a minimal set of interchangeable modules.

Abstraction of VLA systems. Beyond the system-level abstraction, we introduce a unified policy-centric formulation of VLA models. Prior work often distinguishes between VLM-based policies (VLA) and world-model-based approaches (WAM); here, we place them under a common perspective centered on action generation.

As illustrated in Fig. 1, we model a VLA system as a policy that maps vision-language (VL) inputs to future action (A) sequences and optional auxiliary outputs: where:

• \mathbf{x}_{\leq t} = \{o^{\mathrm{vis}}_{\leq t}, o^{\mathrm{depth}}_{\leq t}, o^{\mathrm{tactile}}_{\leq t}, \ldots\} denotes the multimodal observation history up to time t, which may include visual observations, depth maps, tactile feedback, proprioceptive states, or other sensor modalities;
• \ell is the language instruction describing the task;
• \mathbf{a}_{t:t+k} represents the predicted k-step action chunk from time t to t+k;
• \mathbf{y}_{\mathrm{aux}} denotes optional auxiliary outputs over the future horizon, such as predicted future visual observations o^{\mathrm{vis}}_{t+1:t+k}, intermediate language reasoning or sub-goal descriptions \ell_{\mathrm{plan}}, or other modality predictions.

This formulation abstracts away intermediate representations and implicitly marginalizes over latent predictions when present, allowing both direct policies and model-based approaches to be expressed within a common interface.The training objective takes the general form where \mathcal{L}_{\mathrm{action}} supervises the predicted actions, and \mathcal{L}_{\mathrm{aux}} serves as an inductive bias that shapes the learned representation. Different VLA paradigms can then be interpreted as instantiations of this formulation with distinct learning signals:

• Direct VLA Modeling sets \mathcal{L}_{\mathrm{aux}}=0, optimizing actions alone.
• VLM-based VLA introduces language-aligned auxiliary objectives, such as sub-task planning, spatial grounding, or structured reasoning supervision, requiring the model to generate language tokens as auxiliary outputs.
• WM-based VLA incorporates future observation prediction (e.g., images or videos), either as an auxiliary objective or as an implicit latent structure that supports action generation, where the model must predict visual states as auxiliary outputs.

Under this view, seemingly different paradigms such as VLM-based, world-model-based, and direct policies can be understood as variations of a shared policy formulation with different inductive biases. This perspective simplifies comparison while remaining compatible with both step-wise execution and multi-step open-loop control.

Embodied agents interact continuously with the physical world, where vision serves as the primary modality for perceiving scene structure, object identity, spatial relations, and interaction affordances.

Vision-language foundation models. This central role of vision has driven advances in visual representation learning, from supervised models such as ResNet (He et al., 2016) and Vision Transformers (Dosovitskiy et al., 2021) to scalable self-supervised approaches (Oquab et al., 2023) and video pretraining that captures temporal structure. Building on these backbones, language-aligned pretraining (Radford et al., 2021; Zhai et al., 2023) enables shared vision–language representations, while promptable systems such as SAM (Kirillov et al., 2023; Liu et al., 2023b) extend open-world perception. Together with instruction-tuned VLMs (Liu et al., 2023a; Chen et al., 2023; Karamcheti et al., 2024; Bai et al., 2025b; OpenAI, 2024; Gemini Team, Google, 2024) and generative video models (Gao et al., 2025; Google DeepMind, 2025), these advances significantly enhance perceptual grounding. However, perception alone is insufficient: embodied agents must also reason over language-conditioned goals and predict environment dynamics under action. Existing models are not inherently designed for action generation or visuomotor control (Zhao et al., 2023; Dhariwal and Nichol, 2021; Ze et al., 2024).

Vision-language modeling for robotic perception and reasoning. Vision-language pretraining grounds perception in language, providing a scalable interface for task specification and high-level reasoning (Radford et al., 2021; Zhai et al., 2023). Extending this paradigm, Vision-Language-Action (VLA) models incorporate action supervision to unify perception, language, and control (Brohan et al., 2022, 2023; Kim et al., 2024; Black et al., 2024; Intelligence et al., 2025b; Bjorck et al., 2025). Early works (Nair et al., 2022; Xiao et al., 2022) show that strong visual priors improve control, while VLA models directly map observations and instructions to actions via behavior cloning or policy learning. By transferring large-scale semantic knowledge into control, they improve instruction following and cross-task generalization, often outperforming prior robotic policies (Zhao et al., 2023; Chi et al., 2024a; Ze et al., 2024). Recent work extends these models to humanoid loco-manipulation (Wei et al., 2026).

To preserve reasoning capabilities, subsequent approaches explore multimodal co-training (Driess et al., 2025; Ye et al., 2026a; Chen et al., 2025c; Zeng et al., 2024; Yang et al., 2025c; Zhou et al., 2025), while others scale teleoperated datasets (Collaboration et al., 2023; Khazatsky et al., 2024; Wu et al., 2024; AgiBot, 2025; Ebert et al., 2021; Duan et al., 2024). However, these datasets remain limited in task, language, and scene diversity (Shi et al., 2025; Chi et al., 2024b), motivating portable data collection (Generalist AI, 2025; Liu et al., 2024b; Chi et al., 2024b). Meanwhile, tightly coupled pipelines hinder reproducibility, modularity, and scalability, highlighting the need for unified frameworks.

Video-based world model for robotic dynamics and interaction. Orthogonal to language-based scaling, video-based world models learn physical dynamics via visual prediction. Video captures motion, contact, and causality more effectively than static data. Early methods augment VLA policies with predictive latent modeling (Zheng et al., 2025b; Bjorck et al., 2025; Ye et al., 2025), while large-scale video pretraining enables planning with minimal robot data (Assran et al., 2025; Jang et al., 2025). Later work treats video as a primary policy substrate, either unifying policy, simulation, and evaluation or decoupling planning from control (Du et al., 2023; Ko et al., 2024; Pai et al., 2025; Chen et al., 2025a).

Action-conditioned world models further support policy evaluation and improvement: imagined rollouts achieve strong performance (Wu et al., 2023), while recent systems enable counterfactual replay and safety evaluation (1X World Model Team, 2025; Team et al., 2025). Other approaches use controllable world models for trajectory generation, reinforcement learning, or scalable data synthesis (Guo et al., 2025; Jiang et al., 2026; GigaWorld Team et al., 2025; GigaBrain Team et al., 2026; Qiu et al., 2026). Recent work emphasizes causal consistency, controllability, and closed-loop efficiency by integrating action and value prediction into pretrained video models or jointly learning dynamics and control (Kim et al., 2026; Li et al., 2026; Cai et al., 2026; Gao et al., 2026; Zhu et al., 2025; Yuan et al., 2025). Some approaches formulate joint video–action prediction as policy learning or analyze gains from test-time imagination versus co-training (Ye et al., 2026b; Yuan et al., 2026). Additionally, human video provides scalable motion priors, with egocentric pipelines enabling transferable behaviors across tasks and embodiments (Hoque et al., 2025; Yang et al., 2025b; Zheng et al., 2026).

Above vision-language pretraining and video-based world modeling scale embodied intelligence along complementary but largely fragmented axes, motivating StarVLA's design choice to separate what should vary across methods from what should remain stable across training, evaluation, and deployment.

While the foundation models surveyed above provide powerful visual-linguistic representations, they are not natively designed for action generation. A key design goal of StarVLA is to make these VL foundation models VLA-ready: we provide a unified I/O interface contract and a compositional architecture that allow diverse action decoding strategies to be flexibly composed on top of the same VL backbone.

Unified I/O Interface. All framework modules in StarVLA inherit from a common base class and expose two methods that share a unified input/output (I/O) interface: both training and inference consume raw, environment-level observations identical to what the robot receives at deployment time.

• forward({raw images, str, ...}) \rightarrow {raw images, str, ...}: the training entry point. It receives a batch of raw samples, each containing multi-view RGB images, a natural-language instruction, and an action chunk, and returns a loss dictionary.
• predict_action({raw images, str, ...}) \rightarrow {normalized_actions, ...}: the inference entry point. It accepts the same observation format (minus ground-truth actions) and returns predicted action chunks.

By deliberately adopting this unified I/O interface, where training inputs mirror real deployment observations rather than relying on heavily preprocessed dataloader tensors, we minimize train/test distribution mismatch, a common source of silent performance degradation in VLA systems.

This design choice reflects a deeper invariant of robotic deployment: regardless of how different VL foundation models are pretrained—what tokenization scheme they adopt, how they resize or partition images, or what auxiliary objectives they optimize during pretraining—at inference time every model must ultimately accept the same raw sensor streams that the physical robot provides and produce executable motor commands. The unified I/O interface codifies this deployment-time invariant as the system's first-class contract, ensuring that any VL model whose inference path can consume raw observations is immediately compatible with StarVLA, without requiring users to reverse-engineer or replicate model-specific preprocessing pipelines. Crucially, this same invariant-driven principle extends naturally to the internal architecture, as we describe next.

Compositional framework. Applying the same principle internally, we decompose every VLA method into two explicitly separated components connected by a standardized representation contract: a VL backbone (e.g., Qwen2.5-VL, z) that consumes raw multimodal observations and exposes hidden-state representations through a common output specification, and a pluggable action head that reads those representations through a corresponding input specification and converts them into motor commands. Each framework assembles itself through the same two-step composition (first loading the backbone, then attaching an action head), with both components configured declaratively via YAML. Because the outer system boundary (raw observations \to actions) and the inner backbone–head boundary (multimodal inputs \to hidden states \to actions) are both governed by standardized contracts, StarVLA achieves bidirectional modularity: backbone and action head can each be replaced independently without affecting the other or any surrounding infrastructure.

This modularity provides flexibility across different stages of VLA development. For researchers, it supports rapid experimentation in multiple directions. New action decoding paradigms can be prototyped by implementing and registering an action-head module, while new vision-language backbones—such as instruction-tuned VLMs (e.g., Qwen2.5-VL (Bai et al., 2025b), InternVL (Cai et al., 2026)) or video-native models (e.g., Cosmos (Kim et al., 2026))—can be integrated through a lightweight adapter that conforms to a shared representation interface. Once integrated, these backbones can be evaluated across different action heads without requiring per-method modification. For training infrastructure, the standardized interfaces allow much of the upstream and downstream stack (e.g., training pipelines, benchmark harnesses, and deployment services) to remain largely backbone- and action-head-agnostic, reducing the need for method-specific code paths as new paradigms or models are introduced. For deployment, switching between different backbones or action paradigms can be handled through configuration changes, without requiring code-level modifications.

Under this unified abstraction, we implement four paradigms spanning the major action decoding families in the current VLA literature, as illustrated in Fig. 2. All variants share the same VL backbone, the same base class, and the same forward/predict_action contract, differing only in how they extract actions from the backbone's representations:

• StarVLA-FAST (\pi_{\text{fast}}): Appends a FAST tokenizer (Pertsch et al., 2025) to the VL backbone and autoregressively generates discrete action tokens via next-token prediction, using the LLM's own vocabulary space.
• StarVLA-OFT: Attaches a lightweight MLP that reads the hidden states of predefined action tokens and regresses continuous actions in parallel (L1 loss), following OpenVLA-OFT (Kim et al., 2025)—the simplest form of pluggable head.

• StarVLA-\pi (\pi_0): Integrates a layer-wise cross-DiT flow-matching action expert, conditioned on multi-layer VL hidden states via cross-attention, and predicts continuous actions through iterative denoising, following \pi_0 (Black et al., 2024).
• StarVLA-GR00T: Adopts a dual-system design where the VL backbone serves as System 2 (slow reasoning) and a DiT-based flow-matching module serves as System 1 (fast action generation), consistent with GR00T N1.5 (Bjorck et al., 2025). This variant demonstrates that even fundamentally different inference-time compute patterns can coexist under the same interface.

This spectrum, from VLM-native decoding (autoregressive tokenization, parallel regression) to generative-model-based decoding shared with world-model architectures (iterative flow-matching denoising, dual-system reasoning), shows that the proposed compositional architecture and unified interface are broadly applicable. Adding further paradigms requires only implementing and registering a new action head; the backbone, training loop, and evaluation pipeline remain unchanged.

The StarVLA codebase supports several practical training regimes for VLA policies, ranging from standard supervised fine-tuning (SFT) on downstream robot datasets to multi-objective co-training with vision–language (VLM) web data and cross-embodiment co-training on mixed robot embodiments. All training pipelines are implemented in explicit PyTorch loops built on Accelerate + DeepSpeed for distributed execution, while preserving a unified YAML configuration interface across methods. Figure 3 summarizes the supported training modes and how data streams connect to the unified model framework.

The most direct training mode is robot-only supervised learning, where the policy is trained to predict continuous actions from observations and language instructions. In our codebase, this training path is implemented in starVLA/training/train_starvla.py. The objective is the action modeling loss returned by the framework forward() method (e.g., action_loss in the output dict).

Optimization setup. We support (i) full-parameter fine-tuning and (ii) selective freezing of submodules via trainer.freeze_modules (comma-separated module paths). To stabilize training across heterogeneous components, the optimizer can use multiple parameter groups with different learning rates (e.g., separate LR for qwen_vl_interface and the action model) configured by trainer.learning_rate. Training uses bfloat16 autocast, gradient accumulation, gradient clipping, and a cosine schedule with a minimum learning rate.

Robot-only SFT can over-specialize the VLM backbone to a narrow instruction distribution. To preserve general-purpose visual reasoning and language grounding while learning action prediction, StarVLA supports a co-training regime that interleaves robot action learning with a VLM loss on multimodal web data. This mode is implemented in starVLA/training/train_starvla_cotrain.py.

Dual-loader multi-objective training scheme. Co-training uses two dataloaders (VLA and VLM) and performs two forward/backward passes per optimization step: (i) a VLA forward pass through the framework forward() to obtain action_loss, and (ii) a VLM forward pass through qwen_vl_interface to obtain the language modeling loss. The VLM loss is scaled by trainer.loss_scale.vlm in config, enabling a controlled trade-off between action learning and VLM capability retention.

To support cross-embodiment generalization, the codebase provides a unified LeRobot mixture dataset interface that allows training on heterogeneous robot datasets with different embodiments, action conventions, and camera setups. In config, users select a named mixture through datasets.vla_data.data_mix, which maps to a list of (dataset name, sampling weight, robot type) tuples. At runtime, the mixture is materialized as a LeRobotMixtureDataset, which samples trajectories across datasets according to the specified weights and tracks embodiment tags based on robot type. This design makes “cross-embodiment pretraining” an operational configuration choice, rather than a bespoke training script.

Beyond supervised and co-training regimes, we plan to support reinforcement learning (RL) fine-tuning as an extension of the same framework abstraction, collaborating with the RLinf project (https://github.com/RLinf/RLinf). At the time of writing, RL fine-tuning is an ongoing integration effort; the current public codebase focuses on supervised and co-training pipelines to build up a strong robotic foundation model.

StarVLA adopts a thin server–client testing abstraction so that benchmark-side evaluation code remains close to the official implementations, while model-side inference is standardized. In practice, a checkpoint is loaded by baseframework.from_pretrained() and hosted as a lightweight WebSocket policy server in the StarVLA runtime environment. The benchmark evaluator, which may live in a different conda environment with its own simulator dependencies, interacts with the model through a small client wrapper rather than importing framework code directly. This decoupling is particularly useful for benchmarks such as LIBERO, SimplerEnv, and RoboTwin, whose official evaluators each carry different dependency stacks and control loops.

Inference interface. All framework variants expose the same inference entry point, Framework.predict_action(), and the server forwards incoming payload dictionaries to this method with minimal routing logic. The benchmark-side client packages observations into a single dictionary, typically containing image (single- or multi-view RGB observations), lang (task instruction), and optional fields such as state, timestamps, or episode metadata. The payload is serialized with msgpack and sent to the policy server, which returns a dictionary containing model outputs such as normalized_actions. Because the communication contract is action-head-agnostic, switching from OFT to FAST, \pi, or GR00T does not require modifying benchmark code.

Benchmark-specific adapters. In StarVLA, benchmark differences are isolated in lightweight interface files such as model2libero_interface.py, model2simpler_interface.py, and model2robotwin_interface.py. These adapters translate raw environment observations into the common StarVLA example format and post-process returned actions into the benchmark's native control API. Typical responsibilities include resizing images to the training resolution, reading dataset_statistics.json from the checkpoint directory for action unnormalization, converting chunked normalized predictions into executable actions, applying action ensembling, and handling benchmark-specific conventions such as sticky grippers or delta/relative-to-absolute action conversion. This design keeps the core policy server benchmark-agnostic while preserving faithful evaluation under each official protocol.

The same client-server contract also supports real-robot or hosted-benchmark deployment. In this setting, the robot controller plays the role of the benchmark client: it captures camera observations, assembles the same example dictionary used in simulation, queries the remote policy server, and executes the returned action on hardware. As a result, the control loop, safety logic, and device-specific middleware remain outside the StarVLA model runtime, while the model service remains unchanged.

Deployment interface. This separation makes deployment much less intrusive. The model stack can stay in a GPU-oriented inference environment, whereas the robot-side process can remain integrated with vendor SDKs, ROS nodes, or hosted evaluation platforms such as RoboChallenge. More importantly, the exact same checkpoint can be reused across simulation and real-robot settings as long as the client provides observations in the agreed dictionary format and applies the appropriate benchmark- or robot-specific post-processing. In this sense, StarVLA treats deployment as a continuation of the same testing paradigm rather than as a separate engineering path.

Recent vision-language-action (VLA) research has made rapid progress across a wide range of benchmarks. However, most existing methods are evaluated on only a limited number of environments, and their implementations often differ substantially in preprocessing pipelines, policy interfaces, and evaluation protocols. These inconsistencies hinder fair cross-paper comparison and weaken reproducibility.

StarVLA aims to provide simple and reproducible baselines across a diverse benchmark suite by: (i) adhering as closely as possible to the official training and evaluation workflows of each benchmark, with minimal data engineering and environment-specific modifications, and (ii) standardizing the policy-side interface. Concretely, all StarVLA variants expose a unified lightweight WebSocket service, enabling different benchmark runners to interact with a shared inference endpoint. This design facilitates seamless integration and simplifies scaling to additional benchmarks.

To facilitate reproducibility, StarVLA defines a unified integration interface for benchmark onboarding. Specifically, each benchmark integration is structured around three aligned components: (i) a checkpoint package containing the saved config.yaml and dataset_statistics.json, (ii) a runnable training entry (YAML configuration and launch script under examples/<BENCH>/train_files/), and (iii) a runnable evaluation workflow that launches a policy server and invokes the official benchmark evaluator (typically under examples/<BENCH>/eval_files/). This design ensures that benchmark-specific workflows remain reproducible while maintaining a consistent policy interface across environments.

StarVLA integrates a diverse set of manipulation benchmarks spanning different simulators, embodiments, and protocols, including LIBERO, SimplerEnv, RoboTwin 2.0, RoboCasa GR1 Tabletop Tasks, and BEHAVIOR-1K. The experiments section reports detailed results and comparisons under each benchmark's official evaluation protocols.

LIBERO. LIBERO (Liu et al., 2024a) is a widely used benchmark for language-conditioned robot manipulation and lifelong robot learning. It contains 130 manipulation tasks organized into four suites: Spatial, Object, Goal, and Long, each targeting a different form of generalization, including spatial variation, object-centric manipulation, goal-conditioned execution, and long-horizon dependencies. A standard training protocol uses 50 demonstrations per task, resulting in approximately 6.5K trajectories in total. LIBERO provides a standardized evaluation protocol and serves as a comprehensive testbed for instruction following, compositional generalization, and multi-task policy learning.

LIBERO-Plus. LIBERO-Plus (Fei et al., 2025) is a robustness-oriented benchmark built on top of LIBERO for systematically evaluating the generalization ability of vision-language-action models under distribution shifts. It expands the original benchmark by introducing perturbations over seven factors, including object layout, camera viewpoints, robot initial states, language instructions, lighting, background textures, and sensor noise. The final benchmark is a test-only evaluation set with 10,030 tasks spanning 7 perturbation factors and 21 low-level components.

SimplerEnv. SimplerEnv (Li et al., 2024b) is a simulation-based evaluation benchmark designed as a scalable proxy for real-world robot evaluation. It provides standardized simulated environments corresponding to common real-robot platforms, including the WidowX (BridgeData V2) and the Google Robot (RT-series) setups. The benchmark defines fixed evaluation protocols such as Visual Matching and Variant Aggregation, as well as standardized success-rate aggregation rules. Although it does not specify a fixed number of tasks or dataset size, it is widely used to evaluate policies trained on real-world data under reproducible simulated conditions, with prior work showing strong correlation between simulated and real-world performance.

RoboCasa-GR1. RoboCasa-GR1 (Nasiriany et al., 2024; Bjorck et al., 2025) is a tabletop manipulation benchmark built on the RoboCasa simulation framework, commonly used to evaluate humanoid-style manipulation policies. Compared with standard single-arm setups, it introduces more complex embodiments and household interaction scenarios involving articulated objects and multi-stage tasks. The benchmark contains 24 tasks, with approximately 1,000 demonstrations per task, resulting in around 24K trajectories in total.

RoboTwin 2.0. RoboTwin 2.0 (Chen et al., 2025b) is a large-scale benchmark for bimanual robotic manipulation, focusing on dual-arm coordination across diverse scenarios. It contains 50 tasks with two evaluation setups: clean and randomized. Each task includes 50 clean demonstrations together with 500 randomized demonstrations, resulting in approximately 550 trajectories per task and 27.5K trajectories in total. The randomized data is generated via structured domain randomization, including variations in scene clutter, backgrounds, table height, and lighting, providing a challenging testbed for both coordination and robustness. For evaluation, each task is tested for 100 episodes under each setup. In total, this results in 50 tasks \times 2 setups \times 100 episodes, equals to 10,000 evaluation trials.

BEHAVIOR-1K. BEHAVIOR-1K (Li et al., 2023) is a large-scale benchmark for human-centered embodied AI, built around everyday activities. It defines 1,000 activities across 50 interactive scenes with more than 9,000 objects, covering environments such as homes, offices, and restaurants. Built on OmniGibson, it supports realistic physics for rigid, deformable, and liquid objects, and emphasizes long-horizon interaction requiring perception, navigation, and manipulation. An active evaluation setting is the BEHAVIOR Challenge, which selects 50 household tasks from the activity set and provides 10,000 teleoperated demonstrations (over 1,200 hours), with 200 demonstrations per task released for training. For evaluation, each task includes 20 additional instances with varying initial conditions, of which 10 are used for reporting, and each instance is evaluated once with a fixed timeout. Performance is measured by the average task success rate across all tasks, with partial credit based on goal completion.

CALVIN. CALVIN (Mees et al., 2022) is a benchmark for long-horizon language-conditioned manipulation, designed to evaluate whether a single policy can execute sequences of natural-language instructions from visual observations. It comprises four environments (A, B, C, and D) and 34 manipulation tasks involving articulated objects and stateful scene elements such as drawers, sliding doors, lights, and switches. The standard evaluation follows the ABC\rightarrowD setting, where policies are trained on A–C and tested on D using 1,000 task sequences of length 5. Performance is reported by the average length of successfully completed subtask sequences.

In this section, we report single-benchmark SFT results to establish transparent, reproducible reference points under official evaluation protocols. To provide the community with the cleanest possible baselines, we deliberately avoid any VLA-specific pretraining (e.g., large-scale robot pretraining mixtures), data augmentation, or online refinement techniques such as DAgger. Every model is initialized from publicly released VL pretrained weights and fine-tuned exclusively on the benchmark's standard demonstration dataset. These minimal-assumption results serve as reliable anchor points for future research: they make it straightforward to measure the marginal value of additional pretraining data, augmentation strategies, or co-training recipes.

LIBERO (Liu et al., 2024a) is a widely used tabletop manipulation benchmark comprising four task suites of increasing difficulty: Spatial, Object, Goal, and Long. We treat it as the first worked example of our single-benchmark pipeline and walk through every step—data loading, training, and evaluation—so that readers can fully reproduce our numbers.

Training data format. To maintain a simple and reproducible baseline, we adopt minimal data engineering and follow the benchmark's native schema.

• Input: a raw sample dict loaded directly from the LeRobot-format dataset, containing the primary (third-person) RGB view and the wrist-camera RGB view. We do not use proprioceptive state, history stacking, or image augmentation for this baseline.
• Output: a continuous end-effector (EEF) control action vector following the LIBERO action definition with action chunking=8.

Training setup. We train the LIBERO baseline using distributed training with 8 A100 GPUs (via accelerate + DeepSpeed ZeRO-2). Unless otherwise specified, the per-device batch size is 16 and training runs for 100K optimization steps. Checkpoints are saved every 10K steps, with periodic logging and evaluation during training. For transparency and exact reproducibility (full command line, YAML configuration, and environment variables), we provide the complete training scripts under examples/LIBERO/train_files/. We train a single policy jointly on four LIBERO suites (Spatial, Object, Goal, and LIBERO-10) using the corresponding LeRobot-format datasets: they are available as a public collection at https://huggingface.co/collections/IPEC-COMMUNITY/libero-benchmark-dataset.

Evaluation protocol. We evaluate on the four suites (Spatial, Object, Goal, and LIBERO-Long) using the official LIBERO evaluation scripts and report success rate. We periodically evaluate checkpoints (every 10K steps by default) and report the earliest checkpoint that achieves the best average success rate. For each suite, we run 10 tasks with 50 episodes per task (500 trials total) and report the mean success rate over all trials. To ensure reproducibility without modifying benchmark logic, we provide the complete evaluation scripts and launch instructions under examples/LIBERO/eval_files/.

Results and analysis. Table 2 summarizes the LIBERO baseline performance. Using only 30K steps (\sim10 epochs), StarVLA already matches or surpasses several strong published baselines. For instance, OpenVLA-OFT trains for 175K steps (223 epochs) to reach 97.1% average, whereas StarVLA-OFT achieves 96.6% (Qwen3-VL) and 95.8% (Cosmos-Predict2-2B) with 6\times fewer steps and 23\times fewer epochs. \pi_0+FAST and GR00T-N1.5 score 85.5% and 86.5% respectively, both considerably below our variants. Notably, replacing the VL backbone from Qwen3-VL-4B to Cosmos-Predict2-2B yields comparable performance (average \geq95.2% across all action heads), demonstrating that StarVLA generalizes well across different VL backbones. These comparisons suggest that the StarVLA pipeline is highly data-efficient on LIBERO.

Training setup. All models are trained with full-parameter fine-tuning using distributed training on 16 A100 GPUs. Unless otherwise specified, the per-device batch size is 16 and training runs for 100K optimization steps. Checkpoints are saved every 10K steps, with periodic logging and evaluation during training. For transparency and exact reproducibility (full command line, YAML configuration, and environment variables), we provide the complete training scripts under examples/SimplerEnv/train_files/. We train SimplerEnv baselines on a merged mixture of Bridge and Fractal datasets in LeRobot format: https://huggingface.co/datasets/IPEC-COMMUNITY/bridge_orig_lerobot and https://huggingface.co/datasets/IPEC-COMMUNITY/fractal20220817_data_lerobot.

Evaluation protocol. We evaluate using the official SimplerEnv evaluation workflow and report the task success rate. We present detailed per-task results under two standard SimplerEnv settings: (i) WidowX robot with Visual Matching (VM) in Table 3, and (ii) Google Robot in Table 4. We strictly follow the official protocol for per-task repeats/episodes and success-rate aggregation without modifying benchmark logic. Since SimplerEnv evaluation can exhibit non-trivial variance, we run each reported setting five times (each time rerunning the full official evaluation) and report the mean success rate. To ensure reproducibility without modifying benchmark logic, we provide the complete evaluation scripts and launch instructions under examples/SimplerEnv/eval_files/.

Results. Tables 3 and 4 summarize the SimplerEnv performance. On WidowX (VM), StarVLA with Qwen3-VL-4B achieves a strong average success rate (up to 65.3%), while the Cosmos-Predict2-2B backbone also delivers competitive results (up to 61.6%), confirming that StarVLA generalizes across different VL backbones. Both configurations show consistently high performance on the most structured task and a remaining gap on object placement tasks. On Google Robot, StarVLA is competitive with or better than strong recent baselines under the Visual Matching setting, and remains comparable under Variant Aggregation, suggesting that the policy transfers robustly across standardized simulation evaluation settings.

Training setup. We train the RoboCasa-GR1 baselines with distributed full-parameter fine-tuning on 16 A100 GPUs. Unless otherwise specified, the per-device batch size is 16 and training runs for up to 100K optimization steps. Checkpoints are saved every 10K steps, with periodic logging and evaluation during training. For the specialist setting, we use the official RoboCasa-GR1 tabletop release and train one model jointly across all 24 tasks from this benchmark only. This keeps the policy architecture fixed while treating RoboCasa as a multi-task humanoid-style manipulation suite rather than 24 separate single-task runs.

Evaluation protocol. We follow the official RoboCasa-GR1 evaluation workflow and report average success rate over the 24 tasks. For the architecture comparison in this section, each model is evaluated with 50 rollouts per task. Table 6 further reports the task-level success rates for representative baselines and StarVLA variants.

Results. Table 5 summarizes the average RoboCasa-GR1 performance for the single-benchmark setting. This benchmark is noticeably harder than LIBERO and SimplerEnv, and the choice of action head matters more: the discrete StarVLA-FAST baseline reaches 39.0%, while the continuous-action variants improve to 43.9–48.8%. Among the StarVLA variants, StarVLA-OFT performs best with a 48.8% average success rate, slightly exceeding StarVLA-GR00T (47.8%) and outperforming \pi_{0.5} by 11.8 points. Detailed task-level results are reported in Table 6. We defer cross-benchmark generalist results to Sec. 7.

Training setup. We train the RoboTwin 2.0 baseline using distributed training with 48 A100 GPUs (via accelerate + DeepSpeed ZeRO-2). Unless otherwise specified, the per-device batch size is 4 and training runs for 150K optimization steps. Checkpoints are saved every 10K steps, with periodic logging and evaluation during training. For transparency and exact reproducibility (full command line, YAML configuration, and environment variables), we provide the complete training scripts under examples/Robotwin/train_files/. We train RoboTwin 2.0 baselines on official clean and randomized datasets in LeRobot format: https://huggingface.co/datasets/StarVLA/RoboTwin-Clean and https://huggingface.co/datasets/StarVLA/RoboTwin-Randomized.

Evaluation protocol. We evaluate on the 50 tasks using the official RoboTwin 2.0 evaluation scripts and report success rate. We periodically evaluate checkpoints (every 10K steps by default) and report the earliest checkpoint that achieves the best average success rate. For each suite, we run 50 tasks with 100 episodes per task under clean and randomized condition (10000 trials total) and report the mean success rate over all trials. To ensure reproducibility without modifying benchmark logic, we provide the complete evaluation scripts and launch instructions under examples/Robotwin/eval_files/.

Results. Table 7 summarizes the RoboTwin baseline performance. Under Qwen3-VL-4B backbones, all four StarVLA variants achieve strong average success rates when trained as a single unified policy over 50 tasks, demonstrating that our end-to-end baseline pipeline (data \to training \to evaluation) is reliable and reproducible.

Beyond single-benchmark supervised fine-tuning, StarVLA natively supports multimodal co-training, in which the VLM backbone is jointly optimized on both robot action data and auxiliary vision-language tasks (e.g., spatial grounding, visual question answering, and captioning). The motivation is twofold: (i) action-only fine-tuning can rapidly degrade the pre-trained multimodal representations, undermining instruction comprehension and spatial reasoning; and (ii) co-training with carefully curated auxiliary data can align the optimization dynamics of perception and control, leading to better-performing policies.

When a pre-trained VLM is fine-tuned exclusively on action prediction, it tends to “forget” pre-trained visual and linguistic capabilities within thousands of steps. This manifests as degraded object grounding, instruction following, and scene understanding, all of which are prerequisites for robust manipulation. Co-training with multimodal grounding data counteracts this forgetting by maintaining the gradient flow through perception-relevant pathways.

Co-training setup. StarVLA provides built-in support for mixing heterogeneous data sources during training. Users can specify arbitrary combinations of action datasets and VLM-style QA datasets in a single configuration file; the framework handles tokenization, loss masking, and gradient accumulation transparently across data types. This makes it straightforward to reproduce co-training recipes, for instance, mixing OXE action data with RefCOCO spatial grounding or LLaVA-style visual QA data, without modifying the training loop.

Evaluation and baselines. To illustrate the effect, we summarize a spatially guided co-training study built on the StarVLA codebase (Ye et al., 2026a). This study compares three training strategies: (1) Vanilla VLA, which fine-tunes only on action data, (2) Vanilla co-training VLA, which jointly optimizes on spatial grounding and action data, and (3) Spatially guided training VLA, which additionally incorporates spatial pre-training and spatial prompting during co-training.

Figure 4 visualizes the interaction between spatial perception (measured by IoU@0.5 on RefCOCO-g) and manipulation performance (WidowX success rate) across training steps. Vanilla VLA suffers rapid perception degradation: RefCOCO-g performance drops to near-random levels within 20K steps. Vanilla co-training partially preserves perception but exhibits unstable oscillations. The spatially guided StarVLA (ST4VLA (Ye et al., 2026a)) variant achieves the best balance, maintaining {\sim}70\% of original grounding performance while reaching strong manipulation success.

Table 8 further quantifies the impact of co-training on multimodal understanding, spatial grounding, and robotic manipulation. Compared to the vanilla VLA, vanilla co-training already improves manipulation performance (+4.1% Google Robot VM, +6.4% WidowX) while recovering multimodal capabilities. The spatially guided StarVLA variant pushes the results further, achieving 84.6%/75.9% on Google Robot VM/VA and 73.2% on WidowX, while simultaneously preserving strong spatial grounding (71.2 IoU@0.5 on RefCOCO-g).

Takeaways. These results demonstrate that StarVLA's co-training infrastructure enables significant gains over action-only fine-tuning. By preserving multimodal understanding during policy learning, co-training yields more generalizable agents. For a comprehensive treatment of spatially guided co-training, including the full training recipe, gradient alignment analysis, and extensive real-world experiments, we refer readers to the ST4VLA (Ye et al., 2026a), a study paper based on StarVLA.

Building on the benchmark-wise specialist baselines in Sec. 5, we next evaluate a stricter setting for embodied generalization: one model jointly trained across benchmarks and robot embodiments. StarVLA natively supports co-training on heterogeneous datasets under a unified framework, which makes this all-in-one setting a natural case study for generalist VLA training.

Existing evaluation patterns. The Embodied AI community shares a common ambition: to develop a generalist agent that can seamlessly operate across diverse tasks, environments, and robots. In practice, however, the research landscape remains fragmented. Many state-of-the-art systems are tuned for specific benchmarks, and their performance can drop substantially when transferred to different environments or embodiments. This makes it difficult to measure true generalization ability.

Training setup. In this setting, we jointly train one model on the merged training sets from LIBERO, SimplerEnv, RoboTwin 2.0, and RoboCasa-GR1, and then directly evaluate on each benchmark under its official protocol. No additional benchmark-specific fine-tuning is applied. We set the learning rate to 1\times10^{-4}, the total batch size to 256, and train jointly on the merged benchmark datasets. To handle action-space differences across embodiments, we avoid task-specific action heads and apply a simple unified padding strategy that expands lower-DoF actions to a shared 32-dimensional action vector.

Evaluation protocol as a generalist. A practical way to test generalization is to require one model to handle diverse benchmarks simultaneously. Following this principle, we evaluate StarVLA under a unified multi-benchmark setting, where a single policy is trained once and evaluated across suites without benchmark-specific fine-tuning.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 \pi_{0.5} and GR00T-N1.6.

As shown in Table 9, we compare our generalist model (jointly trained across datasets) with specialist models trained per benchmark. The generalist model remains competitive across most benchmarks and improves RoboCasa-GR1 from the best specialist average of 48.8% to 57.3% on the 24-task average. These results support the feasibility of a single policy that transfers across tasks and embodiments under a unified training/evaluation setting.

Takeaways. This section focuses on a direct capability demonstration rather than ablation analysis: StarVLA can jointly train on heterogeneous, cross-embodiment benchmark datasets and produce a single model that remains competitive across diverse evaluation suites. We view this as evidence that all-in-one multi-benchmark training is a practical path toward large-scale cross-embodiment pretraining for future generalist VLA systems.

This section reports the training efficiency of StarVLA using the public profiling measurements collected in issue https://github.com/starVLA/starVLA/issues/158. Our goal is to provide actionable scaling guidance for practitioners, while keeping the reported metrics aligned with common distributed-training bottlenecks (compute and communication).

Experimental setup. Unless otherwise specified, the measurements use StarVLA-GR00T with a Qwen3-VL-4B backbone trained on the RoboCasa-GR1 dataset on A100 80GB GPUs. We report wall-clock time per 100K optimization steps, which includes distributed communication and system overhead.Efficiency metrics. We distinguish two throughput notions: (i) step throughput (lower seconds/step is better), and (ii) sample throughput (higher samples/s is better), where samples/s is computed as \text{global batch} / (\text{seconds per step}). This distinction is important because distributed scaling often decreases step throughput (due to synchronization) while increasing sample throughput (due to larger global batch).

Table 10 summarizes a single-node sweep that varies the per-GPU batch size. We omit derived “24-hour” projections and focus on directly measured quantities and the implied sample throughput.Figure 5 visualizes the main trade-off. Smaller per-GPU batches yield faster steps (e.g., 0.703 s/step at batch 2 vs. 2.404 s/step at batch 24), while larger per-GPU batches improve sample throughput (from 22.7 to 79.9 samples/s) at the cost of sharply increased step latency.

We next fix per-GPU batch size to 8 and scale the number of GPUs. As shown in Table 11, the time per step rises from 0.735 s (8 GPUs) to 0.899 s (32 GPUs) due to inter-node communication overhead, then plateaus at {\sim}0.93 s up to 256 GPUs. Despite this overhead, sample throughput scales from 87.0 to 2200.0 samples/s, which is the relevant metric when the training objective is to process a fixed amount of data quickly.

Figure 6 plots both step latency and sample throughput against GPU count, together with the ideal linear reference line. The results highlight a practical guideline: scaling out is most beneficial for data-volume-driven training, while fixed-step training does not become faster with more GPUs.

Takeaways. First, inter-node communication introduces a one-time latency overhead (0.735\to0.93 s/step), but sample throughput still scales near-linearly via larger global batch. Second, on a single node, a moderate per-GPU batch (e.g., 8) often provides the best balance between step latency and GPU utilization; very large batches (e.g., 24) maximize utilization (96%) but inflate step latency by 3.4\times. Third, for large-scale training, once the system scales beyond 8 nodes (64 GPUs), the communication burden no longer grows further, maintaining a stable scaling efficiency of 79–80%. This indicates that practitioners can confidently scale to hundreds of GPUs without incurring additional parallel efficiency degradation.

StarVLA thrives on the synergy between its dedicated core team and a vibrant open-source community. To accurately reflect the nature of involvement, we list contributors in two categories: Authors and Community Contributors. We extend our deepest gratitude to everyone who has helped shape and scale StarVLA.Authors. Jinhui Ye, Ning Gao, Yilun Chen^\dagger, Weiyu Guo, Zixuan Wang, Yuxing Chen, Fangjing Wang, Senqiao Yang, Chengyao Wang, Yuqi Liu, Meng Chu, Changsheng Lu, Pengguang Chen, Shu Liu^\dagger, Jiaya Jia^{\dagger *}Community Contributors. Junqiu Yu, Shuang Zeng, Shijie Lian, Hanwen Wan, Changjiu Zhang, Zhijie Song, Mingsheng Li, Qiuyue Wang, Sicheng Xie, Jinliang Zheng, Deyu Zhou, Jiaming Zhou, Lu Dai, Xiaorui ZhaoContributor Policy. Authors constitute the core team of StarVLA. This group is responsible for continuously iterating on core features, maintaining the foundational framework, and providing ongoing, long-term support for the project. Researchers and developers who are interested in making sustained, structural contributions and wish to join the core author team are highly encouraged to contact us. Community Contributors are the vital force behind the project's broader ecosystem. We continuously receive invaluable support from the open-source community—ranging from new feature implementations (pull requests) and bug fixes to constructive feedback. We deeply appreciate these efforts, which allow StarVLA to evolve rapidly. The full and actively updated contributor history is maintained at starvla.github.io/contributors.^\daggerCorresponding authors. * Von Neumann Institute, HKUST