Vision language action models are the reason robots are finally leaving the lab, and the shift is measurable: roughly 13,000 humanoid robots shipped worldwide in 2025, with Chinese manufacturers taking the top five spots by volume (Source: Omdia).
Behind almost every one of those machines sits the same architectural idea. Instead of wiring together separate systems for seeing, planning, and moving, a vision language action model, usually shortened to VLA, folds all three into one neural network that takes in camera images and a plain-language instruction, then outputs motor commands.
That single design choice changes what robots can do. A warehouse arm running a VLA can pick items it has never seen. A humanoid can hear “put the groceries away” and figure out the steps itself. You do not program behaviors anymore. You train them, the same way language models learned to write by reading the internet.
Key Takeaways
- VLA models combine vision, language understanding, and motor control in one network.
- Leading systems include Figure’s Helix, NVIDIA GR00T, Google’s Gemini Robotics, and π0.
- Dual-system designs pair a slow reasoning model with a fast action generator.
- Data scarcity, not model architecture, is the biggest bottleneck.
- Open models like OpenVLA and GR00T let smaller teams build on foundation policies.
What Is a Vision Language Action Model?
A vision language action model is a foundation model for robots. It extends a vision language model, the kind that can describe a photo or answer questions about an image, with a third capability: producing continuous control signals for a physical body.
The input side looks familiar. Camera frames get encoded into visual tokens. The instruction, something like “fold the shirt on the left,” gets tokenized as text. The robot’s own state, joint angles and gripper position, joins the stream. The output side is where things diverge from chatbots. Instead of predicting the next word, the model predicts the next action: target joint positions, end-effector movements, gripper commands, often dozens of timesteps at once.
Google DeepMind’s RT-2 proved the concept in 2023 by showing that web-scale visual knowledge could transfer into a robot arm. The model knew what a “dinosaur toy” was without any robot demonstration involving dinosaurs, because it had seen thousands of them in internet images. That transfer, from web knowledge to physical skill, is the core promise of the whole category.
How VLA Models Work
Most production systems in 2026 share three design patterns. Each one exists to solve the same tension: large models reason well but run slowly, and robots need fast, smooth control.
Dual-System Architecture
The dominant pattern splits the model in two. A heavyweight vision language backbone runs at 5 to 10 Hz, handling scene understanding and task planning. A lightweight action expert, usually a diffusion or flow-matching model, runs at 50 to 100 Hz and converts the backbone’s latent plan into motor commands. Figure AI’s Helix and NVIDIA’s GR00T both formalize this split, sometimes described as System 2 (slow, deliberate) and System 1 (fast, reactive), borrowing Daniel Kahneman’s terms for human cognition.
Action Chunking
Rather than predicting one action per inference step, the policy emits a chunk of 8 to 50 future actions at once. The robot executes the chunk while the next one computes. This cuts the effective inference-rate requirement dramatically and produces smoother motion than step-by-step prediction.
Compression for the Edge
Robots cannot phone a data center for every grasp. Quantization, distillation, and pruning shrink policies until they fit on-robot hardware, Jetson-class devices in particular, running at single-digit watts. On-device inference reduces latency and keeps the robot working when the network drops.
The Systems Defining the Category
Five model families dominate the conversation right now.
Helix (Figure AI). Controls the full upper body of Figure’s humanoids, arms, hands, torso, and fingers, at high frequency. Its dual-system design lets it generalize across household tasks while meeting the real-time demands of dexterous manipulation.
GR00T (NVIDIA). An open foundation model for humanoid robots, now at version N1.6. It trains on a mix of real captured data and synthetic data generated in NVIDIA’s Isaac simulation stack, and it adapts to new robot bodies through post-training. Because the weights are open, GR00T has become the default starting point for labs that cannot collect massive datasets themselves.
Gemini Robotics (Google DeepMind). Built on the Gemini language model family and developed with humanoid maker Apptronik. The 1.5 release, from late 2025, added deeper embodied reasoning and motion transfer between different robot bodies. Its “thinking before acting” approach has the model reason in natural language internally before it commits to movement.
π0 (Physical Intelligence). A flow-matching VLA from the startup founded by researchers behind much of the field’s academic groundwork. The π series, now several versions in, focuses on general-purpose manipulation across many robot types.
OpenVLA. A 7-billion-parameter open-source model that put a working VLA within reach of academic labs. It is smaller and less capable than the commercial systems, but it made the architecture reproducible, which accelerated everything else.
The pattern across all five mirrors what happened in language AI, which is why so many teams building agentic AI systems are watching robotics closely. Scale the data, scale the model, let the policy generalize.
Where VLA Models Are Deployed Today
Production deployments stopped being demos sometime in 2025. Warehouse manipulation leads the way. Systems descended from Covariant’s RFM-1, acquired into Amazon Robotics, handle billions of pick-and-place actions a year on long-tail items that hand-coded grasp libraries could never cover.
Humanoid pilots in manufacturing come next, with Figure, Apptronik, and a wave of Chinese makers placing robots on factory floors for tote handling and machine tending.
Logistics, healthcare support, and smart infrastructure round out the early list. None of these environments are fully structured, which is exactly the point. Traditional robot programming works when the world holds still. VLA models are the bet for when it does not.
The Hard Problems That Remain
Be skeptical of anyone claiming this is solved. Four challenges dominate current research.
Data scarcity. Language models trained on trillions of web tokens. There is no internet of robot actions. Teams compensate with teleoperation (expensive), simulation (imperfect physics), and human video (no action labels). Ant Group’s LingBot-VLA, trained on 20,000 hours of real dual-arm data, hints at industrial-scale collection, but the field remains data-starved compared with language AI.
Inference latency. Dexterous tasks need control at 50 Hz or faster. Every architectural trick above, chunking, dual systems, quantization, exists because big models are slow.
Generalization gaps. A policy that folds shirts in the training kitchen may fail in yours. Benchmark performance of the underlying vision language model, oddly, does not predict downstream robot performance, which complicates model selection.
Safety. A wrong word from a chatbot is embarrassing. A wrong motion from a 60-kilogram humanoid is dangerous. Verification methods for learned policies lag far behind the policies themselves, a gap that concerns anyone who has studied how autonomous agents coordinate in less physical settings.
How to Get Started
You do not need a humanoid to work with VLA models. A realistic entry path looks like this. Start with LeRobot, Hugging Face’s open robotics library, which wraps OpenVLA, π0-style policies, and standard benchmarks behind one API. Pair it with a low-cost arm kit; several sell for under a thousand dollars. Fine-tune an open checkpoint like GR00T N1.6 on a few hundred teleoperated demonstrations of your specific task rather than training from scratch.
For teams evaluating the space commercially, the questions to ask vendors are concrete. What data was the base policy trained on? How many demonstrations does adaptation to your task require? What happens on out-of-distribution inputs? Does inference run on-robot or off? The answers separate production-ready systems from impressive videos. The broader context, from novel compute approaches like physical reservoir computing to conventional GPU stacks, keeps shifting quickly enough that a quarterly re-check is worth your time.
Conclusion
Vision language action models collapsed a decades-old pipeline, perception, planning, control, into a single trainable system, and the results are visible on real factory floors this year. The architecture questions are settling around dual-system designs and action chunking. The open ecosystem, GR00T and OpenVLA especially, means you can experiment without a research lab’s budget.
The honest caveat: data remains the binding constraint, and generalization claims deserve testing in your environment, not the vendor’s. Watch shipment numbers, watch open-model releases, and if robotics touches your industry at all, get hands-on with the open tooling now. The teams that understand these systems before they mature will pick the winning platforms while everyone else reads the announcements.
Read Next
Keep going with more coverage of autonomous systems and applied AI:
- What Is Agentic Orchestration? A Guide
- Agentic AI Systems Explained: A Beginner’s Guide
- Harnessing Physics for AI: The Rise of Physical Reservoir Computing
Frequently Asked Questions
Vision language action models are neural networks that combine visual perception, language understanding, and motor control in a single system. They take camera images and a text instruction as input and output the movement commands a robot executes, letting one model handle tasks that used to require separate perception, planning, and control software.
Vision language models interpret images and text but only produce text as output. Vision language action models add a third modality, action, so the output is continuous robot control signals rather than words. Most VLAs are built by extending a pretrained vision language model with an action decoder.
The most prominent vision language action models come from Figure AI (Helix), NVIDIA (GR00T), Google DeepMind (Gemini Robotics), and Physical Intelligence (π0), with OpenVLA serving as the leading open academic model. Ant Group and several Chinese robotics firms have also released large-scale VLA systems.
Yes. Vision language action models run on robot arms, mobile manipulators, and other form factors, and open libraries like LeRobot support low-cost hardware kits. Fine-tuning an open checkpoint on a few hundred demonstrations is a common starting point for smaller teams.
Data scarcity is the biggest limitation facing vision language action models. There is no web-scale dataset of robot actions comparable to the text that trained language models, so teams rely on costly teleoperation, simulation, and human video, and policies can still fail on situations far outside their training data.
