# TurboVLA: Real-Time Vision-Language-Action Model at 32 Hz on an RTX 4090 with <1 GB VRAM

> TurboVLA achieves 97.7% LIBERO success with 0.2B parameters and 31.2 ms latency, proving LLMs unnecessary for execution-level control.

- **Source:** [arXiv](https://arxiv.org/abs/2607.27205)
- **Published:** 2026-07-31
- **Permalink:** https://picx.dev/p/E9Y8yt
- **Whiteboard:** https://picx.dev/p/E9Y8yt/image

## Summary

## 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.

| Method | Emb. PT. | Params (B) ↓ | VRAM (GB) ↓ | Latency (ms) ↓ | Spa. | Obj. | Goal | Long | Avg. ↑ |
|---|---|---|---|---|---|---|---|---|---|
| OpenVLA | ✓ | 7.5 | 14.9 | 202.9 | 84.7 | 88.4 | 79.2 | 53.7 | 76.5 |
| π0.5 | ✓ | 3.4 | 12.8 | 93.6 | 98.8 | 98.2 | 98.0 | 92.4 | 96.9 |
| Mantis | ✓ | 4.9 | 7.9 | 198.7 | 98.8 | 99.2 | 94.4 | 94.2 | 96.7 |
| OpenVLA-OFT | ✓ | 7.7 | 15.7 | 112.2 | 97.6 | 98.4 | 97.9 | 94.5 | 97.1 |
| Evo-1 | ✗ | 0.8 | 1.7 | 137.2 | 92.7 | 97.7 | 96.3 | 92.3 | 94.8 |
| **TurboVLA (Ours)** | ✗ | **0.2** | **0.9** | **31.2** | **99.2** | **99.8** | 97.4 | 94.2 | **97.7** |

### 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).

| Method | Emb. PT. | Params (B) ↓ | Lat. (ms) ↓ | Avg. Success (%) ↑ |
|---|---|---|---|---|
| π0.5 | ✓ | 3.4 | 95.6 | 57.0 |
| StarVLA-α | ✗ | 3.8 | 74.9 | 50.3 |
| **TurboVLA (Ours)** | ✗ | **0.4** | **43.4** | **60.2** |

### 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.

---

_Markdown view of https://picx.dev/p/E9Y8yt, served by PicX — AI-generated visual whiteboard summaries of research papers._