LeRobot v0.6: Reward Models and lerobot-eval CLI

On July 7, 2026, Hugging Face released LeRobot v0.6.0 — the most substantial update in the project's history. While previous versions focused on data collection and policy training, v0.6 tackles the hardest unsolved problem in robotics projects: how do you know if your robot is learning correctly, and how do you automatically keep improving it?

LeRobot v0.6's answer comes in three interlocking pieces:

• Reward Models (Robometer + TOPReward) to automatically evaluate trajectory quality
• lerobot-eval CLI with 6 new simulation benchmarks to standardize policy evaluation
• lerobot-rollout + DAgger to collect correction data on real hardware in the loop

This guide covers how each tool works and how to wire them together into a complete automated RL pipeline.

The Problem: Why Robot RL Loops Keep Breaking

Picture this: you collect 100 pick-and-place demonstrations, train a policy, run it — the robot handles steps 1 and 2 fine but fails at step 3. You collect more data, retrain, but you don't know if the new data actually helps or makes things worse.

This is the broken RL loop that plagues most robotics projects:

Collect data → Train → Run → See failure → Collect more → Retrain → ...

The problem lives in evaluation: you have no automatic way to know:

1. Which episodes in your dataset are high-quality, which are garbage?
2. How much better is the new policy than the old one, in percentage?
3. When should you intervene during deployment to collect corrections?

LeRobot v0.6 answers all three.

Installing LeRobot v0.6

# Base install
pip install lerobot

# Add reward models (Robometer)
pip install "lerobot[robometer]"

# Or from source with uv
uv sync --extra robometer --extra evaluation

LeRobot v0.6 slimmed down dependencies by ~40% for the base install. Heavy features (reward models, simulation benchmarks) are optional extras — you only pay for what you use.

Robometer — A General-Purpose Reward Model Trained on 1 Million Trajectories

The Core Idea

Robometer is a general-purpose reward model: you point it at any manipulation task without any fine-tuning and it produces dense progress and success scores from raw video plus a language instruction.

Original paper: ROBOMETER: Scaling General-Purpose Robotic Reward Models via Trajectory Comparisons (RSS 2026)

Architecture

Robometer builds on a Qwen3-VL-4B-Instruct backbone — a 4B-parameter vision-language model that understands video and text. Three lightweight prediction heads sit on top:

Training objective: L = L_pref + L_prog + L_succ — joint learning across three tasks for better generalization.

Training data: 1 million robot trajectories from diverse sources.

Using Robometer

Option 1: Direct load

from lerobot.rewards.robometer import RobometerConfig, RobometerRewardModel

cfg = RobometerConfig(
    pretrained_path="lerobot/Robometer-4B",
    device="cuda",
    reward_output="progress",  # or "success"
)
reward_model = RobometerRewardModel.from_pretrained(cfg.pretrained_path, config=cfg)

Option 2: Encode frames and compute reward

import numpy as np
from lerobot.rewards.robometer.modeling_robometer import ROBOMETER_FEATURE_PREFIX
from lerobot.rewards.robometer.processor_robometer import RobometerEncoderProcessorStep

# frames: np.ndarray shape (T, H, W, C), dtype uint8
# task: str — task description in natural language
frames = np.zeros((8, 480, 640, 3), dtype=np.uint8)  # placeholder
task = "Pick up the red block and place it in the bin"

encoder = RobometerEncoderProcessorStep(
    base_model_id="Qwen/Qwen3-VL-4B-Instruct",
    use_multi_image=True,
    use_per_frame_progress_token=True,
    max_frames=8,
)

encoded = encoder.encode_samples([(frames, task)])
batch = {f"{ROBOMETER_FEATURE_PREFIX}{key}": value for key, value in encoded.items()}

# reward: tensor of shape (batch_size,), values in [0, 1]
reward = reward_model.compute_reward(batch)
print(f"Task progress: {reward.item():.3f}")

Option 3: Reward factory (recommended)

from lerobot.rewards import make_reward_model, make_reward_model_config, make_reward_pre_post_processors

cfg = make_reward_model_config(
    "robometer",
    pretrained_path="lerobot/Robometer-4B",
    device="cuda",
    image_key="observation.images.top",  # camera key in your dataset
)
reward_model = make_reward_model(cfg)
preprocessor, postprocessor = make_reward_pre_post_processors(cfg)

The reward factory is the cleanest integration path into LeRobot's training loop. The preprocessor handles Qwen-VL encoding, the postprocessor handles output formatting.

A Practical Use Case: Dataset Quality Filtering

