A Pragmatic VLA Foundation Model

Chapter 1: The Key Insight

LingBot-VLA's philosophy is refreshingly pragmatic: scale real data, not architecture complexity.

Many recent VLA papers compete on clever architectural innovations — spatial representations, novel attention patterns, specialized pre-training objectives. LingBot-VLA bets on a simpler thesis: a clean architecture trained on a truly massive and diverse real-world dataset will outperform fancier models trained on less data.

The second key insight is about evaluation rigor. Most VLA papers evaluate on 5-20 tasks with a single robot. LingBot-VLA uses the GM-100 benchmark: 100 tasks, 3 platforms, 130 post-training episodes per task per platform. This is 22,500 total evaluation trials — enough to draw statistically meaningful conclusions.

The third insight is data efficiency. With strong pre-training, LingBot-VLA needs fewer demonstrations to adapt to new tasks. With only 80 demonstrations per task, it already outperforms π0.5 using the full 130-demonstration budget. Good pre-training is a force multiplier.

Chapter 2: Data Collection

Twenty thousand hours of robot data does not appear out of thin air. LingBot-VLA's dataset was collected across 9 different dual-arm robot embodiments, each with its own kinematic configuration, gripper design, and camera setup.

The Nine Robot Platforms

Notice the diversity: arm degrees of freedom range from 6 to 7, camera configurations vary from 2 to 3+, and teleoperation methods differ (VR, isomorphic arms, direct). This diversity is intentional — the model must learn manipulation skills that transfer across embodiment differences.

Automatic Annotation Pipeline

Raw teleoperation videos are not directly useful for training. They need language instructions that describe what the robot is doing. LingBot-VLA uses a two-stage annotation process:

The word cloud of atomic actions in the dataset reveals over 150 distinct verbs: move, pick, fold, pour, open, release, insert, arrange, stir, stack, rotate, peel, and many more. This action vocabulary is far richer than what most VLA datasets provide.

Chapter 3: Unified Action Space

Here is a hard problem: the 9 robot platforms have different numbers of joints, different gripper types, and different control interfaces. A 6-DoF arm and a 7-DoF arm produce action vectors of different sizes. How do you train a single model on all of them?

The Action Representation

LingBot-VLA uses continuous actions in a unified format. Each action step specifies joint positions (or velocities) for both arms plus gripper commands. For robots with fewer degrees of freedom, unused dimensions are masked or zero-padded. The key insight: despite different kinematic chains, all these dual-arm robots perform similar manipulation tasks (grasping, placing, pouring), so a shared action representation can capture the common structure.

Action Chunks

Instead of predicting one action at a time, LingBot-VLA predicts an action chunk — a sequence of T consecutive actions:

During pre-training, T = 50. This means the model outputs the next 50 time steps of robot motion in one forward pass.

Flow Matching for Action Generation

The action chunks are generated via Flow Matching, not autoregressive prediction. Starting from Gaussian noise, the model iteratively refines the action chunk toward a coherent trajectory. The training objective is:

Where A_t,s = sA_t + (1-s)ε is a linear interpolation between noise ε and the ground-truth action chunk A_t, and v_θ is the learned velocity field.

Think of it this way: the model learns to "push" random noise toward real trajectories. At inference, you start with noise and follow the learned velocity field to produce a smooth action sequence.

Chapter 4: The Architecture

LingBot-VLA has a clean two-expert design: an understanding expert that processes visual and language inputs, and an action expert that generates motor commands. They communicate through shared self-attention.

Understanding Expert: The VLM Backbone

The understanding expert is a pre-trained Vision-Language Model (Qwen2.5-VL). It takes three inputs:

• Three-view images (I₁, I₂, I₃): typically a head camera and two wrist cameras, providing the robot's view of the workspace
• Task instruction T: the language command ("Arrange flowers in the vase")
• Robot state s: the current joint positions and gripper state

The VLM encodes these into a rich multimodal representation. It understands what objects are present, what the task requires, and what the current robot configuration looks like.

Action Expert: The Motion Generator

The action expert is a separate transformer pathway that receives the robot's proprioceptive state and produces action chunks via flow matching. It has its own feed-forward layers and embeddings, but shares self-attention with the understanding expert.

Mixture-of-Transformers (MoT)

The two experts are woven together using a Mixture-of-Transformers architecture (inspired by BAGEL). In each layer:

• The understanding expert processes vision-language tokens through its own FFN
• The action expert processes action tokens through its own FFN
• Both share a single self-attention mechanism, so action tokens can attend to visual/language tokens and vice versa

Blockwise Causal Attention

The joint sequence [O_t, A_t] is split into three blocks:

• Block 1: image and text tokens [I₁, I₂, I₃, T] — bidirectional attention within
• Block 2: robot state [s] — can attend to Block 1 and itself
• Block 3: action chunk [a_t, ..., a_t+T-1] — can attend to all preceding blocks

This causal structure ensures the action expert has access to all observation context, but future actions cannot leak information backward into the observation representations.

Optional Depth Integration

For tasks requiring precise spatial awareness, LingBot-VLA adds a depth distillation mechanism. Learnable queries [Q₁, Q₂, Q₃] are processed through the VLM and then aligned with depth tokens from LingBot-Depth via a distillation loss:

This infuses geometric information without requiring depth at inference time — the VLM learns to internalize spatial reasoning during training.

Chapter 5: The Training Pipeline

Training a VLA on 20,000 hours of data is a serious engineering challenge. Without an efficient pipeline, a single training run could take months. LingBot-VLA achieves 261 samples per second on 8 GPUs — 1.5 to 2.8 times faster than existing codebases.

Distributed Strategy

