VLA vs RAX: two paths to robot learning

By Lentin Joseph, CEO, RUNTIME Robotics

Most Vision-Language-Action (VLA) models learn robot behaviors by imitating demonstrations, usually collected through hours of teleoperation. But what if a robot could explore, experiment, learn from its failures and write its own executable skills?

That is the idea behind RAX (Robot Agent eXploration), a recent research project that uses LLM-powered coding agents to discover robot behaviors through online exploration, without action demonstrations, hand-engineered action primitives or policy training. It’s an interesting new direction for Physical AI.

Two ways to learn

Both approaches start from the same goal: turn observations into actions. They differ in where the learned behavior lives.

  • VLA, a learned policy. A neural network learns actions from robot experience. The behavior lives in the model’s weights.
  • RAX, a code agent. An LLM discovers skills through online trials. The behavior lives in programs you can read.
VLA and RAX learning loops VLA turns vision and an instruction into robot actions through a neural action model trained on demonstrations. RAX turns a goal and camera state into a reusable robot program, with an LLM that writes, tests and rewrites code. Both run on safe low-level control. VLA behavior in weights RAX behavior in programs Vision + instruction Neural action model Robot action Goal + camera / state LLM writes & tests code Reusable robot program trained on demos try · fail · rewrite Safe low-level control · robot APIs · controllers
Both loops still rely on safe low-level control. RAX builds on existing robot APIs and controllers.

Where each one excels

VLA is strong at continuous, contact-rich motion: grasping, dexterous handling and learned visuomotor control. Its challenges are the cost of training data, GPU compute, and domain shift when the robot meets a new environment.

RAX is strong at self-exploration, producing reusable skills you can inspect. Its challenges are slow discovery, safety risks while exploring, and programs that can be brittle. The key distinction: RAX doesn’t need action demonstrations or teleoperation data. A new robot is integrated through its APIs alone.

Which fits the task?

Task type VLA RAX
Continuous motor control Strong fit Needs a controller
Learning without demos Usually harder Core advantage
Long-horizon routines Needs orchestration Skill composition
Readable task logic Limited Code can be audited
Real-world reliability Task-dependent Task-dependent

What the RAX paper reports

According to Huang et al. (2026):

  • More exploration, better results. On unseen simulation scenes, the score rises from 25% after 4 exploration episodes to 79% after 128, against a previous best of 41.2%.
  • +37.4 percentage points on average over the top baselines, across five simulation benchmarks.
  • Real robots, no demonstrations. RAX learned high-precision, deformable, articulated and long-horizon mobile manipulation tasks on real robots, reusing verified skills from earlier sessions.

These are the authors’ own benchmark results. They show RAX works on real hardware, but not yet the long-term reliability that production deployments need.

RAX isn’t alone. Several other projects explore robots that improve through their own execution:

  • ASPIRE (Agentic Skill Programming through Iterative Robot Exploration), from NVIDIA’s GEAR lab: writes code-as-policy robot programs, diagnoses failures from execution feedback, repairs them and saves reusable skills.
  • SEAR (Self-Evolving Agentic Robotics): language agents refine control code, carry skills and memories across tasks, and train action models on their own rollouts. It already mixes code and learned models.
  • RHO (Robotics Harness Optimization): a coding agent rewrites a robot’s control code in simulation until it solves the task. It reports 99.0% on the Robosuite benchmark with zero demonstrations, and the code runs unchanged on real Franka and Kinova arms.
  • RoboClaw (Agentic Robotics Framework): a single vision-language model runs data collection, policy training and task execution for long-horizon manipulation. Each action is paired with a recovery action, so the robot can reset itself and keep collecting data. It’s another example of an agent working with learned VLA policies.

Their learning mechanisms differ, but they all point toward robots that can grow their own capabilities from experience.

The interesting direction: VLA + RAX

I don’t see these as competitors. A promising architecture combines them:

  • RAX explores the task, generates a program and verifies the skill.
  • VLA executes learned motor behaviors where code alone falls short.

The hard part is making such systems reliable, efficient and safe enough for real-world deployment. That means the same evaluation ladders, safety layers and staged rollouts we cover in Physical AI in Production.

Explore the research

Will autonomous exploration and self-improving robot agents reduce our dependence on teleoperation and demonstration datasets? And what would you benchmark first? If you’re exploring VLA or agentic robotics for your own robots, get in touch with RUNTIME Robotics.