Hugging Face just dropped LeRobot v0.6.0, and it's the most complete robot learning release we've seen from the open-source robotics stack. This isn't just a model drop—it's the infrastructure for closing the full learning loop: policies that imagine consequences, reward models that score success without human labels, a deployment CLI that turns real-world failures into training data, and six simulation benchmarks under one evaluation interface.
The headline is clear: LeRobot is no longer just a training framework. It's becoming the platform where you evaluate, deploy, and iterate on robot policies end-to-end.
World models: policies that learn to imagine
The robotics community has been wrestling with a question: do world models actually help robot policies, or are they just expensive pretraining? LeRobot v0.6.0 brings three policies to the table, each with a different answer.
VLA-JEPA: free world-model supervision
VLA-JEPA trains a compact VLA (built on Qwen3-VL-2B) to predict future frames in latent space while learning actions. The clever bit: the world model runs during training but disappears at inference, so you get world-model supervision at zero runtime cost.
Three pretrained checkpoints are live on the Hub, including a DROID-pretrained base ready for fine-tuning. The architecture is opinionated—JEPA-style latent prediction rather than pixel reconstruction—betting that abstract representations matter more than photorealism for manipulation.
LingBot-VA: autoregressive video-action
LingBot-VA goes full autoregressive: it predicts future video and actions together, chunk by chunk, feeding real observations back in to keep imagination grounded. You can save the predicted video with --policy.save_predicted_video=true and compare what the robot imagined versus what actually happened.
This is the most computationally honest of the three—inference needs a single 24–32 GB GPU, so it's not hiding the world-model cost. But you get actual video predictions you can debug.
FastWAM: dream during training, skip at inference
FastWAM asks the smartest question: do you need test-time imagination at all? It pairs a ~5B video-generation expert with a compact action expert in a single network. The model learns to dream rollouts during training, then at inference it skips the dreaming and directly denoises action chunks.
It's the inverse of VLA-JEPA's architecture but shares the same philosophy: world models are supervision, not inference-time tools. Fine-tune from lerobot/fastwam_base if you want the fastest world-model-trained policy in the lineup.
VLAs: the model zoo keeps growing
LeRobot is becoming the Hugging Face Transformers of robotics: if a credible VLA gets published, it lands in LeRobot with training, evaluation, and deployment ready to go.
GR00T N1.7: NVIDIA's latest foundation model
The NVIDIA GR00T integration upgrades to N1.7, swapping the previous VLM for Cosmos-Reason2-2B (built on Qwen3-VL) with a flow-matching action head. LeRobot's integration is parity-tested against NVIDIA's Isaac-GR00T implementation—same inputs, same outputs.
Flash-attention is now optional, so pip install 'lerobot[groot]' just works. You can load NVIDIA's published checkpoints directly. N1.7 replaces N1.5 entirely; if you need the old version, pin lerobot==0.5.1.
MolmoAct2: Allen Institute's VLA, zero-shot ready
MolmoAct2 from the Allen Institute for AI gets full lifecycle coverage: fine-tuning (full or LoRA), evaluation, and real-robot deployment. Ready-made checkpoints with calibration correction baked in mean you can run it zero-shot on an SO-100/101 arm.
Inference fits in ~12 GB at bf16, and LoRA fine-tuning runs on a single 24 GB GPU. This is one of the easiest VLAs to deploy if you have compatible hardware.
EO-1, Multitask DiT, and EVO1
EO-1 brings a Qwen2.5-VL-3B backbone with flow-matching action head, pretrained on interleaved vision-text-action data. Multitask DiT ships the TRI Large Behavior Models recipe: a ~450M-parameter diffusion transformer conditioned on CLIP vision and language, small enough to train yourself.
EVO1 is the efficiency play: 0.77B parameters, InternVL3-1B backbone, flow-matching action head, real-time chunking support. It's small enough to fine-tune and run on modest GPUs, which matters if you're scaling to fleets.
Reward models: knowing when your robot succeeds
This is the sleeper feature. Success detection and progress estimation have been missing pieces in the robot learning loop, and LeRobot v0.6.0 gives them a unified API.
The new lerobot.rewards module mirrors the policies API: four reward models behind one interface, including the HIL-SERL reward classifier, SARM, and two new entries.
Robometer: pretrained, general-purpose reward
Robometer is a pretrained reward model that scores task progress and success from raw video plus language instruction, with no task-specific training. Point lerobot/Robometer-4B at any LeRobot dataset and it returns per-frame progress curves.
It's built on Qwen3-VL-4B and trained via trajectory comparisons over more than one million robot trajectories. This is the first credible attempt at a universal reward function for manipulation, and it ships with labeling scripts that write progress curves directly into your dataset.
TOPReward: fully zero-shot
TOPReward goes even further: no reward weights at all. It wraps an off-the-shelf VLM (Qwen3-VL by default) and reads the log-probability of the token "True" given trajectory video and task instruction.
Any capable VLM becomes a reward function. It's hacky and brilliant—language model logits as reward signal, no training required. The implicit claim is that VLMs already encode enough common-sense physics and goal understanding to score manipulation success.
Both models support reward-aware behavior cloning (RA-BC), dataset quality inspection, and progress-overlay videos.
Datasets: faster, richer, more flexible
Custom video encoding
Recording is no longer locked to one codec. The new --dataset.rgb_encoder.* options expose codec, quality, pixel format, GOP, and presets. vcodec=auto probes for hardware encoders (NVENC, VideoToolbox, VAAPI, QSV) before falling back to software AV1.
For existing datasets, one command re-encodes everything. This matters because different robots have different recording constraints—some need low-latency h264 for live streaming, others want high-compression AV1 for archival.
Depth support, end to end
Plug in an Intel RealSense, set use_depth: true, and LeRobot records depth maps end to end: captured in millimeters, compressed as 12-bit depth video streams, decoded back to physical units at training time.
Depth renders live during recording and in lerobot-dataset-viz. It works across SO-100/101, Koch, OpenArm, reBot, Unitree G1, and more. This is a big deal for manipulation policies that need geometric understanding—RGB-only training has been a known limitation.
Language annotations at scale
Datasets now natively store rich language annotations: timestamped subtasks, plans, corrections, per-camera VQA pairs. The new lerobot-annotate CLI fills them in automatically using a VLM that watches your episodes.
A YAML recipe layer renders these annotations into chat-style training messages at sample time. This is the data format tomorrow's long-horizon, language-conditioned policies will train on, and LeRobot is automating the annotation pipeline now.
2x faster data loading
Training on video datasets is up to ~2x faster: multi-camera frames decode in parallel, dataloader workers ship compact uint8 frames (4x less memory), and persistent workers keep decoder caches alive. Loading a subset of a large dataset dropped from 275 seconds to 0.06 seconds in benchmarks.
Sampling is deterministic and resumable, so interrupted trainings restart sample-exact.
Benchmarks: one CLI to evaluate them all
LeRobot v0.5.0 positioned itself as an evaluation hub; v0.6.0 delivers with six new simulation benchmarks, all runnable through lerobot-eval.
- LIBERO-plus: ~10,000 perturbed variants of LIBERO across lighting, camera viewpoints, and rewritten instructions
- RoboTwin 2.0: 50 bimanual manipulation tasks with heavy domain randomization and 100k+ trajectories on the Hub
- RoboCasa365: 365 kitchen tasks in 2,500 procedurally generated kitchens on a mobile manipulator
- RoboCerebra: long-horizon episodes chaining 3 to 6 sub-goals under language-grounded intermediate rewards
- PegasusRL: dexterous hand manipulation tasks with continuous control
- ManiSkill3: GPU-parallelized manipulation suite
Each benchmark has a docs page, a Docker image, and a SmolVLA baseline checkpoint smoke-tested in CI. The unified CLI means you can compare policies across benchmarks without rewriting evaluation scripts.
Training and deployment
lerobot-rollout: deployment gets its own CLI
The new lerobot-rollout CLI handles real-robot deployment with DAgger-style human-in-the-loop corrections. When the robot fails, you take over, and those corrections become training data.
This closes the learning loop: deploy, collect failure cases, retrain, repeat. It's the workflow that made DAgger work in 2011, now productized into a CLI.
FSDP and cloud training
Fully Sharded Data Parallel (FSDP) support means you can train models bigger than your GPU. Cloud training on HF Jobs is now documented and supported, so you can scale annotation pipelines and training runs without managing infrastructure.
The codebase is also leaner: installation is faster, dependencies are trimmed, and the API surface is more consistent.
Final thoughts
LeRobot v0.6.0 is the release where the framework becomes a platform. World models, reward models, unified benchmarks, deployment CLI, and dataset tooling all shipped in one release.
The implicit bet is clear: open-source robotics needs more than model weights. It needs the full stack—data pipelines, evaluation infrastructure, deployment tools—all working together. If you're building robot policies in 2026, this is the release that makes LeRobot hard to ignore.