LeRobot v0.7.0: From Terabytes to Prompting Robots

Every robot policy starts as terabytes of demonstrations and ends as a robot following instructions. LeRobot v0.7.0 works on both ends of that road. The Hub now holds almost 300 TB of open Physical AI data in LeRobot format, with some of the largest datasets released in just the past few months. You can now train on these datasets directly from the Hub, a Storage Bucket or LanceDB, without downloading the datasets first. The training stack has been rebuilt for multi-billion-parameter world action models.

Once the robot is running, you can interact with its policy in real time. Without stopping the robot, you can alter its course, ask the model what it currently sees, or assign it a new goal to figure out autonomously. In between, v0.7.0 brings world action models from NVIDIA, Black Forest Labs and RLinf, new VLAs, and remote inference that allows running big models on a GPU server while keeping the robot’s compute requirements low.

TL;DR

LeRobot v0.7.0 puts language in the loop: interactive rollouts let you switch subtasks, ask questions and autosteer a running robot, using text-generating policies (FineART-VLA, Wall-OSS-0.5) or an external VLM planner. It adds four world action models (Cosmos 3, Long-WAM, FLUX 3 Action, LaWAM), four new VLAs (G0.5, LingBot-VLA 2.0, DM0.5, Wall-OSS-0.5), and a training stack built for them: FSDP2, HSDP, distributed checkpoints, support for FP16, EMA and Trackio. Policies can now run on a remote GPU with lerobot-policy-server, the Unitree G1 gets NVIDIA's SONIC whole-body controller, datasets stream from the Hub, Storage Buckets or LanceDB without downloading, and every simulator runs on one core, locally or served.

Table of contents

• LeRobot v0.7.0: From Terabytes to Prompting Robots TL;DR Table of contents Language in the loop: talk to your robot Interactive rollouts External VLM planner FineART: subtasks at scale Training with language annotations Datasets: train on terabytes without downloading them Disk-less streaming LanceDB: object storage at local-disk speed Augment on the GPU Training at scale: built for world action models FSDP2, HSDP and distributed checkpoints Recipes from large-model training Trackio: experiment tracking, the Hugging Face way World action models: imagine, then act Cosmos 3 FLUX 3 Action LaWAM Long-WAM VLAs: the model zoo keeps growing G0.5 LingBot-VLA 2.0 DM0.5 Wall-OSS-0.5 Remote inference: big models, light robots Simulation and evaluation Hardware: more arms, more humanoids YAM reBot B601 Unitree G1: SONIC and the 23-DoF variant Codebase: typed, shared, easier to extend Community & ecosystem 300 TB of open Physical AI data Final thoughts
• TL;DR
• Table of contents
• Language in the loop: talk to your robot Interactive rollouts External VLM planner FineART: subtasks at scale Training with language annotations
• Interactive rollouts
• External VLM planner
• FineART: subtasks at scale
• Training with language annotations
• Datasets: train on terabytes without downloading them Disk-less streaming LanceDB: object storage at local-disk speed Augment on the GPU
• Disk-less streaming
• LanceDB: object storage at local-disk speed
• Augment on the GPU
• Training at scale: built for world action models FSDP2, HSDP and distributed checkpoints Recipes from large-model training Trackio: experiment tracking, the Hugging Face way
• FSDP2, HSDP and distributed checkpoints
• Recipes from large-model training
• Trackio: experiment tracking, the Hugging Face way
• World action models: imagine, then act Cosmos 3 FLUX 3 Action LaWAM Long-WAM
• Cosmos 3
• FLUX 3 Action
• LaWAM
• Long-WAM
• VLAs: the model zoo keeps growing G0.5 LingBot-VLA 2.0 DM0.5 Wall-OSS-0.5
• G0.5
• LingBot-VLA 2.0
• DM0.5
• Wall-OSS-0.5
• Remote inference: big models, light robots
• Simulation and evaluation
• Hardware: more arms, more humanoids YAM reBot B601 Unitree G1: SONIC and the 23-DoF variant
• YAM
• reBot B601
• Unitree G1: SONIC and the 23-DoF variant
• Codebase: typed, shared, easier to extend
• Community & ecosystem 300 TB of open Physical AI data
• 300 TB of open Physical AI data
• Final thoughts

Language in the loop: talk to your robot

v0.6.0 taught LeRobot datasets to store language annotations. v0.7.0 puts them to work end to end: policies learn to read and write language, and you can talk to the policies while they work.

Interactive rollouts

Add --interactive=true to lerobot-rollout, and the robot connection, policy weights and processors stay loaded between instructions. You drive the session from your terminal while the robot moves:

