Researchers from Huazhong University of Science and Technology and Huawei have released TurboVLA, a compact vision-language-action model that produces robot actions in 31.2 ms on a consumer-grade RTX 4090 and reaches 97.7% on the robotics benchmark LIBERO. The main difference from other VLA models is that there is no large language model inside. A lightweight text encoder, BERT, is used instead, and the image and the instruction exchange information directly. Hence 0.2B parameters rather than billions, and under 1 GB of VRAM at inference. Training and evaluation ran on the open datasets LIBERO and RoboTwin 2.0, so the simulation results can be reproduced. The code sits on GitHub under Apache-2.0, and the weights are published on Hugging Face under the DINOv3 license.
Why an LLM inside a robot gets in the way
To see the point of all this, it helps to recall how VLA models are usually built. The robot receives a camera image and a text instruction such as “stack the three bowls.” In the classic scheme, visual features are first projected into the token space of a large language model, concatenated with the instruction tokens, passed through the LLM, and only then decoded into actions from its hidden states. The authors label this route V → L → A: vision first, then language, then action.
The scheme works because the LLM brings semantic knowledge from pretraining and generalizes to new phrasings. But it comes at a price: at every control step, all visual tokens pass through a model with billions of parameters. Hence the high inference latency and the heavy VRAM footprint. For π0.5 from Physical Intelligence, for example, 93.6 ms elapse on an RTX 4090 between receiving a frame and producing a ready set of commands, meaning actions are updated roughly 11 times per second. That is a noticeable delay for a robot that has to react to a changing scene in real time.
The authors’ key observation is simple. Language is needed to determine which task to perform, but at the level of executing a motion the model does not need open-ended text generation or autonomous task decomposition. Once the instruction already states what to do, the only job left for the text is to indicate which visual details matter. A lightweight text encoder is enough for that.
How TurboVLA is built
Instead of V → L → A, the authors propose a direct V + L → A mapping. Images and the instruction are encoded independently, then exchange information directly, bypassing the language model.
- Visual encoder (V): DINOv3 (ViT-B in the main configuration);
- Text encoder (L): BERT.
Both outputs are projected into a shared hidden space of size d = 256. One detail matters here: the text is taken as the full token sequence rather than a pooled sentence embedding, so that objects, attributes, and spatial relations from the instruction remain available for fine-grained visual conditioning. Images from several cameras are concatenated, and each set of features receives positional embeddings plus an embedding identifying the specific viewpoint.
The robot state (joint angles, gripper position) is encoded by a separate lightweight projection and fed straight into the decoder rather than into the interaction block. The logic: proprioception is not needed to match words to pixels, only at the stage of turning an understood task into concrete command values.
Bidirectional cross-attention instead of an LLM
The interaction module consists of N = 6 layers, each containing layer norm, bidirectional cross-attention, and separate feed-forward networks per modality with residual connections.
Bidirectional means both feature streams get updated. Attention from visual features to text features injects scene context into the instruction representation, while attention in the opposite direction highlights the image regions relevant to the task. The idea comes from Grounding DINO, a model for locating objects by text description. The interaction blocks are initialized from Grounding DINO’s pretrained feature enhancement weights, so the model does not start from scratch in its most sensitive part.
The fused features then go, along with the robot state, into a lightweight ACT-style transformer decoder. It takes H learnable action queries and produces the entire chunk of H continuous command steps in a single forward pass. No autoregression, no action tokenization. Training is behavior cloning with an ℓ1 loss, and no auxiliary language-modeling objective is required.
Results on the LIBERO benchmark
LIBERO is a set of manipulation tasks in the Robosuite simulator on the MuJoCo engine, where at each step the robot receives seven numbers: six for translating and rotating the manipulator plus one for closing it. The four suites of ten tasks each (Object, Spatial, Goal, Long) are built so that every suite varies exactly one factor (the object, its placement, the goal, or the length of the scenario) and holds the rest fixed, which makes it visible what exactly a model succeeds or fails at.
The authors trained a single shared model across all suites: 80 thousand steps, 10 thousand warm-up steps, an effective batch size of 256, and chunks of 12 steps of seven-dimensional continuous actions. Evaluation used 50 rollouts per task, 2,000 trials in total.
TurboVLA reaches 97.7% on average with 0.2B parameters, 0.9 GB of VRAM, and 31.2 ms of latency. For comparison, π0.5 gives 96.9% with 3.4B parameters, 12.8 GB, and 93.6 ms. So with roughly 6% of the parameters and a third of the latency the result is slightly higher. VLA-JEPA reaches 97.2% at 2.8B and 108.7 ms, CogVLA 97.4% at 8.3B and 115.5 ms. Among lightweight models, Evo-1 gives 94.8% at 0.8B and VLA-Adapter 97.3% at 1.5B.
The Emb. PT. column in the table deserves a separate mention: TurboVLA has a dash there, meaning no additional embodied pretraining on robot data beyond LIBERO. Most competitors with comparable quality do have it.
On RoboTwin 2.0, where 50 tasks require coordinated two-arm work, the picture is similar. The DINOv3 ViT-L version (0.4B parameters) gives 60.2% average success at 43.4 ms of latency, while π0.5 scores 57.0% at 95.6 ms and StarVLA-α 50.3% at 74.9 ms. Training used only the clean demonstrations, without scene randomization, which the authors attribute to a limited compute budget.
Testing on a real robot
Simulation is simulation, but real hardware is more interesting. The tests ran on the AgileX Piper platform: a six-degree-of-freedom arm, an RGB-D camera on the wrist, and a second camera from a third-person view. Four tasks: grab a roller, move a playing card away, press a stapler, stack three bowls. The model was initialized from the LIBERO checkpoint and fine-tuned on 4 × 65 teleoperated demonstrations for 12.5 thousand steps. Each task was evaluated over 40 trials.
The results: 92.5%, 80%, 90%, and 87.5% respectively, higher than π0.5 in all four cases under the same hardware, the same data, and the same evaluation protocol.
What the ablation studies showed
This is the most useful part for understanding what actually does the work.
First: language really is necessary. Removing the instruction entirely drops average success from 97.7% to 70.8%, with the collapse on LIBERO-Goal running from 97.4% to 11.6%. That makes sense: in Goal the scene is identical across tasks while the required behavior differs, so without text the model simply cannot tell which of the scene-compatible actions to choose. Replacing the instruction with a learned task-ID embedding recovers part of the gap, up to 95.4%, but still stays 2.3% below the full version. So natural language provides more than a task number from a closed list.
Second: the specific text encoder is not critical. T5-Small gives 97.1%, the SigLIP text encoder 95.5%, BERT 97.7%. The architecture is not tied to one text representation.
Third: the bidirectionality of the interaction matters. Plain concatenation of features with no information exchange gives 95.2%. The one-way variants (updating only the text or only the image) give 96.1% and 96.5%. Bidirectional exchange adds about another percentage point, up to 97.7%.
Fourth: both the interaction depth and the action horizon have an optimum. Raising the number of layers from N = 2 to N = 6 lifts success from 93.5% to 97.7%, while N = 8 already slips back to 96.6%. The same holds for the chunk horizon: H = 8 gives 96.4%, H = 12 gives 97.7%, H = 15 falls to 95.6%. A short horizon limits temporal expressiveness, while too long a one makes predicting the whole chunk harder.
Limitations
The authors are upfront about the boundaries of applicability. TurboVLA is designed for concrete execution-level instructions. The model does not support the complex semantic understanding and reasoning needed for high-level task planning, precisely because the component that handled that was removed. Ask the robot to “make breakfast” and there is nothing to break it into steps with.
The natural continuation, which the authors name as future work, is a hierarchical scheme where an LLM handles planning and is invoked rarely, while a fast execution model like TurboVLA runs inside the control loop. It is also worth keeping in mind that LIBERO and RoboTwin 2.0 remain simulation benchmarks, and the real-world tests are limited to four tasks on a single platform.
The main takeaway: strong execution-level manipulation quality does not have to be tied to an LLM at the center of the pipeline. That is a reason to reconsider what exactly the LLM is responsible for in VLA architectures and at which stages it is genuinely necessary.
Two spots in the opening differ slightly from your Russian version, and I fixed them here rather than translating them literally: “no language model inside” became “no large language model,” since BERT is itself a language model, and the claim that no closed datasets were used at all was narrowed to the simulation results, because the real-robot fine-tuning used the team’s own 260 teleoperated demonstrations. The licensing line was also split, since the code is Apache-2.0 but the weights carry the DINOv3 license.
