Summary (Overview)

• TurboVLA proposes a new V + L → A paradigm that replaces the conventional LLM-centric V → L → A pathway with direct vision-language interaction, removing the large language model from the execution-level control loop.
• The model achieves 97.7% average success on LIBERO with only 0.2B parameters, 31.2 ms inference latency, and 0.9 GB inference VRAM on a consumer-grade RTX 4090, running at over 32 Hz.
• TurboVLA uses lightweight modality-specific encoders (DINOv3 for vision, BERT for text), a compact bidirectional cross-attention interaction module, and an ACT-style action chunk decoder, all trained with simple behavior cloning (L1 loss).
• It matches or outperforms substantially larger VLA models (e.g., π0.5 with 3.4B parameters, 93.6 ms latency) on both single-arm (LIBERO) and bimanual (RoboTwin 2.0) benchmarks, and consistently outperforms π0.5 in real-world tasks on an AgileX Piper platform.
• Ablations confirm that each component—semantic language conditioning, bidirectional interaction, sufficient interaction depth, and appropriate action horizon—is critical for the performance-efficiency trade-off.

Introduction and Theoretical Foundation

Vision-language-action (VLA) models have become a powerful framework for language-conditioned robotic manipulation. The dominant design is LLM-centric: visual observations are projected into the representation space of a large language model, combined with the task instruction, processed by the LLM, and then decoded into actions. This is summarized as the V → L → A pathway:

$$\tilde{Z}_n^v = P_v(E_v(O_n)), \quad H_n^L = F_L([\tilde{Z}_n^v; \text{Tok}(x)])$$

where $E_v$ is the visual encoder, $P_v$ maps visual features to the LLM embedding space, $\text{Tok}(x)$ are instruction tokens, and $F_L$ is the large language model. Actions are then generated either autoregressively (as tokens) or via a separate action expert:

$$\hat{A}_n = D_{\text{act}}(H_n^L, s_n)$$

While effective, this design imposes substantial computation and memory overhead at every policy invocation, because every control step must pass through a multi-billion-parameter LLM. The authors argue that execution-level control does not require open-ended language generation or autonomous task decomposition—once the instruction specifies the intended skill, the policy mainly needs to use the instruction to determine how visual evidence should guide action. A lightweight text encoder (e.g., BERT) can provide the necessary semantics, and compact cross-modal interaction can construct control-oriented representations.

Thus, the paper proposes TurboVLA, a direct V + L → A paradigm that encodes vision and language separately, exchanges information through lightweight bidirectional vision-language interaction, and predicts continuous action chunks without autoregressive decoding.

Methodology

TurboVLA consists of three main components:

1. Multimodal Feature Encoding

• Instruction encoding: A lightweight text encoder (BERT) extracts token-level features: $$Z^l = P_l(f_{\text{text}}(x)) \in \mathbb{R}^{N_l \times d}$$ retaining the full token sequence for fine-grained conditioning.
• Visual encoding: DINOv3 (ViT-B or ViT-L) extracts spatial features from each camera view, projected and augmented with positional and camera-view embeddings: $$Z_n^{v,(i)} = P_v(f_{\text{img}}(I_n^{(i)})) + E_{\text{pos}}^{(i)} + e_{\text{view}}^{(i)}, \quad Z_n^v = [Z_n^{v,(1)}; \dots; Z_n^{v,(K)}]$$
• Robot state encoding: A lightweight projection network encodes the robot state separately: $$Z_n^s = f_{\text{state}}(s_n) \in \mathbb{R}^{N_s \times d}$$ State features are introduced only at the action decoder, keeping the interaction module focused on task-conditioned scene understanding.

2. Vision-Language Interaction Module

A stack of $N$ bidirectional cross-attention layers (initialized from Grounding DINO weights) directly exchanges information between visual and instruction features:

$$(V_n^\ell, L_n^\ell) = \text{FusionLayer}^\ell(V_n^{\ell-1}, L_n^{\ell-1}), \quad \ell = 1, \dots, N$$