/subtask changes the instruction while the robot runs, /vqa asks the policy what the robot sees, /autosteer gives the policy a goal so it selects its own subtasks until you take back control. You can record episodes while all of this happens. /vqa and /autosteer need a policy that generates text, such as FineART-VLA or Wall-OSS-0.5, or an external planner. See the interactive sessions docs.

External VLM planner

No text-generating policy? Point LeRobot at any VLM behind an OpenAI-compatible API, served locally with transformers serve, Llama or vLLM, or hosted through Inference Providers. The planner answers /vqa and drives /autosteer while the robot keeps acting, turning vague requests like "tidy up" into precise instructions the VLA understands, in the spirit of steerable policies. See the external planner docs.

FineART: subtasks at scale

FineART, from Scale AI and Hugging Face, shows what this looks like at scale: 40k+ bimanual episodes (1,718 hours) with 533k+ subtask annotations, 1.9 TB in LeRobot format. FineART-VLA, trained on it, extends π0.5 with a language head: a high level system interprets the goal and predicts its next subtask in words (System 2), then a flow-matching action expert carries it out (System 1). Fine-tune lerobot/FineART-VLA-subtask-midtrained on your own annotated data; the documentation and the paper have the details.

Training with language annotations

Any policy can learn this way. YAML recipes turn lerobot-annotate labels (subtasks, plans, memory, VQA, speech) into chat-style training targets. The recipe is now included in the policy configuration, so training and inference render language the same way. Four recipes come built in, EO-1 and Wall-X gained text supervision, and lerobot-annotate now runs on HF Jobs with a single flag. See the language and recipes and annotation pipeline docs.

Datasets: train on terabytes without downloading them

The largest robot datasets no longer fit on a training node's disk. With v0.7.0, you can train directly from the Hub, via a Storage Bucket or Datasets.

Disk-less streaming

For standard LeRobot datasets, --dataset.streaming=true now uses a new reader that fetches only the video byte ranges the training needs, from the Hub or a Storage Bucket. Every frame is visited exactly once per epoch, and runs resume deterministically. The reader supports DataLoader workers, with 2.1–2.5x more samples per second when using four workers. See training with dataset streaming.

LanceDB: object storage at local-disk speed

Built with the LanceDB team, LeRobot now reads datasets stored as Lance tables, with the original MP4s kept as blobs so nothing is re-encoded. Frames are read in place, so you can start training immediately, with a true global shuffle and at local-disk speed. You use the same LeRobotDataset:

Convert an existing dataset with lerobot-lance-convert and browse it in lerobot-dataset-viz. See the LanceDB section of the dataset docs and LanceDB's own guide.

Augment on the GPU

You can now train faster by moving image augmentation to the GPU. Set --dataset.image_transforms.backend=gpu: ACT trains 2.8x faster on an H100 and 3.3x faster on an A100. Eight new robotics-oriented augmentations come with it, from motion blur and random shadows to JPEG compression and color-temperature jitter. See running transforms on the GPU.

Training at scale: built for world action models

World action models often have a large number of parameters (5-20B), with many video tokens per sample. With standard data parallelism, these models exceed the available memory. So we rebuilt the training stack for them.

FSDP2, HSDP and distributed checkpoints

Forget about the old FSDP1 path, it is now replaced by a parallel-training framework with all the bells and whistles: FSDP2 and HSDP sharding, gradient accumulation, and Torch Distributed Checkpoints (DCP) that resume on multiple GPUs. On an 8×H200 node with a 6B FastWAM, DCP saves checkpoints 3x faster, and resuming peaks go from 143 GB to 42 GB per GPU. See the multi-GPU training docs.

Recipes from large-model training

• Precision, simplified. FP16 mixed precision with loss scaling now works on every topology, TF32 is configurable, and every policy uses the same dtype setting.
• EMA of the policy weights, with warmup, constant and power decays, sharded training included. EMA weights are saved next to the live ones.
• The warmup-stable-decay schedule and opt-in fused Adam/AdamW.

See the hardware accelerators docs.

Trackio: experiment tracking, the Hugging Face way

LeRobot now supports Trackio, Hugging Face's open-source experiment tracker. You can monitor local runs without signing up or logging in. You only need to log in to sync to a Hugging Face Space. It also records each run's launch command and console output, including tracebacks. Trackio replaces Weights & Biases entirely; the installation docs include a migration table.

World action models: imagine, then act

v0.6.0 brought the first three world action models to LeRobot. The field has moved fast since: v0.7.0 adds four more, from NVIDIA, Black Forest Labs and RLinf.

Cosmos 3

