LeRobot 0.7.0: Hugging Face's Robot Stack Now Talks Back

Most robot software treats a running robot like a sealed box. You start a task, watch it work, and if it goes wrong you stop everything, change the instruction, and start again. LeRobot 0.7.0, released November 5, 2026, breaks that seal. Hugging Face's open robotics framework now lets you talk to a policy while the robot moves: change its subtask mid-motion, ask it what it sees, or hand it a goal and let it pick its own steps until you take back control.

This is a framework release, not a single model launch, and the scope shows it. Four world action models and four new vision-language-action models arrive at once, training can now stream from nearly 300TB of open robot data without downloading it, and big policies can run on a GPU server while a laptop or single-board computer sits beside the robot. The software costs nothing under Apache 2.0. The catch is in the fine print of one new model, and in the breaking changes that come with the upgrade. Both are worth knowing before you install it.

What LeRobot 0.7.0 actually changes

LeRobot is Hugging Face's open-source library for real-world robot learning: datasets, training recipes, policies, and hardware drivers in one place. The repository has grown to 28,731 stars and 6,033 forks on GitHub since its creation in January 2024, and the project says its Discord server and X account have each passed 20,000 members. Version 0.7.0 is the biggest release since 0.6.0 in July, and it works on both ends of the robot-learning pipeline at once: the terabytes of demonstrations that train a policy, and the live session where that policy drives hardware.

Three changes carry the release: language enters the control loop, training scales up to multi-billion-parameter world action models, and inference splits apart from the robot itself, so the computer next to the arm no longer needs enough memory to load the model. Around those, the release adds new hardware support, a unified simulation core, and evaluation results that now come with confidence intervals.

One clarification up front: this article covers the LeRobot framework release. LingBot-VLA 2.0, which we reviewed separately, is one of the four new models that ship inside this release. If you want the deep dive on that model alone, that review is the place to go.

Talk to your robot while it works

The headline feature is 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 keeps moving:

/start
/subtask pick up the red cube
/vqa how many cubes are left on the table?
/autosteer clear the table
/stop

The /subtask command changes the instruction while the robot runs. /vqa asks the policy what the robot currently sees. /autosteer gives the policy a goal and lets it select its own subtasks until you take back control. You can record episodes while all of this happens, so a steered session doubles as new training data.

Two commands need a policy that generates text. /vqa and /autosteer work with text-generating policies such as FineART-VLA and Wall-OSS-0.5, or with an external planner. If your policy only outputs actions, you can point LeRobot at any vision-language model behind an OpenAI-compatible API, served locally with transformers serve, the Llama app, or vLLM, or hosted through Hugging Face Inference Providers. The planner answers questions and drives autosteer while the robot keeps acting, turning a vague request like "tidy up" into precise instructions the action model understands.

FineART, built by Scale AI and Hugging Face, shows what this looks like at scale: more than 40,000 bimanual episodes, 1,718 hours of demonstrations, and 533,000 subtask annotations, totalling 1.9TB in LeRobot format. FineART-VLA, trained on that data, extends the pi0.5 policy with a language head. A high-level system interprets the goal and predicts its next subtask in words, then a flow-matching action expert carries it out. You can fine-tune it on your own annotated data.

Language supervision is now part of training itself. YAML recipes turn labels from lerobot-annotate, covering subtasks, plans, memory, visual questions, and speech, into chat-style training targets, and the recipe ships inside the policy configuration so training and inference render language the same way.

Four world action models and four new VLAs

World action models imagine the future before acting: given camera views and a language instruction, they predict upcoming video frames and the next action chunk together. Version 0.6.0 brought the first three. Version 0.7.0 adds four more, from NVIDIA, Black Forest Labs, and RLinf.

Every benchmark figure in that table is the lab's own reported result, not an independent reproduction. Treat the LIBERO scores as a rough ranking of the models on one simulated benchmark, not as a guarantee of how any of them will behave on your hardware. The release notes are candid about the same point in their own way: evaluation in 0.7.0 now reports a 95% Wilson confidence interval at every level, so a run of ten lucky episodes no longer looks like a solved benchmark. The example in the release shows 9 out of 10 successes carrying an interval of 59.6% to 98.2%.

