Teaching Robotics With the SO-100: A Semester Course Plan

A robotics course lives or dies on whether the hardware survives twenty students. The SO-100 is one of the few arms cheap enough for a department to buy a set and open enough that a broken gripper costs an evening of printing, not a purchase order. What follows is a course plan: what a seat costs, what a student finishes in fourteen weeks, and which exercises teach.

Software here describes LeRobot v0.6.1, released 3 August 2026, read from the upstream docs in August 2026. Upstream moves: the inference entry point went from lerobot-record --policy.path in v0.5.1 to a dedicated lerobot-rollout, and the install was split into optional extras. Pin a version in the syllabus and date it, or week 9 goes on debugging a command that no longer exists.

Why the SO-100 is a teaching arm, not a research arm

Six degrees of freedom, bus servos that report their own position, a printed frame, a two-finger end effector. No absolute encoders, no torque sensing, no compliance control. Every omission makes the arm poor for research and good for teaching: the failure modes are large and mechanically obvious. A student who watches the follower miss a cube by two centimetres can usually name the cause without instrumentation. On a 30,000 EUR collaborative arm the same failure hides behind a controller nobody may open.

Cost per seat, worked out

The published bill of materials totals USD 229.88 or EUR 226.30 for a leader and follower pair: twelve STS3215 servos across three gear ratios, two control boards, two power supplies, cables and clamps. A follower alone is USD 121.94 or EUR 124.30, and filament, cameras and the host machine are outside that. This site lists SO-100 parts at 110 to 150 EUR and SO-101 at 130 to 170 EUR per arm.

Fleet arithmetic matters more than unit price. One seat serves two to three students in rotation, because recording is a single-operator job while the others audit footage, write the LeRobot dataset card and prepare the next reset. For 20 students, 7 pairs works and 10 is comfortable: roughly 1,600 to 2,300 EUR. Add a spare follower per five seats, because something snaps in week 3.

What a student can build in fourteen weeks

The realistic deliverable for one semester: a working leader-follower rig, a 50-episode dataset with a data card, one trained policy that completes one tabletop task at some measured rate, and a report explaining three ablations. One task, honestly measured, failures documented. Teams that aim higher deliver less.

Half the semester happens before a network is trained and a third after. That ratio is correct and students will resist it. Here, SO-100 getting started covers weeks 1 to 3, record your first dataset covers 4 to 6, and train your first policy plus run your first policy cover 8 and 9. The free Hugging Face robotics course is a usable lecture spine: 30 to 45 minute units needing no hardware, so a student who misses a lab keeps up.

Five exercises that actually teach something

1. Calibrate, then break the calibration on purpose

Most courses treat calibration as setup. It is the best teaching artifact on this arm, because getting it wrong is immediate and recoverable. Calibrate correctly, verify by teleoperation, then deliberately mis-calibrate one joint and describe what the leader-follower mapping does.

1. 1
   Find the two serial ports

   Run with both arms connected, unplug one when prompted. Students find out for themselves that port numbers are not stable across reboots.

   bash

   lerobot-find-port

2. 2
   Write motor IDs into servo EEPROM

   One motor at a time, gripper first. Written to EEPROM, so once per arm. Where teams learn a bus needs unique addresses.

   bash

   lerobot-setup-motors \
       --robot.type=so101_follower \
       --robot.port=/dev/ttyACM0
   
   lerobot-setup-motors \
       --teleop.type=so101_leader \
       --teleop.port=/dev/ttyACM1

3. 3
   Calibrate both arms with stable ids

   Centre every joint, press enter, sweep each through its full range. The id string is how LeRobot finds the calibration file; renaming it breaks every later command.

   bash

   lerobot-calibrate \
       --robot.type=so101_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=lab03_follower
   
   lerobot-calibrate \
       --teleop.type=so101_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=lab03_leader

4. 4
   Verify, then break it

   Teleoperate with both cameras and the Rerun viewer on. Then recalibrate the shoulder with the arm parked 20 degrees off centre and drive again. Write down the offset and which joints amplified it.

   bash

   lerobot-teleoperate \
       --robot.type=so101_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=lab03_follower \
       --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=lab03_leader \
       --display_data=true

What it teaches: a network trained on one robot transfers to another only because calibration made them agree on what joint angle zero means. That lands harder after watching a 20 degree offset propagate down the chain. When ports refuse to appear, arm not detected and joint stops early cover the usual causes.

2. Record 50 episodes, then audit them before training

Upstream guidance for a first grasping task is 50 episodes, about 10 per object location, cameras fixed and grasp behaviour consistent. Its rule of thumb is the useful part: you should be able to do the task yourself from the camera images alone. If you cannot, neither can the policy.

lerobot-record \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=lab03_follower \
    --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=lab03_leader \
    --dataset.repo_id=${HF_USER}/lab03_cube_in_bowl \
    --dataset.num_episodes=50 \
    --dataset.single_task="put the red cube in the bowl" \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=15 \
    --display_data=true

