A new framework called VERITAS pairs a generalist robot policy with a gradient-free visual verifier that evaluates actions during inference, letting robots steer their behavior and improve from their own rollouts without human feedback.
What the Researchers Built
Researchers developed VERITAS, a generator-verifier framework for generalist robot policies that enables two capabilities: inference-time action steering and autonomous policy improvement. The system takes any pre-trained generalist robot policy (the "generator") and pairs it with a separate "visual verifier" — a model that evaluates the correctness of proposed actions using only visual input. The verifier works without any gradient computation, making it lightweight and compatible with existing policies.
At inference time, the verifier scores multiple action candidates from the generator and selects the best one, enabling the robot to steer away from suboptimal moves without any fine-tuning. The same verified rollouts are then used as training data to improve the generator itself through offline learning. This creates a self-sustaining loop: the robot acts, verifies its actions, learns from the good ones, and improves for the next trial.
The framework is designed for real-world deployment where robots need to adapt without human supervision. By relying solely on visual feedback, VERITAS removes the need for human-labeled rewards, preference annotations, or online environment resets.
Key Results
VERITAS consistently outperformed vanilla generalist policies — those used without any verification or steering — across multiple manipulation tasks. The improvement came from inference-time verification alone, without any additional training or data collection.
When the researchers fine-tuned the generator policy using its own verified rollouts, the performance gains were maintained and even amplified. Crucially, models fine-tuned on self-generated verified trajectories reached efficiency levels comparable to those trained on expert demonstrations — but without requiring any human interventions or demonstrations.
The results show that inference-time verification is not just a one-time fix but a scalable mechanism for continuous improvement during deployment. The framework does not degrade policy performance over repeated self-training cycles, indicating stable self-improvement.
How It Works
VERITAS operates in two phases: inference-time steering and offline policy improvement.
Inference-time steering: At each time step, the generator policy produces multiple action candidates (e.g., via sampling or stochastic forward passes). The visual verifier takes the current observation and each candidate action as input and outputs a score indicating how likely that action is to succeed. The robot executes the highest-scoring action. The verifier is a gradient-free model — it does not require backpropagation, so it runs fast and can be used with any generator.
Offline policy improvement: After a deployment session, the robot has a dataset of observations and the verified actions it actually took. These "verified rollouts" serve as positive examples for offline fine-tuning of the generator. The policy is updated using standard behavior cloning or offline RL, but the data is self-generated and self-verified. No human labels, no hand-coded reward functions, no environment resets.
The visual verifier itself is trained once from a small set of demonstration data (e.g., success/failure labels on images). After that, it generalizes to new tasks and scenes without retraining. Because it uses visual features rather than proprioceptive signals, it works even when the robot interacts with different objects or surfaces.
The entire pipeline is designed to be modular: the generator and verifier can be swapped independently, and the verification step adds minimal latency — on the order of a few milliseconds per action.
Why This Matters for Robotics
The biggest barrier to deploying generalist robot policies in the real world is the so-called "sim-to-real gap" and the inability to adapt after deployment. VERITAS addresses both without requiring expensive human feedback or manual data collection.
For operations managers and engineers running fleets of warehouse robots or used industrial robots, this means robots could gradually improve their performance on specific tasks after being installed — picking new objects, navigating cluttered areas, adapting to variations in lighting or setup — all without calling in a robotics team.
For developers building humanoid robots or generalist assistants, the framework provides a practical path to continuous learning: let the robot try, verify, and improve. It reduces the need for high-quality expert demonstrations and makes self-supervised improvement a reality.
VERITAS shifts the focus from collecting more data to making better use of the data the robot itself generates — a more scalable and cost-effective approach for real-world robotics.
Limitations and Open Questions
The visual verifier's performance depends on the quality and diversity of its training data. If the verifier has not seen certain failure modes, it may incorrectly score actions. This could lead to overconfidence in unsafe moves or rejection of useful exploratory actions.
The framework also assumes that the generator can produce diverse action candidates. If the policy collapses to a single mode (e.g., due to deterministic inference), steering has no effect. Future work will need to ensure robust candidate generation.
Additionally, the offline fine-tuning step is currently performed in batch after deployment. Real-time or continuous learning during a single episode is not yet supported. Finally, the paper does not address safety guarantees — what happens when the verifier consistently misses a failure pattern during self-training remains an open question.
Frequently Asked Questions
Does VERITAS require any human-labeled data at all? Yes, a small set of success/failure labels on images is needed to train the visual verifier once, but this is a one-time cost. The generator policy itself never needs human demonstrations again after initial training.
Can I use VERITAS with my existing robot policy? If your policy can produce multiple action candidates per time step and you have access to a camera, you can plug it into VERITAS. The verifier is model-agnostic and gradient-free.
What types of robots does VERITAS work for? The framework was demonstrated on manipulation arms, but it generalizes to any robot that uses visual observations and has continuous or discrete action spaces — including mobile manipulators and legged robots.
How much does inference-time verification slow down the robot? The verifier adds only a few milliseconds per action, so it's negligible for most real-time control loops. The main cost is generating multiple action candidates from the policy, which can be parallelized.
Conclusion
VERITAS introduces a practical way for generalist robot policies to improve their performance at inference time using a lightweight visual verifier, and to learn from their own verified experiences without human help. The framework achieves expert-level efficiency from self-generated data, making self-improving robots a realistic goal for deployment.