Cosmos 3 brings NVIDIA's world foundation models to robot learning, in two sizes you can fine-tune on any LeRobot dataset, in full with FSDP2 or with LoRA. FLUX 3 Action, from the team behind the FLUX image models, pairs a frozen video VAE and text encoder with a diffusion transformer that predicts video latents and action chunks together; only the actions come out at inference. It ships with three checkpoints, including one for the SO-101 arm and one for DROID. LaWAM learns dynamics in latent space on a Qwen3-VL backbone. Long-WAM is built for long context, with two modes: one imagines future latents and conditions actions on them without decoding a single RGB frame, the other co-denoises video and actions jointly.

The vision-language-action lineup grows by four as well. G0.5 from OpenGalaxea is a Qwen3.5-2B model that writes its chain of thought, the current subtask and optionally bounding boxes, and its actions in one stream. LingBot-VLA 2.0 pairs a Qwen3-VL-4B backbone with a sparse mixture-of-experts action expert, 32 experts with top-4 routing, acting in a 55-dimensional action space shared across embodiments. Upstream, it reports 93.5% success on RoboTwin 2.0 clean, against 82.7% for pi0.5, and in LeRobot, CUDA graphs and torch.compile cut an action chunk from about 756 ms to about 120 ms on an RTX PRO 6000 in bf16. DM0.5 from Dexmal combines a Gemma3-4B vision-language model with a 680M-parameter flow-matching action expert, scoring 197 out of 200 on a LIBERO reproduction check. Wall-OSS-0.5 from X Square Robot is a 4B model whose vision-language expert also generates text, so once fine-tuned it can answer visual questions and plan its own subtasks in an interactive rollout.

Read the licenses before you pick one. G0.5's code and weights are released under the non-commercial G0.5 Community License, not Apache 2.0. The framework itself is Apache 2.0, but that one model is not free for commercial use. It is the only license catch in the release, and the blog post flags it in the G0.5 section rather than burying it.

Train on 300TB without downloading it

The Hugging Face Hub now holds almost 300TB of open Physical AI data in LeRobot format, and some of the largest additions arrived in the past few months, spanning real robots, handheld grippers, human video, and simulation. Many go beyond RGB with tactile sensing, depth, joint torques, or dense language annotations.

The practical change is that the largest datasets no longer need to fit on your training node's disk. With --dataset.streaming=true, a new reader fetches only the video byte ranges training needs, from the Hub, a Storage Bucket, or LanceDB. Every frame is visited exactly once per epoch, runs resume deterministically, and the reader supports DataLoader workers, with 2.1 to 2.5 times more samples per second when using four workers, according to Hugging Face's own measurements.

LanceDB support, built with the LanceDB team, reads datasets stored as Lance tables with the original MP4s kept as blobs, so nothing is re-encoded. Frames are read in place with a true global shuffle at local-disk speed. Convert an existing dataset with lerobot-lance-convert and browse it in lerobot-dataset-viz. Image augmentation can now move to the GPU as well: Hugging Face reports ACT training 2.8 times faster on an H100 and 3.3 times faster on an A100, with eight new robotics-oriented augmentations from motion blur and random shadows to JPEG compression and color-temperature jitter.

Training itself was rebuilt for world action models, which often run 5 to 20 billion parameters with many video tokens per sample. The old FSDP1 path is gone, replaced by FSDP2 and HSDP sharding, gradient accumulation, and Torch Distributed Checkpoints that resume on multiple GPUs. On an 8xH200 node with a 6B FastWAM model, Hugging Face reports distributed checkpoints saving 3 times faster, with resume memory peaks falling from 143GB to 42GB per GPU. FP16 mixed precision with loss scaling now works on every topology, EMA of policy weights is built in, and experiment tracking moves to Trackio, Hugging Face's open-source tracker, which replaces Weights and Biases entirely and works locally without signing up.

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 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 follows buffered actions while the server computes the next chunk, which effectively hides inference latency, and you can adjust replanning frequencies without retraining the policy. Because the robot keeps moving during computation, the client aligns incoming chunks with the remaining trajectory, discards expired steps, and blends overlapping targets for smooth transitions. Compatible checkpoints can also use real-time chunking to condition new predictions directly on the remaining actions. Interactive sessions and episode recording work remotely too, using the same rollout workflow as local inference. Transport uses Zenoh, with TLS and access-control configurations provided.

