You can start LeRobot without buying a robot. Create a separate Python environment, check the installed version, and inspect a public demonstration dataset first. Connect hardware when your first goal is to teleoperate an arm or collect data from your own setup. LeRobot provides the software for those stages; a downloaded policy still needs observations and actions that match the robot you intend to control.
This guide uses LeRobot 0.6.1, marked as the latest release on the official release page when checked on October 14, 2026. The examples below are preparation steps, not a report of an installation, training run or robot test performed for this article.
Choose a first session you can finish
If you are still deciding whether robot learning suits your project, start with data. You can learn what a camera observation, robot state and demonstrated action look like before dealing with motors or training costs.
| Your first goal | What you need | A useful first result |
|---|---|---|
| Understand demonstration data | A computer, internet access and Python; no physical robot | Identify the dataset’s image, state and action fields |
| Try a policy in simulation | The matching environment and policy dependencies; compute suited to that policy | Evaluate a compatible checkpoint in that environment |
| Teach your own arm a task | A supported robot, teleoperation device, cameras and a working recording setup | Save and inspect a short demonstration from your robot |
Simulation is a separate route from physical hardware. A policy that works in a PushT environment does not become an arm policy by changing the robot name. Keep the environment, dataset and checkpoint together for your first experiment.
Make the installation identify itself
Use Python 3.12 for this starting environment. The 0.6.1 package configuration requires Python 3.12 or newer. Follow the versioned installation guide for your operating system and PyTorch build, especially if you need CUDA acceleration or video decoding.
With conda already installed, the following commands create an isolated environment and request the fixed LeRobot release:
conda create -n lerobot-start python=3.12 -y
conda activate lerobot-start
python -m pip install "lerobot==0.6.1"
python -c "from importlib.metadata import version; import torch; print('LeRobot:', version('lerobot')); print('PyTorch:', torch.__version__); print('CUDA available:', torch.cuda.is_available())"
lerobot-info
Look for LeRobot: 0.6.1, then save the PyTorch version and system information with your notes. The official lerobot-info script reports environment information. It does not connect to an arm. A false CUDA result can be acceptable for the metadata exercise below; it needs investigation before a CUDA training or inference run.
If pip rejects the Python version, activate the new environment and check python --version before trying again. If the installed LeRobot version differs, resolve the environment mismatch before copying commands from another tutorial.
The base installation deliberately omits heavier workflow dependencies. Add the relevant extra when you need it: dataset for dataset loading, training for training, or core_scripts for recording and related robot tools. The installation guide also explains the video decoder and FFmpeg setup. A successful version check alone does not establish that videos can decode or that a robot can communicate.
Read one dataset before choosing a model
Use LeRobot’s public PushT dataset for a small, hardware-free inspection. Save the following as inspect_pusht.py and run python inspect_pusht.py in the environment above. It downloads only the schema JSON at a fixed dataset revision, rather than the videos or model weights.
import json
from pathlib import Path
from huggingface_hub import hf_hub_download
schema_path = hf_hub_download(
repo_id="lerobot/pusht",
repo_type="dataset",
filename="meta/info.json",
revision="7628202a2180972f291ba1bc6723834921e72c19",
)
info = json.loads(Path(schema_path).read_text(encoding="utf-8"))
print("Dataset format:", info["codebase_version"])
print("State shape:", info["features"]["observation.state"]["shape"])
print("Action shape:", info["features"]["action"]["shape"])
print("Image keys:", [key for key in info["features"] if "image" in key])
The checked schema declares dataset format v3.0, two-element state and action fields, and observation.image. The dataset format number and the LeRobot package version describe different things. Two action values also give you an immediate reason not to treat this dataset as demonstrations for a six-joint arm.
Next, add lerobot[dataset]==0.6.1 and follow the official dataset-loading example to inspect actual samples. Check an image beside its state, action and timestamp. The schema tells you the shape; the dataset documentation must explain the action’s meaning. Our LeRobot Dataset v3 guide explains how the tabular data, videos and episode metadata fit together when you need to inspect the files more closely.
With an SO-101, calibration comes before demonstrations
If you have not bought the arms yet, our SO-101 kit guide covers the parts list, motor voltage choice and kit sellers.
For a physical first project, the official SO-101 guide provides an assembly and calibration route. Its bill of materials distinguishes the follower arm that performs the task from the leader arm you move by hand. Check the exact kit’s motors, controller boards, power supplies, cables, mechanical parts and camera mounts before ordering. An arm by itself is not the complete teleoperation setup.
For that SO-101 route, install the robot tools and Feetech support in the same environment:
python -m pip install "lerobot[core_scripts,feetech]==0.6.1"
Then work through the real-robot imitation-learning tutorial in this order:
- Assemble the hardware, identify each arm’s serial port, configure the motors and calibrate the leader and follower using the SO-101 instructions. Keep each device’s ID consistent so later commands use the intended calibration.
- Teleoperate in a clear workspace before recording. Confirm that the follower responds as expected and that you can stop the session. This is the point to resolve a reversed joint, incorrect port or mechanical problem.
- Add the camera feeds. Confirm that the object and gripper remain visible during the task, and give the cameras stable names that you will reuse for training and evaluation.
- Record a short task, such as moving one cube into a tray. Inspect the saved observations and actions before collecting many more episodes. Change starting positions deliberately as you expand the data.
The tutorial’s recording example uploads to the Hugging Face Hub by default. For an initial local recording, set --dataset.push_to_hub=False; decide separately what data you want to share. Replace the tutorial’s ports, device IDs and camera configuration with your own values.
Train after the data matches the intended rollout
A collection test answers whether your recording path works. Training requires demonstrations with consistent camera names, action meaning and task labels, plus enough variation for the task you want the policy to handle. There is no episode count that guarantees success for every arm and scene.
Choose a policy after that inspection, then install its dependencies and the training extra. The official compute guide separates policy classes and gives configuration-specific memory estimates. Use those estimates to plan a small run, then measure memory and throughput for your actual images and batch size. The CPU metadata exercise does not establish a training budget.
If you choose the language-conditioned SmolVLA route, continue with our SmolVLA fine-tuning guide. Evaluate the resulting checkpoint on defined starts and held-out task variations, recording completion and operator interventions. If you later collect data while a policy is running, our LeRobot HIL handoff guide explains how to interpret assistance and pauses.
For your first session, stop at a result you can explain: the installed version and one dataset’s observation/action structure, or a calibrated teleoperation setup with one inspected recording. That gives the next training step a concrete input.