One of the best uses for Robometer is not online RL but dataset filtering. After collecting 500 demonstrations, score every episode with Robometer and drop the bottom 20% by progress score. Training on the filtered top 80% consistently outperforms training on the full noisy dataset.

How the Progress Head Works Internally

Progress prediction in the published checkpoint is discrete: the progress head outputs logits over 10 uniformly spaced bin centers in [0, 1]. LeRobot applies a softmax and takes the expectation over bin centers to produce a continuous value — matching the original ROBOMETER implementation.

For success, the head outputs raw logits per frame. LeRobot applies sigmoid. When reward_output="success", compute_reward() thresholds the last-frame success probability using success_threshold.

TOPReward — Zero-Shot Reward Without Any Training

The Elegant Idea

TOPReward (Token Probabilities as Hidden Zero-Shot Rewards) takes a completely different approach: no training at all. It wraps an off-the-shelf VLM (Qwen3-VL) and asks it:

"Looking at this trajectory video and task instruction, did the robot complete the task? True or False?"

Then it reads the log-probability of the token "True" in the VLM's output distribution. High probability = robot is doing well.

Paper: TOPReward: Token Probabilities as Hidden Zero-Shot Rewards for Robotics

from lerobot.rewards import make_reward_model_config, make_reward_model

cfg = make_reward_model_config(
    "topreward",
    vlm_id="Qwen/Qwen3-VL-7B-Instruct",
    device="cuda",
    image_key="observation.images.top",
    task_key="task",
)
reward_model = make_reward_model(cfg)

Robometer vs TOPReward — When to Use Which

Rule of thumb: Use Robometer in your continuous training loop where speed matters. Use TOPReward when evaluating a brand-new task where you have no reward data.

lerobot-eval CLI — Standardizing Manipulation VLA Benchmarking

The Old Problem: Every Paper Used Different Benchmarks

Before v0.6, every VLA paper evaluated on different benchmarks with different configs and metrics — cross-paper comparison was nearly impossible. LeRobot v0.6 introduces the lerobot-eval CLI to standardize this.

6 New Benchmarks

Plus continued support for LIBERO, Meta-World, and NVIDIA IsaacLab-Arena from previous versions.

Running lerobot-eval

Evaluate SmolVLA on RoboTwin:

lerobot-eval \
  --policy.path=lerobot/smolvla_robotwin \
  --env.type=robotwin \
  --env.task=beat_block_hammer \
  --eval.n_episodes=100 \
  --eval.batch_size=4

Evaluate on LIBERO-plus:

lerobot-eval \
  --policy.path=${HF_USER}/my_policy \
  --env.type=libero_plus \
  --env.task=KITCHEN_SCENE1_put_the_black_bowl_on_the_plate \
  --eval.n_episodes=50

Understanding the output metrics:

{
  "episode": {"pc_success": 0.82, "avg_sum_reward": 14.3},
  "task": {"pc_success": 0.79},
  "suite": {"pc_success": 0.76},
  "overall": {"pc_success": 0.74, "avg_max_reward": 0.91}
}

Results are hierarchically aggregated: episode → task → suite → overall. pc_success is the primary success rate. avg_sum_reward and avg_max_reward are useful for debugging reward model integration.

lerobot-rollout + DAgger — Closing the Loop on Real Hardware

Why DAgger Matters

Pure behavioral cloning suffers from distribution shift: the robot reaches states never seen in training and doesn't know how to recover. DAgger (Dataset Aggregation) addresses this by letting the robot run autonomously, having a human intervene when it's about to fail, and collecting corrections at the exact states where the policy struggles.

Deployment Strategies in lerobot-rollout v0.6

Running DAgger With an SO-100 Robot

lerobot-rollout \
    --strategy.type=dagger \
    --policy.path=${HF_USER}/my_manipulation_policy \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --dataset.repo_id=${HF_USER}/dagger_corrections \
    --dataset.single_task="Pick up the red block and place it in the blue bin"

The workflow in practice:

1. Policy runs pick-and-place autonomously
2. You see the gripper is about to miss the object
3. Press the intervention key — the leader arm drives to the follower's current pose (jerk-free handover)
4. You guide the correction with the leader arm
5. Release → policy resumes control
6. Every correction frame is tagged with intervention=True
7. Fine-tune the policy on collected correction data

The jerk-free handover is a key quality-of-life detail — the actuated leader arm is driven to the follower's pose before you take over, preventing sudden jerks that could damage hardware.

Fine-Tuning on DAgger Corrections