Simulation gets the same unification. Every benchmark used to install its own simulator into the same environment as LeRobot, with conflicting dependency versions. Version 0.7.0 runs every simulator through one vector-env core, used both as an environment that batches episodes for lerobot-eval and as a simulated robot you can run rollouts, record, and teleoperate in exactly as on hardware. You no longer need a physical robot to test and improve your workflow. The first benchmark built on the new core is NVIDIA's RoboLab: 120 tabletop tasks for the DROID Franka setup on Isaac Lab.

More arms, more humanoids

Hardware support widens in three directions. The I2RT YAM arm joins the lineup, controllable singly or as a bimanual pair, with a gravity feed-forward term computed from the arm's inertial model compensating for the arm's own weight. The reBot B601 from Seeed Studio, a 6-DoF arm paired with the reBot Arm 102 leader, now runs on RobStride motors as well as Damiao, selected with a single motor_family setting, and bimanual setups can even mix the two.

For humanoids, LeRobot now runs the decoder half of NVIDIA's SONIC whole-body controller 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. The 23-DoF G1 variant joins too, sharing the G1-29 driver with a single embodiment setting, with GR00T and Holosoma locomotion supported on it.

The codebase is now fully typed under one mypy ruleset, ships with PyTorch 2.15 and a single CUDA 13 build from PyPI, and returns typed predictions alongside actions so you can watch what a policy predicts live in the visualizers. Documentation is now machine-translated, including Chinese, Korean, and Spanish. A new @huggingface/lerobot npm package lets you read LeRobot datasets directly from the Hub in a browser or in Node, using ranged requests so you never download the whole dataset.

What it costs: free software, a real hardware bill

LeRobot itself costs nothing. The framework is Apache 2.0, the Hub datasets are open, and Trackio replaces a paid experiment tracker with a free one. The bill starts with hardware, and the honest number depends on which end of the spectrum you enter at.

The usual starting point is the SO-101, Hugging Face's reference arm, a 6-DoF leader-follower pair you 3D print and assemble yourself. The project's own bill of materials lists $121.94 for one follower arm and $229.88 for the leader-plus-follower pair, before a camera and before a 3D printer if you do not own one. In today's money that is roughly £91 / C$172 for a single arm and £172 / C$325 for the pair, at November 7, 2026 market rates of 1 USD = 0.7471 GBP and 1.4117 CAD. Those are parts totals from the repository, not shop prices, and they change by country and date, so open the links before you budget.

Buying a kit trades money for time. Seeed Studio lists its SO-101 servo motor kit at $189, its SO-ARM101 Pro kit at $295, and an unassembled bundle at $299, roughly £141 to £223 or C$267 to C$422. Assembled pairs from other vendors run higher still. None of those prices include a camera, a computer, or the GPU time to train anything larger than a small policy, and that last item is where the real money goes. Training a multi-billion-parameter world action model is an 8xH200-node job in Hugging Face's own example, not a weekend laptop project. Hugging Face publishes no per-hour compute price, because there is none to publish: you bring your own GPUs or rent them elsewhere. The framework is free. The compute is the product.

That split is the right way to judge the release. If you already own a robot and a GPU, 0.7.0 costs you an afternoon of upgrading. If you own neither, the entry ticket is a few hundred dollars of arm and a rented GPU, and the framework will not be the expensive part of that bill.

Breaking changes before you upgrade

Version 0.7.0 removes things, and the removals will break existing setups. Remote inference replaces the lerobot.async_inference module and the lerobot[async] extra, both removed in this release. Install the remote extra instead. The old FSDP1 training path is gone, replaced by the FSDP2 and HSDP framework. Trackio replaces Weights and Biases, and the installation docs include a migration table. The blog post does not publish a full breaking-change list, so read the release notes on GitHub before upgrading a working robot, and pin 0.6.1 if your setup is in the middle of a project.