Cosmos 3 brings world foundation models to robot learning. From camera views and a language instruction, it predicts future video frames and the next action chunk together. It comes in two sizes, Cosmos 3 Nano (16.5B parameters) and Cosmos 3 Edge (4.6B), which reach 97.90% and 97.95% average success on LIBERO. You can fine-tune either one on any LeRobot dataset, in full with FSDP2 or with LoRA, starting from the Cosmos 3 collection: lerobot/Cosmos3-Nano or lerobot/Cosmos3-Edge. Read the Cosmos 3 documentation and the tech report.

FLUX 3 Action

Black Forest Labs, the team behind FLUX, brings its generative models to robotics. In FLUX 3 Action, a frozen video VAE and text encoder feed a diffusion transformer that predicts video latents and action chunks together; at inference, only the actions come out. The FLUX 3 Action collection brings together three checkpoints (base, SO-101 and DROID), and LeRobot supports inference and LoRA fine-tuning for new tasks. To train a new embodiment, use Black Forest Labs' flux-action repository. Details in the FLUX 3 Action documentation.

LaWAM

LaWAM, from the RLinf team, learns dynamics in latent space: a Qwen3-VL backbone, a latent action and world model, and a flow-matching action head. Original LaWAM checkpoints load directly, and the LIBERO fine-tune scores 98.5% (1,970 of 2,000 episodes). See the LaWAM documentation, the project page and the paper.

Long-WAM

Long-WAM, from NVIDIA's LongLive team, is built for long context. Autoregressive video pretraining teaches the model how the past affects the future before executing an action. It runs in two modes: Inverse-Dynamics Model imagines future latents and conditions the actions on them, without decoding a single RGB frame, while video and actions are co-denoised jointly. Both land around 99% average success on LIBERO (99.00% for IDM, 98.45% for COD, over 2,000 episodes each). Check out the documentation, the project page and the paper.

VLAs: the model zoo keeps growing

G0.5

G0.5 from OpenGalaxea is a Qwen3.5-2B VLA that thinks out loud: it writes its chain of thought (the current subtask, optionally bounding boxes) and its actions in one stream. Run it as a fast System 1, or let it reason as System 2. It plugs straight into interactive rollouts, so /subtask and /autosteer just work. The G0.5 collection brings together four converted checkpoints covering the base model, LIBERO, RoboTwin 2.0 and SO-101, and fine-tuning works on robots G0.5 was never trained on. See the G0.5 documentation.

G0.5's code and weights are released under the non-commercial G0.5 Community License, not Apache-2.0.

G0.5's code and weights are released under the non-commercial G0.5 Community License, not Apache-2.0.

LingBot-VLA 2.0

LingBot-VLA 2.0 from Robbyant pairs a Qwen3-VL-4B backbone with a sparse mixture-of-experts action expert (32 experts, top-4 routing) and acts in a 55-dimensional action space shared across embodiments. Upstream, it reports 93.5% success on RoboTwin 2.0 (clean), against 82.7% for π0.5. In LeRobot, CUDA graphs and torch.compile bring an action chunk from about 756 ms down to about 120 ms (bf16, RTX PRO 6000). Start from lerobot/lingbot_vla_v2_base, browse the base and RoboTwin checkpoints in the LingBot-VLA 2.0 collection, and read the documentation and the paper.

DM0.5

DM0.5 from Dexmal combines a Gemma3-4B VLM with a 680M-parameter flow-matching action expert. It is ported from OpenDM onto standard LeRobot datasets, processors and training, with lerobot/dm05_base ready for fine-tuning and lerobot/dm05_libero scoring 197/200 on a LIBERO reproduction check. See the DM0.5 documentation.

Wall-OSS-0.5

Wall-OSS-0.5 from X Square Robot is a 4B VLA (Qwen2.5-VL plus a flow-matching action expert), now supported officially in transformers. Its vision-language expert also generates text, so once fine-tuned on your robot, it can answer /vqa questions and plan its own subtasks in an interactive rollout. Start from the lerobot/wall-oss-0.5 base checkpoint; see the Wall-OSS-0.5 documentation.

Remote inference: big models, light robots

The computer connected to your robot no longer needs enough memory to load the policy. With lerobot-policy-server, you can keep a laptop or single-board computer beside the robot and run the model on a GPU workstation across the lab. Cameras, motors, teleoperation and recording stay local; observations and instructions go to the server, and chunks of upcoming actions come back.

The robot can follow buffered actions while the server computes the next chunk. This overlap effectively hides inference latency and lets you adjust replanning frequencies without retraining the policy. Because the robot continues to move during this computation, the client aligns incoming chunks with the remaining trajectory. It discards expired steps and blends overlapping targets for smooth transitions. Compatible checkpoints can also use real-time chunking (RTC) to condition these new predictions directly on the remaining actions.