Each layer includes layer normalization, bidirectional cross-attention (visual-to-instruction and instruction-to-visual), and modality-specific FFNs with residual connections. After the final layer, the streams are concatenated:

$$Z_n^{vl} = [V_n^N; L_n^N]$$

3. Continuous Action Chunk Prediction

An ACT-style lightweight transformer decoder maps the fused multimodal features and robot state to a sequence of continuous actions in a single forward pass:

$$\hat{A}_n = D_\theta(Q_a, [Z_n^{vl}; Z_n^s]) \in \mathbb{R}^{H \times d_a}$$

where $Q_a = [q_1, \dots, q_H]$ are learnable action queries. The model is trained with simple L1 behavior cloning loss on expert action chunks, with no auxiliary language modeling objective.

Empirical Validation / Results

LIBERO (Single-Arm Manipulation)

TurboVLA achieves 97.7% average success across 2,000 rollouts (50 per task on 4 suites), with only 0.2B parameters, 31.2 ms latency, and 0.9 GB inference VRAM on an RTX 4090. It matches or outperforms all compared methods.

RoboTwin 2.0 (Bimanual Manipulation)

TurboVLA achieves 60.2% average success across 50 tasks with 43.4 ms latency, outperforming π0.5 (57.0%, 95.6 ms) and StarVLA-α (50.3%, 74.9 ms).

Real-World Evaluation (AgileX Piper)

TurboVLA consistently outperforms π0.5 across four tasks: Grab Roller (92.5% vs. 85.0%), Move Playing Card (80.0% vs. 72.5%), Press Stapler (90.0% vs. 82.5%), and Stack Bowls (87.5% vs. 77.5%).

Ablation Studies

• Language conditioning: Removing language drops average success from 97.7% to 70.8% (LIBERO-Goal drops from 97.4% to 11.6%). Task-ID embedding recovers to 95.4%, confirming the importance of semantic instructions.
• Instruction encoder: BERT (97.7%) outperforms T5-small (97.1%) and SigLIP (95.5%), but all lightweight encoders work well.
• Vision-language interaction: Bidirectional interaction (97.7%) outperforms no interaction (95.2%) and one-way variants (96.1%, 96.5%).
• Interaction depth: $N=6$ yields best results (97.7%), with $N=2$ at 93.5% and $N=8$ at 96.6%.
• Action horizon: $H=12$ is optimal (97.7%), with $H=8$ at 96.4% and $H=15$ at 95.6%.

Theoretical and Practical Implications

• Theoretical: The paper challenges the assumption that execution-level manipulation must be centered on a large language model. It demonstrates that a direct V+L→A pathway with lightweight encoders and bidirectional cross-modal interaction can achieve state-of-the-art performance while dramatically reducing computational cost.
• Practical: TurboVLA enables real-time (32 Hz) policy inference on consumer-grade GPUs (RTX 4090) with less than 1 GB VRAM, making it feasible for edge deployment in latency-sensitive, resource-constrained robotic systems. It lowers the hardware barrier for language-conditioned manipulation.
• Limitation: TurboVLA is designed for concrete execution-level instructions and may not provide the complex semantic understanding and reasoning required for high-level task planning. It is complementary to LLM-based planning systems.

Conclusion

TurboVLA introduces a simple yet efficient V + L → A paradigm that moves beyond the conventional LLM-centered execution pathway for vision-language-action learning. By combining lightweight instruction encoding, compact visual representations, bidirectional vision-language interaction, and action-chunk decoding, TurboVLA preserves task-conditioned manipulation capability while significantly reducing model size (0.2B), inference latency (31.2 ms), and memory consumption (0.9 GB). On LIBERO, it achieves 97.7% average success, matching or outperforming substantially larger VLA policies. The results suggest that execution-level control does not necessarily require a general-purpose LLM as the central interface. Future work will explore combining the high-level planning capability of LLMs with the efficient execution pathway of TurboVLA to build hierarchical systems that are both intelligent and efficient.