Two more cautions come from the release itself. The benchmark scores above are the labs' own numbers on simulated tasks, and the new confidence intervals exist precisely because small evaluations mislead. And the G0.5 license is non-commercial, which matters the moment a hobby project turns into a product. Both are easy to miss if you skim the announcement for the headline features.

Common mistakes

Upgrading mid-project without reading the migration notes. The async inference module is removed, not deprecated. A robot that worked on 0.6.1 will not start on 0.7.0 until you switch to the remote extra.

Quoting a LIBERO score as real-world performance. Simulation success rates are a ranking signal, not a deployment guarantee. The new Wilson intervals are there to stop ten-episode evaluations from looking conclusive.

Downloading datasets you could stream. The largest datasets are hundreds of gigabytes to terabytes. Use the streaming reader or LanceDB before you fill a disk.

Building a product on G0.5 without checking its license. The framework is Apache 2.0, but G0.5 is not. Commercial use needs a different model or a license conversation with OpenGalaxea.

Budgeting only for the arm. A $230 parts list is not a $230 project. Cameras, a host computer, and GPU time for training are separate line items, and training a world action model is the expensive part.

Frequently asked questions

Is LeRobot 0.7.0 free?

Yes. LeRobot is open source under the Apache 2.0 license, and the Hub datasets are open. You pay for hardware and compute, not for the software. One exception: the G0.5 model ships under a non-commercial community license, so it is free for research and hobby use but not for commercial products.

What hardware do I need to try LeRobot?

A typical starting point is an SO-101 arm pair, about $230 in parts from the project's bill of materials, plus a camera and a computer. You can also run everything in simulation with no physical robot at all, using the new vector-env core. Training large policies needs a GPU, and the biggest world action models need multi-GPU setups.

Can I talk to my robot while it runs?

Yes, with interactive rollouts. Run lerobot-rollout with --interactive=true, then use /subtask to change instructions, /vqa to ask what the robot sees, and /autosteer to hand it a goal. Visual questions and autosteer need a text-generating policy such as FineART-VLA or Wall-OSS-0.5, or an external vision-language model as a planner.

What is a world action model?

A model that predicts future video frames and the next action chunk together, given camera views and a language instruction. It imagines what will happen before it acts. Version 0.7.0 adds Cosmos 3, FLUX 3 Action, LaWAM, and Long-WAM to the three world action models that arrived in 0.6.0.

Does 0.7.0 break my existing LeRobot setup?

Possibly. The lerobot.async_inference module and the lerobot[async] extra are removed, the FSDP1 training path is gone, and Weights and Biases is replaced by Trackio. Read the release notes and migrate before upgrading a working robot.

How is LeRobot 0.7.0 different from LingBot-VLA 2.0?

LingBot-VLA 2.0 is one model. LeRobot is the framework that trains, runs, and evaluates robot policies, and 0.7.0 is a release of that framework. LingBot-VLA 2.0 ships inside this release alongside three other new vision-language-action models and four world action models.

The bottom line

LeRobot 0.7.0 is the release where open-source robotics starts to feel like a conversation instead of a batch job. Talking to a running robot, streaming terabytes of training data without downloading them, and running big policies on a remote GPU are all real, usable changes, not roadmap promises. The price is honest too: free software, a few hundred dollars of arm to start, and compute bills that scale with ambition. Just read the migration notes before you upgrade, and read the G0.5 license before you build a business on it.

Sources

• Hugging Face, "LeRobot v0.7.0: From Terabytes to Prompting Robots," November 5, 2026 — huggingface.co/blog/lerobot/lerobot-release-v070
• Hugging Face, LeRobot repository, GitHub — github.com/huggingface/lerobot (28,731 stars, 6,033 forks, Apache 2.0; release v0.7.0 published November 5, 2026)
• Hugging Face, LeRobot documentation — huggingface.co/docs/lerobot/en/index
• TheRobotStudio, SO-ARM100 bill of materials, GitHub — github.com/TheRobotStudio/SO-ARM100 ($121.94 follower, $229.88 pair)
• Exchange rates: 1 USD = 0.7471 GBP, 1.4117 CAD, November 7, 2026 market rates, verified at publication