LingBot-VLA uses FSDP (Fully Sharded Data Parallel), PyTorch's implementation of the ZeRO optimizer. This shards optimizer states, model parameters, and gradients across GPUs to minimize memory footprint.

But here is the clever part: they construct specific shard groups exclusively for the action expert modules, inspired by Hybrid Sharded Data Parallel (HSDP). The VLM backbone is large but its gradients are well-behaved. The action expert is smaller but its parameters are updated more aggressively. By sharding them differently, they reduce communication overhead without sacrificing memory efficiency.

Operator-Level Optimization

The multimodal fusion of vision, language, and action is fundamentally a sparse attention process — not all tokens need to attend to all other tokens. LingBot-VLA exploits this with two techniques:

• FlexAttention: computes only the attention entries that matter (following the blockwise causal mask), avoiding wasted FLOPs on masked-out token pairs
• torch.compile: fuses multiple small operations into single GPU kernels, reducing kernel launch overhead and maximizing memory bandwidth

Mixed Precision

Reductions (gradient aggregation across GPUs) run in float32 for numerical stability. Storage and communication use bfloat16. This halves memory traffic for the bulk of computation while keeping the critical accumulation steps precise.

Throughput Scaling

Samples per second with Qwen2.5-VL-3B backbone. LingBot-VLA maintains near-linear scaling from 8 to 256 GPUs, closely tracking the theoretical maximum.

Chapter 6: The GM-100 Benchmark

Most VLA papers evaluate on a handful of tasks with vague protocols. LingBot-VLA uses the GM-100 benchmark — 100 carefully designed manipulation tasks, evaluated across 3 platforms, with a strict protocol that makes comparisons meaningful.

Hardware

25 physical robots across 3 platforms: AgileX, AgiBot G1, and Galaxea R1Pro. All dual-arm with parallel-jaw grippers. Each has a head camera and two wrist cameras. All tasks are tabletop-based with the chassis fixed.

Data Collection Protocol

For each of the 100 tasks:

• 150 raw trajectories are collected via teleoperation per platform
• The top 130 (ranked by execution quality, motion smoothness, protocol adherence) are retained
• Object poses are randomized for each trajectory to prevent spatial memorization
• Automated filtering removes technical anomalies, followed by manual review

Evaluation Metrics

A trial ends early if 3 consecutive sub-task failures occur or a safety event (collision) happens. Each model gets 15 trials per task per robot for statistical robustness.

The total evaluation across all models involves 22,500 trials with comprehensive recording (third-person video, robot states, model predictions) in rosbag format. All recordings will be open-sourced for reproducibility.

Chapter 7: Scaling Results

This is the paper's headline result. As pre-training data scales from 3,000 to 20,000 hours, both success rate and progress score climb steadily across all three platforms.

The Scaling Curves

The experiment was run on a subset of 25 representative tasks. At each data volume (3K, 5K, 8K, 12K, 20K hours), the model was pre-trained from scratch, then post-trained on the evaluation tasks.

Equally important: the scaling behavior is consistent across all three platforms. AgileX, AgiBot G1, and Galaxea R1Pro all improve with more data, and their individual trends align with the aggregate curve. The scaling law is not specific to any single embodiment.

Data Efficiency

A well-pre-trained model needs fewer demonstrations to adapt. On 8 representative tasks with the AgiBot G1 platform:

• LingBot-VLA with 80 demonstrations outperforms π0.5 with 130 demonstrations in both SR and PS
• The gap widens as more post-training data is added, showing the pre-training provides a better foundation for learning

Chapter 8: Comparison

LingBot-VLA was compared against three state-of-the-art VLA models under strict experimental controls. All models were fine-tuned from public pre-trained checkpoints using the same data, hyperparameters, and evaluation protocol. Here are the real-world results on the GM-100 benchmark:

Real-World GM-100 Results (Average across 100 tasks)

Per-Platform Breakdown

GR00T N1.6 performs well on Galaxea R1Pro (14.29% SR) — comparable to π0.5 — because its pre-training included extensive Galaxea data. This highlights an important point: pre-training data composition matters as much as volume.

Simulation Benchmark (RoboTwin 2.0)

On 50 simulation tasks, LingBot-VLA also leads:

The gap is especially large in randomized scenes (+9.92% over π0.5), where diverse pre-training data helps most.

Chapter 9: Connections

LingBot-VLA sits at the intersection of several important research threads. Let's map where it fits.

Relation to π0 and π0.5

π0 pioneered the VLM + action expert design with flow matching. LingBot-VLA adopts the same high-level architecture (VLM backbone + flow-matching action head with blockwise causal attention) but demonstrates that the primary bottleneck is data scale, not architecture. LingBot-VLA's 20K-hour dataset dwarfs what π0 was trained on, and the scaling curves suggest even more data would help.

Relation to GR00T N1.6

NVIDIA's GR00T N1.6 is a generalist humanoid foundation model. The GM-100 comparison reveals an interesting finding: GR00T performs well specifically on platforms whose data was heavily represented in its pre-training (Galaxea R1Pro). This underscores that pre-training data composition — not just architecture — drives cross-embodiment transfer.

Relation to Scaling Laws in LLMs

LingBot-VLA provides the first evidence of scaling laws for VLA models on real-world data, analogous to the scaling laws discovered for LLMs (Kaplan et al., 2020). The implication is the same: invest in data collection infrastructure, because performance will keep improving with scale.

Relation to Diffusion Policy

Diffusion Policy showed that diffusion-based action generation outperforms behavioral cloning for robot manipulation. LingBot-VLA uses flow matching (a close relative of diffusion) for the same reason: it handles multimodal action distributions better than regression losses.

Cheat Sheet