You can also run interactive sessions and record episodes remotely, using the same rollout workflow as for local inference. Transport uses Zenoh, with TLS and access-control configurations provided. The remote inference docs cover setup, supported policies and robots, and tuning for your network and inference latency.

Remote inference replaces the lerobot.async_inference module and the lerobot[async] extra, which are removed in v0.7.0. Install the remote extra instead.

Remote inference replaces the lerobot.async_inference module and the lerobot[async] extra, which are removed in v0.7.0. Install the remote extra instead.

Simulation and evaluation

Every benchmark used to install its own simulator into the same environment as LeRobot, with conflicting dependency versions (robosuite, MuJoCo, NumPy 1.x, ...). v0.7.0 runs every simulator through one vector-env core, which is used in two ways. As an env, it batches episodes for lerobot-eval and training-time evaluation. As a sim robot, you can run rollouts, record and teleoperate in simulation exactly as you do on hardware. You no longer need a physical robot to test and improve your workflow. Either way, the simulator runs in-process or in its own Docker image behind the new lerobot-env-server, and pointing at an endpoint is the only switch.

The first benchmark built on the new core is NVIDIA's RoboLab: 120 tabletop tasks for the DROID Franka setup on Isaac Lab. See the simulation docs.

Results also come with error bars now. lerobot-eval reports success counts and a 95% Wilson confidence interval at every level (task, suite and overall), so ten lucky episodes no longer look like a solved benchmark:

Hardware: more arms, more humanoids

YAM

You can now control one I2RT YAM arm or combine two arms for a bimanual setup in LeRobot. A gravity feed-forward term, computed from the arm's inertial model, compensates for the arm's own weight. See the YAM documentation.

reBot B601

The reBot B601 from Seeed Studio is a 6-DoF arm that pairs with the reBot Arm 102 leader. It now runs on RobStride motors as well as Damiao, selected with a single motor_family setting, and bimanual setups can even mix the two.

Unitree G1: SONIC and the 23-DoF variant

SONIC is NVIDIA's whole-body controller for humanoids, and LeRobot now runs the decoder half of its deploy stack on the Unitree G1. Instead of 29 joint targets, a policy outputs a 64-dimensional motion token each tick, and an onboard decoder turns it into 50 Hz joint targets for the whole body. It also works with remote inference: the policy runs on a GPU machine while the G1's Jetson runs the decoder. Try it in simulation policy, then follow the hardware-validated recipe in the Unitree G1 docs.

The 23-DoF G1 also joins the lineup, sharing the G1-29 driver with a single embodiment setting. GR00T and Holosoma locomotion are supported on this variant.

Codebase: typed, shared, easier to extend

• PyTorch 2.15 available, with one CUDA 13 build from PyPI for both uv sync and pip install.
• Fully typed. One mypy ruleset now covers the whole codebase, and the typing pass fixed real bugs along the way.
• See what your policy predicts. Policies return a typed prediction alongside their actions. You can view these predictions live in the available visualizers.
• Rollouts that report and extend. lerobot-rollout logs control rate, inference latency and memory as it runs, and you can bring your own rollout strategy, in-tree or as a pip-installable package.
• Docs. Machine-translated docs (including Chinese, Korean and Spanish), an API reference, and new pages listing third-party hardware and integrations.

Community & ecosystem

• On 8 October we hosted the first-ever LeRobot LIVE on our Discord, where the community met the engineers behind LeRobot, heard about new features and asked their questions. Stay tuned for the next one happening in December!
• Both our Discord server and X account passed 20,000 members, and the GitHub repository is closing in on 30,000 stars.
• LeLab got several exciting upgrades.
• LeRobot datasets in JavaScript. With the new @huggingface/lerobot package, you can read LeRobot datasets directly from the Hub in your browser or in Node. It uses ranged requests, so you do not need to download the whole dataset.

300 TB of open Physical AI data

The Hugging Face Hub now hosts almost 300 TB of open Physical AI data in LeRobot format, and some of the biggest additions arrived in the past few months, from real robots, handheld grippers, human video, simulation and live deployments. Many go beyond RGB, with tactile sensing, depth, joint torques or dense language annotations. Here are some in order of release:

Final thoughts

Beyond these headline features, v0.7.0 includes hundreds of bug fixes, documentation improvements and quality-of-life upgrades across the codebase, from more accurate dataset statistics to a much faster CI.

We want to extend a huge thank you to everyone in the community. This release includes work from academia, industry and hobbyist teams who chose LeRobot as the home for their models, datasets, robots and benchmarks. Every PR and bug report pushes open-source robotics forward.

Stay tuned for more to come 🤗 Get started here! – The LeRobot team (and MicroDuck) ❤️