lerobot-train \
  --dataset.repo_id=${HF_USER}/dagger_corrections \
  --policy.path=${HF_USER}/my_manipulation_policy \
  --policy.repo_id=${HF_USER}/my_policy_v2 \
  --training.num_epochs=10 \
  --training.filter_by_key=intervention  # train only on correction frames

FSDP Training — Escaping Single-GPU Memory Limits

When your VLA model exceeds one GPU's VRAM, FSDP (Fully Sharded Data Parallel) shards parameters, gradients, and optimizer state across multiple GPUs. LeRobot v0.6 integrates FSDP through Hugging Face Accelerate:

# Train across 4 GPUs
accelerate launch --num_processes 4 \
  lerobot-train \
  --policy.type=smolvla \
  --policy.dtype=bfloat16 \
  --dataset.repo_id=${HF_USER}/my_dataset \
  --policy.repo_id=${HF_USER}/my_large_policy

FSDP checkpoints are automatically gathered back into a single model.safetensors file — loads exactly like any other LeRobot policy. You can even resume an FSDP run on a different number of GPUs.

HF Jobs — Cloud Training With One Flag

lerobot-train \
  --dataset.repo_id=${HF_USER}/so101_pick_place \
  --policy.type=act \
  --policy.repo_id=${HF_USER}/act_pick_place \
  --job.target=a10g-small  # options: t4-small, h100-large, 8xh200

LeRobot automatically:

1. Pushes your local dataset to a private Hub repo if needed
2. Submits the training job to HF compute
3. Streams logs to your terminal
4. Pushes the trained policy to Hub when done

From a T4 to 8x H200 — same command, just change --job.target. No SSH, no Docker setup.

World Models: VLA-JEPA and FastWAM

Beyond reward models and eval, v0.6 ships three world model policies:

VLA-JEPA

Built on Qwen3-VL-2B, VLA-JEPA adds a JEPA world model that must predict upcoming frames from the model's own actions. The key insight: the world model disappears at inference time. No extra compute cost, just better feature representations from world-model supervision during training.

lerobot-train \
  --policy.path=lerobot/VLA-JEPA-Pretrain \
  --dataset.repo_id=${HF_USER}/my_dataset \
  --policy.repo_id=${HF_USER}/vlajepa_finetuned

DROID-pretrained base available for direct fine-tuning.

FastWAM

FastWAM pairs a ~5B video-generation expert with a compact action expert in one network. At inference, it skips the dreaming step and directly denoises action chunks. Checkpoint: lerobot/fastwam_base.

LingBot-VA

Autoregressive video-action model that predicts future video and actions together, chunk by chunk, feeding real observations back in. Runs on a single 24-32 GB GPU. Supports video visualization with --policy.save_predicted_video=true.

The Complete Automated RL Pipeline

Putting it all together, here's the closed-loop RL workflow enabled by LeRobot v0.6:

1. Collect demonstrations (lerobot-record)
         ↓
2. Score dataset with Robometer → filter low-quality episodes
         ↓
3. Train policy (lerobot-train, FSDP if needed, or HF Jobs)
         ↓
4. Evaluate on simulation (lerobot-eval: LIBERO-plus / RoboTwin / RoboCasa365)
         ↓
5. Deploy on real hardware (lerobot-rollout, strategy=episodic)
         ↓
6. DAgger: collect corrections when policy fails
         ↓
7. Fine-tune on corrections → back to step 3

LeRobot v0.6 also ships LeLab — a web UI to visualize datasets, track training metrics, and manage the pipeline without touching the CLI for each individual step.

Summary

LeRobot v0.6 marks a transition from "data collection toolkit" to "complete RL platform for manipulation robots." The three core contributions:

• Robometer: Plug-and-play reward model trained on 1M trajectories — works on any LeRobot dataset out of the box
• TOPReward: Zero-shot reward from VLM log-probabilities — no training, works on unseen tasks immediately
• lerobot-eval + DAgger: Standardized simulation benchmarks + closed-loop correction collection on real hardware

Combined, these tools let you automatically know where your policy is failing, collect exactly the data you need to fix it, and continuously improve — without manual intervention after every training run.

Resources:

• LeRobot v0.6.0 blog post
• ROBOMETER paper
• TOPReward paper
• Robometer checkpoint on Hub

Related Posts

• LeRobot Ecosystem Guide: The Full Stack from Data to Deployment
• ProcVLM: Dense Reward VLA-RL for Automated Manipulation
• Multitask DiT Policy in LeRobot v0.5