What you will build and what you need
LeRobot is Hugging Face's open-source robotics library. One set of commands moves a robot, records demonstrations, trains a policy and runs it. The SO-101 is its flagship arm: you move a leader arm by hand, a follower arm copies it, and the recorded motion and camera images teach a neural network to repeat the task by itself.
The work has seven stages: source the parts and install the software, give every motor an ID, assemble both arms, calibrate, teleoperate with cameras, record a dataset, then train and run a policy. The last build section adds the LeKiwi mobile base, followed by a troubleshooting checklist.
Swipe sideways to see the whole figure.
You need two arms (parts in the next section), a USB bus-servo control board and a power supply for each arm, a computer with Python 3.12 or newer, two USB cameras (the commands in this guide use two), a free Hugging Face account for datasets and checkpoints, and a GPU for training. A laptop-class GPU is enough for the ACT policy used here, and a rented GPU works too.
We compiled this guide from the official documentation and community build reports, and we did not bench-test every step on every hardware revision. Older tutorials that call control_robot.py do not apply to 0.7.0, which uses the lerobot-* commands.
Parts, printing and power
The SO-101 project publishes the bill of materials and the print files, and the Hugging Face SO-101 page links to both. A complete leader and follower pair needs 12 Feetech STS3215 servos, two control boards, two power supplies, two USB-C cables, table clamps. The assembly uses M2×6 and M3×6 screws; the project's bill of materials does not list them, so check what ships with your servos or kit. Printed parts and complete kits are also sold.
The follower uses six servos with a 1/345 gear ratio. The leader uses three different ratios, so it can hold its own weight and still move with little force.
Match the power supply to the servos. The 7.4 V STS3215 has a stall torque of 16.5 kg·cm at 6 V (slightly less on a 5 V supply) and is normally run from a 5 V supply. The follower can use 12 V servos (30 kg·cm) for more power, but then it needs a 12 V supply rated 5 A or more; the leader always uses 7.4 V servos. Never connect the 12 V supply to a board that has 7.4 V servos on it; mark each supply with its voltage and the arm it belongs to.
Swipe sideways to see the whole figure.
Print in PLA+ with a 0.4 mm nozzle at 0.2 mm layers (or a 0.6 mm nozzle at 0.4 mm layers) and 15% infill. Each arm's parts come as a single file oriented to need few supports; keep supports out of horizontal screw holes. Print the Gauge Zero and Gauge Tight test pieces first and check them against a servo; if Gauge Zero does not fit as shown in the project's video, adjust your printer settings and print it again before printing the arms.
Have Phillips #0 and #1 screwdrivers ready, and clamp each base to the table before you test. The parts we supply for this build are linked below.
Scroll sideways to compare all columns.
| Joint | Motor ID | Leader gear ratio | Follower gear ratio |
|---|---|---|---|
| Shoulder pan | 1 | 1/191 | 1/345 |
| Shoulder lift | 2 | 1/345 | 1/345 |
| Elbow flex | 3 | 1/191 | 1/345 |
| Wrist flex | 4 | 1/147 | 1/345 |
| Wrist roll | 5 | 1/147 | 1/345 |
| Gripper | 6 | 1/147 | 1/345 |
Install LeRobot and motor support
LeRobot 0.7.0 needs Python 3.12 or newer. Create an isolated environment with conda (from miniforge) or uv, and activate it in every new terminal. ffmpeg is needed for video on most platforms (on macOS Intel and 32-bit ARM Linux LeRobot falls back to PyAV and you can skip it); the conda package works with every PyTorch version.
conda create -y -n lerobot python=3.12
conda activate lerobot
conda install ffmpeg -c conda-forgeInstall LeRobot from PyPI with the extras you need. core_scripts adds what recording, replay and calibration use, feetech adds support for the STS3215 servos, and training adds the training tools.
pip install 'lerobot[core_scripts,feetech]'
pip install 'lerobot[training]'Platform notes: on Apple silicon PyTorch needs macOS 14 or newer, and macOS 15 or newer for GPU (MPS) acceleration. To use an NVIDIA GPU on Linux, the default PyTorch builds need a driver 580.65 or newer; with an older driver, install a matching CUDA build of PyTorch first and take torchcodec from the CPU index (see the Hugging Face installation page). Inside WSL also install evdev (conda install evdev -c conda-forge, or with uv sudo apt install libevdev-dev and then uv pip install evdev). With PyTorch 2.10 or newer you can use the system ffmpeg instead of the conda one.
Find the ports and set the motor IDs
New STS3215 servos usually ship with ID 1, and the controller and every servo must share one baud rate. LeRobot writes both into each servo's memory once, so do this before assembly and connect one servo at a time. Servos reused from another robot probably need it too.
Swipe sideways to see the whole figure.
Connect a control board to the computer by USB, power it, and run the port finder. Unplug only that board's USB cable when asked and press Enter; the script prints the port, such as /dev/ttyACM0 on Linux, /dev/tty.usbmodem… on macOS or COM3 on Windows. Plug the cable back in, then repeat for the second board. On Linux you may have to allow access with sudo chmod 666 on each port (for example /dev/ttyACM0 and /dev/ttyACM1).
lerobot-find-portRun the setup script for the follower, then for the leader, each with its own port. The script names one motor at a time, so read the steps below before you run it.
lerobot-setup-motors \
--robot.type=so101_follower \
--robot.port=/dev/ttyACM0The leader uses the teleoperator options instead of the robot options. At each prompt take the motor with the gear ratio listed for that joint in the table in the parts section (on the leader 1/191 for shoulder pan and elbow flex, 1/345 for shoulder lift and 1/147 for wrist flex, wrist roll and gripper), and mark each motor with its ID as soon as the script reports it set.
lerobot-setup-motors \
--teleop.type=so101_leader \
--teleop.port=/dev/ttyACM1- The script names one motor at a time, starting with the gripper (ID 6) and ending with the shoulder pan (ID 1). Connect only that motor to the control board; it must not be chained to any other motor.
- Press Enter. When the script reports that the ID is set, unplug that motor's cable from the board, connect the next motor it names and press Enter again.
- Check the power, USB and 3-pin cables before each Enter. If the script reports an error, check these cables first, and on a Waveshare board both jumpers must sit on channel B (USB).
- When the script finishes, chain the motors together in order and connect the shoulder pan motor (ID 1) to the control board.
Swipe sideways to see the whole figure.
Setting motor IDs one servo at a time, then chaining the servos in order
Assemble the leader and follower arms
Both arms share most printed parts and are built in the same order (the wrist roll part differs, and the leader has a handle and trigger where the follower has a moving jaw): base and shoulder, upper arm, forearm, wrist, then the gripper on the follower or the handle and trigger on the leader. Hugging Face publishes a short video for each joint on its SO-101 page; follow it next to these notes. Remove all support material from the printed parts first, and plug a 3-pin cable into every servo before you close it in.
- Joint 1, shoulder pan: fit both horns on the motor and secure the top one with an M3×6 screw (the bottom horn needs none). Set the motor into the base with four M2×6 screws, slide on the first motor holder with two M2×6, attach the shoulder with four M3×6 on top and four below, and add the shoulder motor holder.
- Joint 2, shoulder lift: fit both horns and secure the top one with an M3×6 screw (the bottom horn needs none), slide the motor in from the top, fasten it with four M2×6, then attach the upper arm with four M3×6 on each side.
- Joint 3, elbow: fit both horns and secure the top one with an M3×6 screw (the bottom horn needs none), insert motor 3 with four M2×6, and connect the forearm to it with four M3×6 on each side.
- Joint 4, wrist flex: fit both horns and secure the top one with an M3×6 screw (the bottom horn needs none), slide over motor holder 4, slide in motor 4 and fasten it with four M2×6.
- Joint 5, wrist roll: put motor 5 in the wrist holder with two M2×6 at the front, fit a single horn with an M3×6 screw, and secure the wrist to motor 4 with M3×6 screws as shown in the official Joint 5 video (the written guide says four on both sides).
- Follower gripper: attach the gripper to the wrist motor's horn with four M3×6, fit the gripper motor with two M2×6 on each side, fit both horns and secure the top one with an M3×6 screw (the bottom horn needs none), and secure the claw with M3×6 screws as shown in the official gripper video (the written guide says four on both sides).
- Leader handle: mount the leader holder on the wrist with four M3×6, fasten the handle to it with one M2×6, fit motor 6, the trigger motor (the official guide calls it the gripper motor), with two M2×6 on each side and a horn with an M3×6 screw, then attach the trigger with four M3×6.
- Before you power anything, turn each joint slowly by hand through its range and never force it past a stop; it should move without scraping. Mark each motor with its ID before you close it in, and clamp both bases to the table.
Calibrate both arms
Calibration records each joint's range so that the leader and the follower report the same numbers in the same physical pose. It also lets a policy trained on one robot run on another. Do it once for each arm, and again after a hardware change or when LeRobot reports a missing calibration. Recordings and policies made before a recalibration used the old calibration.
Calibrate the follower first. The script asks you to move every joint to the middle of its range and press Enter, then to move each joint through its full range of motion and press Enter again when every joint has been through it. Give each arm a unique id; that name labels its calibration file. The commands in this guide use /dev/ttyACM0 for the follower and /dev/ttyACM1 for the leader as examples: replace them with the ports you found, and do not swap the two arms.
Swipe sideways to see the whole figure.
lerobot-calibrate \
--robot.type=so101_follower \
--robot.port=/dev/ttyACM0 \
--robot.id=my_follower_armThen calibrate the leader with the same movements.
lerobot-calibrate \
--teleop.type=so101_leader \
--teleop.port=/dev/ttyACM1 \
--teleop.id=my_leader_armUse the same id in every later command; that is how LeRobot finds the calibration file, which is stored under ~/.cache/huggingface/lerobot/calibration by default. Back it up and keep it out of temporary folders: one community builder lost the calibration files in a power cycle and redid the calibration without putting every joint at the middle of its range, which gave some joints wrong homing offsets.
Teleoperate the follower with the leader
Teleoperation connects the two arms: the follower copies the leader. If a calibration is missing, the command starts the calibration procedure first. Start with small, slow movements, keep clear of the follower's joints, and keep the power supply within reach.
lerobot-teleoperate \
--robot.type=so101_follower \
--robot.port=/dev/ttyACM0 \
--robot.id=my_follower_arm \
--teleop.type=so101_leader \
--teleop.port=/dev/ttyACM1 \
--teleop.id=my_leader_armAdd cameras next. List them with the camera finder, which prints each camera's identifier and saves a test frame from each to outputs/captured_images; open the frames to see which index is which camera. The indices can change after a reboot or when you replug a camera.
lerobot-find-cameras opencvTeleoperate again with the cameras attached and a live view in Rerun. The camera names you choose here, such as top and wrist, become the dataset keys later, so use the same names and settings from now on.
lerobot-teleoperate \
--robot.type=so101_follower \
--robot.port=/dev/ttyACM0 \
--robot.id=my_follower_arm \
--robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
--teleop.type=so101_leader \
--teleop.port=/dev/ttyACM1 \
--teleop.id=my_leader_arm \
--display_data=truePlace the cameras so the policy can learn
A policy sees only the camera images and the joint positions, so a good camera setup matters more than high resolution. 640×480 at 30 fps is enough for most tasks and keeps recording and training fast.
Swipe sideways to see the whole figure.
- Light the scene evenly with diffuse light. Avoid direct sunlight, strong reflections and moving shadows: lighting that differs between recording and running can make a policy fail.
- Fix the cameras rigidly and never move them between recording and running. One community builder's first policy only pecked at the table, and one of several causes was that the cameras had moved slightly between recording and testing.
- Frame the task: the object, the gripper and the target should be visible in at least one camera. A good test is whether you could do the task yourself from the camera images alone. The same community builder demonstrated while watching only the camera feed; if you try that, keep the power supply within reach.
- The same builder replaced a side camera, whose view of the gripper tips was poor during grasps, with an overhead camera next to the front camera, which reduced occlusion; a wrist camera appears in that post only as a next step. If you record through the day, fix the exposure and white balance in your webcam's own settings; LeRobot's RealSense camera configuration also accepts
exposure,gainandwhite_balance. - With two identical webcams on Ubuntu, the USB addresses can swap and a recording may stop with a camera error. The same builder fixed this with udev rules that identify each camera by its physical USB port, so keep each camera in the same port; otherwise run the camera finder again after every reboot.
Record a dataset
Datasets use the LeRobotDataset format and are uploaded to the Hugging Face Hub. Create a free account, make a token with write access in your Hugging Face settings, then log in and keep your user name in a variable. Set HUGGINGFACE_TOKEN to your token first, or run hf auth login on its own and paste the token when asked.
hf auth login --token ${HUGGINGFACE_TOKEN} --add-to-git-credential
HF_USER=$(NO_COLOR=1 hf auth whoami | awk -F': *' 'NR==1 {print $2}')
echo $HF_USERRecord five episodes first to test the setup. Use the same robot id, ports and camera settings as in teleoperation, and describe the task in plain words.
lerobot-record \
--robot.type=so101_follower \
--robot.port=/dev/ttyACM0 \
--robot.id=my_follower_arm \
--robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
--teleop.type=so101_leader \
--teleop.port=/dev/ttyACM1 \
--teleop.id=my_leader_arm \
--display_data=true \
--dataset.repo_id=${HF_USER}/record-test \
--dataset.num_episodes=5 \
--dataset.single_task="Grab the black cube" \
--dataset.streaming_encoding=trueLeRobot appends the date and time to the dataset name, so ${HF_USER}/record-test is saved as ${HF_USER}/record-test_YYYYMMDD_HHMMSS. Use that full name in later commands; find it with ls ~/.cache/huggingface/lerobot/${HF_USER}, or add --dataset.no_stamp=true to keep the name you passed. The dataset is stored in ~/.cache/huggingface/lerobot and pushed to the Hub when recording ends. A dataset pushed from a personal account can be public, so check its visibility on the Hub and add --dataset.private=true if it should be private; add --dataset.push_to_hub=False to keep it local. To continue a stopped session, rerun the command with --resume=true, the full timestamped --dataset.repo_id, --dataset.root set to the dataset's local folder, and --dataset.num_episodes set to the number of additional episodes, not the total.
Episode time and reset time default to 60 seconds (--dataset.episode_time_s and --dataset.reset_time_s), and the default number of episodes is 50. The keyboard controls the flow while you record, as the table below shows.
For a first useful dataset choose a simple task, such as picking an object from several positions and placing it in a bin. Record at least 50 episodes, about 10 per position, keep the cameras and your grasping style consistent, and add variety slowly. Re-record failed episodes. Fifty episodes at fixed positions are a starting point; expect a policy that works mainly near the positions you recorded. LeRobot prints a cadence line after each kept episode and a summary when recording ends. If the rate is well below the 30 Hz target, the dataset still claims 30 Hz, so the motion looks faster than it was. Find what slows the loop (in the documentation's example it was the camera reads) and re-record the affected episodes instead of training on them.
Check the data before training. Open the dataset in the LeRobot dataset visualizer on Hugging Face, and replay an episode on the robot to test that the motion repeats. Replay moves the arm without your input, so clear the workspace, start the arm near the episode's first pose and keep the power supply within reach.
lerobot-replay \
--robot.type=so101_follower \
--robot.port=/dev/ttyACM0 \
--robot.id=my_follower_arm \
--dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS \
--dataset.episode=0Scroll sideways to compare all columns.
| Key | Action |
|---|---|
| Right arrow or n | Finish the episode or the reset period early and move on |
| Left arrow or r | Discard the current episode and record it again |
| Esc or q | Stop the session: the episode in progress is saved, then the videos are encoded and the dataset is uploaded (press Left arrow or r first to discard that episode) |
Train an ACT policy
ACT (Action Chunking Transformer) is the policy used in the LeRobot tutorial: it adapts to the motors and cameras stored in your dataset. The hardware guide puts the light policies (ACT, VQ-BeT, TD-MPC) at about 2 to 6 GB of GPU memory at batch size 8, as an indicative figure. Train on an NVIDIA GPU (cuda); on Apple silicon change the command to --policy.device=mps, which needs macOS 15 or newer (on macOS 14 LeRobot falls back to the CPU, which is not suitable for training).
Start training with the full dataset name.
lerobot-train \
--dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS \
--policy.type=act \
--output_dir=outputs/train/act_so101_test \
--job_name=act_so101_test \
--policy.device=cuda \
--trackio.enable=true \
--policy.repo_id=${HF_USER}/my_policy \
--steps=20000Without --steps training runs 100,000 steps, usually more than a small dataset needs: imitation learning typically converges within 5 to 10 passes over the data. A 50-episode dataset of 30-second episodes at 30 fps holds about 45,000 frames, which at batch size 8 is about 5,600 steps per pass, so 5 to 10 passes is roughly 28,000 to 56,000 steps. The command above uses --steps=20000, about three and a half passes, as a short first run; raise it if the policy is undertrained, and if you cut it much lower also set --policy.scheduler_decay_steps close to --steps. The hardware guide estimates roughly 30 to 60 minutes for five passes of ACT at batch size 8 on an RTX 3090 or 4090 and 1 to 2 hours on an L4 or A10G, and 6 to 14 hours at batch size 4 on an M1, M2 or M3 Max; it calls these figures indicative and says real runs can differ by about 50%.
Without a suitable GPU, train in Google Colab with the ACT notebook, or run hf auth login and add a Hugging Face Jobs flavor such as --job.target=a10g-small to the same command. Because that command enables Trackio, a job also needs --trackio.space_id=<user>/<space> (add --trackio.private=true to keep the Space private), or remove --trackio.enable=true. Jobs are billed per second and capped at 48 hours unless you set --job.timeout, upload a local-only dataset to a private repository for you, and push the trained model at the end; hf jobs hardware lists the flavors.
Checkpoints are written to outputs/train/act_so101_test/checkpoints. Resume an interrupted run from the last checkpoint. Because the training command sets --policy.repo_id=${HF_USER}/my_policy, the finished model is pushed to that repository at the end (--policy.push_to_hub=false turns this off, --policy.private=true makes it private); to upload a checkpoint yourself, use the same repository name so that --policy.path=${HF_USER}/my_policy finds it.
lerobot-train \
--config_path=outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json \
--resume=true
hf upload ${HF_USER}/my_policy \
outputs/train/act_so101_test/checkpoints/last/pretrained_modelLeRobot's training script does not evaluate real-robot policies, so keep some episodes out of training, including start positions you did not record, and test the policy on them. A community builder trained on 50 episodes (10 in each of five start-position regions) and saw 60% success on new episodes from those regions but only 10% on episodes from a region left out of training. After raising the data to 25 episodes per region, the same builder reached 90% and 75%. These are small samples, scored with the builder's own scripts.
Run the policy on the follower
Deploy a trained policy with lerobot-rollout. Use the same robot id, camera names, camera settings and task text that you used when recording, and run the port finder again if you rebooted or replugged since. --duration is in seconds; without it the policy runs until you stop it.
lerobot-rollout \
--strategy.type=base \
--policy.path=${HF_USER}/my_policy \
--robot.type=so101_follower \
--robot.port=/dev/ttyACM0 \
--robot.id=my_follower_arm \
--robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
--task="Grab the black cube" \
--duration=60The strategy sets what happens during the run, as the table below shows. A strategy that records a dataset needs a repository name that starts with rollout_ after your user name, for example --dataset.repo_id=${HF_USER}/rollout_so101_test; a timestamp is added to it. Recording strategies such as sentry take --dataset.single_task instead of --task; see the LeRobot documentation for each strategy's flags.
On LeRobot v0.5.x and earlier there is no lerobot-rollout; use lerobot-record as described in the v0.5.1 documentation. The training flags in this guide target the current release.
Run the first time with a short duration (for example 15 seconds), a clear workspace and a plan for how you will stop the arm; cutting the power releases the motors, so an arm that is not resting on something can drop. If the arm pecks at the table or overreaches, check the setup before blaming the model: the same calibration id, cameras in the same place with the same names and resolution, the same lighting, and objects in positions the dataset covers.
Scroll sideways to compare all columns.
| Strategy | What it does |
|---|---|
| base | Runs autonomously without recording, for quick tests |
| sentry | Records continuously and uploads automatically |
| highlight | Keeps a ring buffer and saves it when you press a key |
| dagger | Human-in-the-loop data collection |
| episodic | Records episode by episode with reset phases in between |
Extend the build with LeKiwi
LeKiwi is a three-wheeled mobile base that carries an SO-101 follower arm. A Raspberry Pi, or another 5 V computer with enough USB ports for the cameras and the motor control board (the LeKiwi page says two or more), runs the robot, and you drive it from a laptop with a leader arm and the keyboard. In the wired version everything runs on the laptop and the Pi steps can be skipped. The parts list, print files and base assembly instructions come from the LeKiwi project linked on the Hugging Face LeKiwi page.
Swipe sideways to see the whole figure.
Driving the base from the keyboard needs a global key backend, so it works on X11, on a Windows desktop, or on macOS with Input Monitoring granted to your terminal, but not on Wayland or headless machines.
- Build two SO-101 arms with the sections above: one to mount on the base and one as the leader. Then assemble the base.
- Install Raspberry Pi OS, enable SSH, and check that you can log in with
ssh <user>@<pi-ip>. Install LeRobot on the Pi and on your laptop as in the install section, then add the LeKiwi extra, which brings the servo driver and ZeroMQ.Install the LeKiwi extra pip install 'lerobot[lekiwi]' - Set up all motors with one command. It gives the arm motors IDs 6 to 1 and the wheels 9, 8 and 7; the wheel IDs must match the mounting positions shown in the LeKiwi documentation. LeKiwi uses a single control board.
Set the LeKiwi motor IDs lerobot-setup-motors \ --robot.type=lekiwi \ --robot.port=/dev/ttyACM0 - Calibrate the follower arm on the Pi, and the leader arm on the laptop. The LeKiwi page shows
--teleop.type=so100_leaderfor the leader; check which leader classexamples/lekiwi/teleoperate.pycreates, and calibrate with the same type and--teleop.id. The wheel motors need no calibration.Calibrate the LeKiwi arm lerobot-calibrate \ --robot.type=lekiwi \ --robot.id=my_awesome_kiwi - On the Pi, activate the LeRobot environment and start the host. It stops after 30 seconds unless you raise
--host.connection_time_s(for example to 600), which you need for longer sessions such as recording.Start the LeKiwi host on the Pi python -m lerobot.robots.lekiwi.lekiwi_host \ --robot.id=my_awesome_kiwi \ --host.connection_time_s=600 - On the laptop, edit
examples/lekiwi/teleoperate.pyin the LeRobot source repository: setremote_ipto the Pi's address and the leader arm'sportand id to your own values, then run it. Inrecord.pyalso setHF_REPO_IDandTASK_DESCRIPTION; inreplay.pysetremote_ip,port, the dataset id and the episode index. To run a trained policy the LeKiwi page usesexamples/lekiwi/evaluate.py(setremote_ip,portand the model); thelerobot-rolloutcommand in the previous section is written for a stand-alone SO-101. Speed has three modes, changed with R and F: fast 0.3 m/s and 90°/s, medium 0.2 m/s and 60°/s, slow 0.1 m/s and 30°/s.
Scroll sideways to compare all columns.
| Key | Action |
|---|---|
| W | Move forward |
| A | Move left |
| S | Move backward |
| D | Move right |
| Z | Turn left |
| X | Turn right |
| R | Increase speed |
| F | Decrease speed |
Troubleshooting checklist
Many problems come from power, cables, ports, or a setup that changed between recording and running. Work through this table before you change any code.
For questions about LeRobot itself, the Hugging Face documentation links its Discord community. For parts from our shop, use the WhatsApp button or the support form.
Scroll sideways to compare all columns.
| Symptom | What to check |
|---|---|
| A serial port is not found or access is denied | Run the port finder again with the board powered and the USB cable in. On Linux allow access with sudo chmod 666 on the port. Ports can change after a reboot or replug, so run the port finder again. |
| The ID script cannot find the motor | Check the power supply, the USB cable and the 3-pin cable. Only the motor being set may be connected. On a Waveshare board both jumpers must be on channel B (USB). |
| Reused servos are not found or do not respond | Their IDs and baud rate likely do not match the new robot, as the SO-101 guide notes. Run the motor setup again, one servo at a time. |
| Calibration fails, or the arm moves wrongly after calibrating | Calibrate again: first put every joint in the middle of its range and press Enter, then move each joint through its full range. A community builder who did not centre every joint ended up with wrong homing offsets. Use the same robot id afterwards. |
| A camera disconnects or its index changes | Run the camera finder again after every reboot or replug. Two identical webcams can swap USB addresses on Linux; one community builder fixed this with udev rules keyed on the physical USB port. |
| The recording keys do nothing | Start the command from an interactive terminal and keep it focused; the letter keys n, r and q work as well as the arrow and Esc keys. Only driving a robot with the keyboard, as on LeKiwi, needs X11, a Windows desktop or macOS permission. |
| Training cannot find the dataset | Use the full dataset name, including its date and time suffix. |
| The recorded cadence is far below 30 Hz | Read the cadence lines that the recording prints. If reading the cameras dominates, lower the resolution or use fewer cameras, then record again: a policy expects the same camera setup at run time, and episodes recorded well below 30 Hz are stored as if they ran at 30 Hz. |
| The policy pecks at the table or overreaches | Compare the calibration id, camera positions, names and lighting with the recording session, and check that objects start where the dataset has examples. |
| LeKiwi does not connect, or the host stops after 30 seconds | Find the Pi's address with hostname -I, ping it from the laptop and test ssh <user>@<pi-ip>; enable SSH in sudo raspi-config if needed. The host stops after 30 seconds unless you set --host.connection_time_s. |