A robot policy that runs at 32 Hz on an RTX 4090 is not unusual. A robot policy that does it with 0.2 billion parameters, 0.9 GB of inference VRAM, and 97.7% average success on LIBERO is much harder to ignore.
That is the pitch behind TurboVLA, a paper released on July 30 by researchers at Huazhong University of Science and Technology and Huawei. The interesting part is not the size of the checkpoint by itself. It is the decision to remove the large language model from the execution loop entirely.
Most vision-language-action systems follow a V to L to A path. The camera image goes into a visual encoder, the instruction is aligned with a language model, and the resulting representation is decoded into robot movement. That design inherits a useful property from large language models: broad semantic knowledge. It also inherits the bill. OpenVLA, for example, uses 7.7 billion parameters, about 15.7 GB of VRAM in the comparison reported by the TurboVLA project, and reaches roughly 6 Hz on an RTX 4090 without extra acceleration tricks.
TurboVLA takes a narrower view of the job. If the instruction already says stack the bowls or place the red block in the tray, the controller does not need to write an answer, plan a paragraph, or perform open-ended reasoning. It needs to connect the words to the current scene and produce the next chunk of motor commands quickly. The authors call this direct V plus L to A.
The visual side uses DINOv3. The text side uses BERT base uncased rather than a generative language model. The two feature streams are projected into a shared 256-dimensional space and passed through six bidirectional vision-language interaction layers. An ACT-style transformer decoder then combines the fused representation with robot state and predicts a continuous action chunk. The default horizon is 12 actions. Training uses behavior cloning with an L1 loss on four RTX 4090 GPUs.
That sounds like a small engineering change until the numbers are placed next to the alternatives.
| Policy | Parameters | VRAM | Latency | LIBERO average |
|---|---|---|---|---|
| TurboVLA | 0.2B | 0.9 GB | 31.2 ms | 97.7% |
| VLA-Adapter | 1.5B | 4.3 GB | 87.3 ms | 97.3% |
| pi0.5 | 3.4B | 12.8 GB | 93.6 ms | 96.9% |
| OpenVLA-OFT | 7.7B | 15.7 GB | 112.2 ms | 97.1% |
| SmolVLA | 2.3B | 7.1 GB | 203.1 ms | 88.8% |
On this benchmark, the compact policy is not merely cheaper. It is faster than every comparison in the table while scoring at the top. The speed comes from removing token-by-token generation and avoiding a multi-billion-parameter language core on every policy invocation. The 31.2 ms figure corresponds to 32 Hz, which leaves enough control updates for responsive tabletop manipulation on a consumer GPU.
The ablations are useful because they show where the result comes from. With two interaction layers, the reported LIBERO average is 93.5%. Six layers raise it to 97.7%. Eight layers drop it to 96.6%, so the team did not simply make the cross-modal block deeper and call it progress. The action horizon behaves similarly: eight steps reach 96.4%, 12 steps reach 97.7%, and 15 steps fall to 95.6%. The best version sits in the middle.
TurboVLA also reports 60.2% on RoboTwin 2.0 Clean50, a 50-task bimanual suite. That score beats pi0.5 at 57.0% and StarVLA-alpha at 50.3% in the project page comparison, although this setting uses a larger DINOv3 ViT-L encoder and a 50-step action head. The result is encouraging, but it is not the same claim as saying that a 0.2B policy solves every kind of robot problem.
Here is the catch. LIBERO is a simulation benchmark built around constrained tabletop tasks. The model is designed for execution-level instructions, not broad task planning. It does not inherit the open-vocabulary knowledge that makes an LLM-centric controller attractive. Asking it to interpret an unfamiliar household scene, break a vague request into subtasks, and recover from a long sequence of mistakes is a different problem. TurboVLA's own conclusion points toward a hierarchy: let a larger model plan, then let a compact policy execute.
That boundary matters more than the headline. A 32 Hz controller with less than 1 GB of VRAM changes the hardware conversation for small labs and edge robots. It makes local inference realistic on machines that cannot host a 7B or 13B policy, and it cuts the latency penalty that turns a capable demo into a sluggish machine. But it does not make language models irrelevant to robotics. It makes the division of labor sharper.
The paper is a good reminder that a robot does not need a chatbot in the motor loop just because the command arrived as text. Sometimes the expensive general-purpose middle layer is doing work the controller never needed. The next test is physical transfer across unfamiliar objects and instructions. If the 0.9 GB footprint survives that test, the practical consequence will be bigger than another benchmark win: robot intelligence will look less like one giant model and more like a stack of small systems that each do one job well.
The technical details and reported results are documented in the official TurboVLA project page, the Apache 2.0 GitHub implementation, the arXiv paper, and the Hugging Face paper listing.