.png)
Hugging Face released LeRobot v0.6.0, adding world model policies, new VLA checkpoints, reward models, a unified benchmark runner, and a dedicated rollout CLI. The release pushes LeRobot further from a research repo toward a usable stack for training, evaluating, and iterating on robot policies.
The main technical addition is a set of policies that learn to predict future observations as part of control training, then drop the world-model component at inference time. That keeps the training signal from imagination without paying an inference penalty when the policy is deployed.
VLA-JEPA is built on Qwen3-VL-2B and trains a compact VLA to anticipate future frames in latent space while learning the control policy. The world model is conditioned on the model’s own actions during training, so the policy learns action-conditioned future prediction instead of only imitation from static context.
The important engineering detail is that the predictive component is only present during training. At inference, the world model is removed, so the deployment path stays as lean as a standard VLA. That makes the approach attractive if the added training complexity translates into better robustness or longer-horizon behavior, because the serving cost does not increase.
Hugging Face ships three checkpoints for this family, including a DROID-pretrained base intended for fine-tuning. The release also exposes a training command for starting from the pretrained policy and writing a fine-tuned checkpoint back to the Hub:
lerobot-train \
--policy.path=lerobot/VLA-JEPA-Pretrain \
--dataset.repo_id=${HF_USER}/my_dataset \
--policy.repo_id=${HF_USER}/my_finetuned_policy
LeRobot v0.6.0 also adds several new VLA-style policies: GR00T N1.7, MolmoAct2, EO-1, EVO1, and Multitask DiT. The practical significance is not the count itself, but that LeRobot is increasingly becoming a comparison surface for model families that differ in backbone, action parameterization, and training recipe.
For teams evaluating robot policies, this is useful because it reduces the amount of glue code needed to do head-to-head comparisons. A model zoo only matters if the evaluation stack is consistent enough to make scores meaningful, and this release leans in that direction by pairing the models with the benchmarking and rollout tooling below.
The release adds a reward-model API with support for Robometer and TOPReward. That gives LeRobot a place to plug in learned success estimators instead of relying only on sparse environment success or manually defined heuristics.
For robot learning systems, this matters because reward models often become the practical bridge between offline data, online correction loops, and policy selection. If the API is clean enough, teams can use the same interface to compare reward models across datasets, use them for reranking, or wire them into filtering and evaluation workflows without building one-off wrappers each time.
The source material is light on implementation specifics, so the exact contract and calibration behavior still need inspection in the docs before treating this as production-ready infrastructure.
LeRobot v0.6.0 makes datasets more usable and evaluation more standardized at the same time. Dataset handling now includes depth support, an automatic language annotation pipeline, custom video encoding, and data loading that is up to 2x faster. Those are the kinds of changes that compound quickly when you are iterating on robot data at scale.
On the evaluation side, six new simulation benchmarks are unified under lerobot-eval. Each benchmark has its own docs page, Docker image, and a SmolVLA baseline checkpoint that is smoke-tested in CI. That is a much stronger contract than a loose benchmark collection, because it turns evaluation into something reproducible enough to track regressions across model and code changes.
The more interesting architectural point is that LeRobot is converging on a single evaluation entrypoint for different tasks and model families. For robot ML stacks, that is often the difference between “we have benchmarks” and “we can trust the numbers.”
LeRobot now splits deployment into a dedicated lerobot-rollout CLI. This is the right move. Training-time tools and deployment-time tools tend to diverge quickly once real hardware enters the loop, and a separate rollout interface lets the project optimize for control latency, backend selection, and correction workflows without overloading the training CLI.
The rollout tooling supports pluggable execution strategies and inference backends, including Real-Time Chunking for compatible slow VLAs. It also adds a DAgger-style human-in-the-loop correction loop, which is the most operationally relevant feature in the release for teams collecting corrective data from live robots.
Training support also moves forward with FSDP and cloud training on HF Jobs. That combination makes LeRobot more viable for larger policies and for teams that want to scale experiments without building their own distributed training harnesses around the framework.
The release also trims the codebase and installation footprint. That sounds mundane, but in robotics stacks it usually decides whether a framework gets adopted by more than one team. A leaner install lowers the cost of trying the stack, and the stronger docs-and-CI pairing around checkpoints and benchmarks lowers the cost of trusting it.
v0.6.0 is the first LeRobot release that looks like a coherent platform rather than a set of adjacent research utilities: policies can imagine, reward models can score, datasets are richer and faster, benchmarks are standardized, and rollout is its own workflow. For teams building embodied AI systems, that combination is more valuable than any single model drop.