1. Watch all 50 episodes at speed. Count how many the operator would fail if graded.
2. Count episodes where the object starts outside the region the policy will be tested in.
3. Check whether the gripper closes to the same width every time, or the operator got lazy after episode 30.
4. Look for camera drift. If the wrist camera moved at episode 13, the dataset holds two tasks.
5. Write a one-page data card: task, objects, locations, lighting, operator, defects. Graded.

3. Train, then distrust the loss curve

ACT is the right first model: about 80 M parameters, trained from scratch on the student's data, with an action chunking head that predicts a whole sequence at once. It wants 50 episodes and any 24 GB card, at roughly 1 to 3 USD a run. Platform defaults: batch size 8, learning rate 1e-5, 100,000 max steps, chunk size 100, 100 action steps.

lerobot-train \
  --dataset.repo_id=${HF_USER}/lab03_cube_in_bowl \
  --policy.type=act \
  --output_dir=outputs/train/act_lab03 \
  --job_name=act_lab03 \
  --policy.device=cuda \
  --policy.repo_id=${HF_USER}/act_lab03 \
  --steps=20000 \
  --wandb.enable=true

The exercise is not to get a low loss. It is to write down beforehand what a low loss would and would not prove. A training step count that looks healthy on a chart is fully compatible with an arm that sits still, because imitation loss is measured against demonstrations, not task success. It has its own page: loss falls, policy does nothing. Requiring the prediction in advance turns a plotting exercise into an epistemic one.

4. The ablation that produces the grade

One trained policy is an anecdote. Three policies differing in exactly one input are an experiment. This is the part that transfers to everything else the student does, and it is cheap here: a retrain costs a couple of dollars, not a grant.

• Drop the wrist camera and retrain. Grasping usually degrades more than the overhead view suggests, which shows which sensor carried the task.
• Halve the dataset to 25 episodes. Plot success against episode count, then argue honestly about what two points support.
• Keep the policy, move the table 15 cm, change the lamp. No retraining. The answer is humbling: policy only works in one setup.
• Swap the red cube for a blue one of the same shape, then a red one of a different shape. Which hurts more, and what does that say about what the network keyed on?
• Re-record 10 episodes with a second operator and mix them in. Operator style is a confound nobody warns undergraduates about.

5. Replay, to separate the arm from the policy

Before blaming a model, replay a recorded episode straight back onto the hardware. The arm executes the recorded action sequence with no network in the loop. If replay does not reproduce the original motion, the problem is mechanical or calibration-related and no training fixes it. Five minutes here saves whole weeks.

lerobot-replay \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=lab03_follower \
    --dataset.repo_id=${HF_USER}/lab03_cube_in_bowl \
    --dataset.episode=0

Two ways to run the course

The same fourteen weeks run either on department hardware or with the cloud parts outsourced. The trade is not quality, it is which failures the students own. Self-hosting teaches CUDA drivers alongside robotics, which is either valuable or eight lost lab hours.

conda create -y -n lerobot python=3.12
conda activate lerobot
conda install ffmpeg -c conda-forge

git clone https://github.com/huggingface/lerobot.git
cd lerobot
pip install -e ".[core_scripts,training,feetech]"

hf auth login

Which policy to teach with

Five policies are trainable here and two belong in an undergraduate course. The rest are worth a lecture and a table, not a lab, because inference latency and GPU tier decide what a student can debug alone.

Teach ACT first. It trains from scratch on the student's own data, so the link between demonstration quality and behaviour is not diluted by a pretrained prior. There is no base ACT model at all, only the one the class produces, which is what a first imitation learning unit wants. Contrast with SmolVLA: 30 episodes minimum and a pretrained backbone, so the same data goes further. The ACT vs SmolVLA comparison is the slide, and the arena lists 85 vision-language-action model entries with 332 benchmark results, each linked to its paper.

Honest limits, including where a platform does not help

The latency limit constrains course design. Inference has to sit next to the servos for anything fast: the control loop is 20 to 485 ms per action step depending on the model, and public-internet round trips on top turn a working policy into a hesitant one. Fine for slow pick and place, not for anything reactive.

Some things no platform fixes. It will not print your parts, stop a student remounting the wrist camera each session, or turn 30 sloppy episodes into a working policy. Cloud training removes the driver problem and nothing about data quality. Assign collecting high-quality VLA training data in week 4, before the first recording session, and pair it with the complete SO-100 setup guide as the build-week reference.

Grade the report, not the demo

Success rate here varies between teams for reasons unrelated to effort: a better print, a stiffer camera mount, an object with more contrast. Grading demo-day success rewards luck and pushes teams to cherry-pick the lighting that works. Grade the epistemics instead.

Two failure modes to pre-empt in the brief. Teams that spend eleven weeks assembling and two learning: set a week 4 cutoff, after which any team without a working rig switches to a public dataset from the dataset directory and continues on software. And teams reporting a single number: demand a denominator. The failure-mode index gives shared vocabulary for a policy that freezes mid-motion or an arm that twitches then sags.

Questions course leads ask