How to build Koch v1.1 low-cost robot arm (leader/follower pair): the whole process
126 steps to build Koch v1.1 low-cost robot arm (leader/follower pair), from buying parts, printing and assembly to software, calibration and training, with the bill of …
The creator's BOM estimate in the README: leader $199 and follower $278 (US prices, about $477 for the pair); €305 + €368 in Europe, £222 + £285 in the UK, CN¥1,696 + CN¥2,251 in China, JP¥6,993 + JP¥15,446 in Japan. Filament, printer and shipping are excluded and the README notes regional variation; there is no official kit price
Bill of materials · Leader Arm
| Part | Qty | US | CN | JP | EU |
|---|---|---|---|---|---|
| Dynamixel XL330-M077-T | 6 | USD 24 | CNY 255 | JPY 4070 | |
| XL330 Frame and Idler Wheel 4pcs set | 1 | USD 10 | CNY 100 | JPY 2024 | |
| Waveshare Serial Bus Servo Driver Board | 1 | USD 10 | CNY 24 | ||
| 5V Power Supply | 1 | USD 6 | CNY 10 | JPY 899 | GBP 10 |
| Jumper Wires 3*40 pcs set (M-M, M-F, F-F) | 1 | USD 7 | CNY 10 | GBP 5 | |
| Table Clamp | 1 | USD 6 | CNY 8 | ||
| Table Clamp 4pcs set | 1 | ||||
| 1.5mm Star/Cruciform Screwdriver 2pcs set | 1 | GBP 4 | CNY 2 | ||
| USB C-A or C-C 2pcs set | 1 | GBP 6 | CNY 12 |
Bill of materials · Follower Arm
| Part | Qty | US | CN | JP | EU |
|---|---|---|---|---|---|
| Dynamixel XL430-W250-T | 2 | USD 50 | CNY 485 | JPY 6831 | |
| Dynamixel XL330-M288-T | 4 | USD 24 | CNY 255 | JPY 4070 | |
| XL330 Frame and Idler Wheel 4pcs set | 1 | USD 10 | CNY 100 | JPY 2024 | |
| XL430 Idler Wheel set | 1 | USD 7 | CNY 75 | JPY 836 | |
| Waveshare Serial Bus Servo Driver Board | 1 | USD 10 | CNY 24 | ||
| Voltage Reducer | 1 | GBP 15 | CNY 11 | ||
| 12V Power Supply | 1 | USD 12 | CNY 20 | JPY 1685 | GBP 13 |
| Jumper Wires 3*40 pcs set (M-M, M-F, F-F) | 1 | USD 7 | CNY 10 | GBP 5 | |
| Table Clamp | 1 | USD 6 | CNY 8 | ||
| Table Clamp 4pcs set | 1 | ||||
| 1.5mm Star/Cruciform Screwdriver 2pcs set | 1 | GBP 4 | CNY 2 | ||
| USB C-A or C-C 2pcs set | 1 | GBP 6 | CNY 12 |
Buy parts
- Source the leader and follower arms
Order the off-the-shelf parts for the leader and follower arm using the document's regional links. Available regions are the US, EU, UK, China, and Japan.
- Order the leader-arm parts
Order the required off-the-shelf leader-arm parts using the regional links listed in the document.
- Order the follower-arm servos
Order 2 Dynamixel XL430-W250-T servomotors for the follower arm using the provided buying links for the US, EU, UK, China, and Japan.
- Choose a 3D printer
Use a minimum layer height of 0.2 mm, a nozzle diameter of 0.4 mm or smaller, approximately 30% infill, and a sufficiently strong plastic such as PLA+, ABS, or PETG. Sample printers include the Prusa Mini+, Bambu P1, and Ender3.
- Prepare printing supplies and tools
Prepare a standard glue stick and a putty knife.
- Prepare Print-Bed Tools
Prepare a glue stick and putty knife. The glue prevents parts from sticking to the print bed, while the putty knife helps scrape parts from it; check the printer's instructions to confirm whether they are needed.
Print and make
- Calibrate the printer and level the bed
Calibrate the printer and correctly set the bed level using the printer-specific instructions.
- Clean the print bed
Remove dust and grease from the bed. If water or another liquid is used, dry the bed afterward.
- Apply glue to the bed
Apply a thin, even layer of glue with a standard glue stick across the print area, avoiding clumps or uneven application.
- Load the printer filament
Load the printer filament using the printer-specific instructions.
- Match the printer settings
Adjust the printer settings to match the suggested values as closely as possible; when the printer has multiple options, choose the closest ones.
- Select and print hardware files
Check the file type, choose the file or files from the hardware folder, and print.
- Print Leader_Base
Print one `Leader_Base` from `hardware/leader/STL`.
- Print Leader_Elbow_To_Wrist
Print one `Leader_Elbow_To_Wrist` from `hardware/leader/STL`.
- Print Leader_Elbow_To_Wrist_Extension
Print one `Leader_Elbow_To_Wrist_Extension` from `hardware/leader/STL`.
- Print Leader_Gripper_Handle
Print one `Leader_Gripper_Handle` from `hardware/leader/STL`.
- Print Leader_Gripper_Trigger
Print one `Leader_Gripper_Trigger` from `hardware/leader/STL`.
- Print Leader_Shoulder_To_Elbow
Print one `Leader_Shoulder_To_Elbow` from `hardware/leader/STL`.
- Print Leader_Platform
Print one `Leader_Platform` from `hardware/leader/STL`.
- Print Robotis_FPX330_S101
Print one `Robotis_FPX330_S101` from `hardware/leader/STL`.
- Print Follower_Base
Print one `Follower_Base` from `hardware/follower/STL`.
- Print Follower_Elbow_To_Wrist
Print one `Follower_Elbow_To_Wrist` from `hardware/follower/STL`.
- Print Follower_Elbow_To_Wrist_Extension
Print one `Follower_Elbow_To_Wrist_Extension` from `hardware/follower/STL`.
- Print Follower_Gripper_Moving_Part
Print one `Follower_Gripper_Moving_Part` from `hardware/follower/STL`.
- Print Follower_Gripper_Static_Part
Print one `Follower_Gripper_Static_Part` from `hardware/follower/STL`.
- Print Follower_Shoulder_Rotation
Print one `Follower_Shoulder_Rotation` from `hardware/follower/STL`.
- Print Follower_Shoulder_To_Elbow
Print one `Follower_Shoulder_To_Elbow` from `hardware/follower/STL`.
- Print optional HuggingFace_Block
Print one optional `HuggingFace_Block`.
- Print optional LeRobot_Block
Print one optional `LeRobot_Block`.
- Remove printed parts from the bed
After printing is complete, use the putty knife to scrape the parts off the print bed.
- Remove support material
Remove all support material from the printed parts.
- Reapply glue before the next print
Reapply the glue stick to the bed before starting the next print.
- Convert the Print File Format
All suggested printers print STL files. If the printer supports only a different format, convert the file to the correct extension before printing.
- Print the Optional Follower-Arm Part
This part is not strictly necessary to print, but it allows the follower arm to reach the ground, which it otherwise cannot do in the current setup.
Assemble
- Assemble the leader and follower arms
Construct the leader and follower arms using the assembly video.
- Connect both arms by USB-C
Plug each arm into your computer using a USB-C cable.
- Insert the leader platform nuts
Insert the four M2 nuts into the pockets on the underside of the Leader Platform.
- Fasten the leader platform
Use the four M2x5 machine screws to fasten the Leader_Platform to the Leader_Base.
- Move the servo driver board
Temporarily remove the Waveshare Serial Bus Servo Driver Board to access the two fasteners beneath it.
- Power the Leader-Arm Servos
Although the Serial Bus Servo Driver Board suggests a 9 to 12.6V DC input, only 5V is applied to the leader arm. The lower voltage will not hurt the board and is required to correctly power the leader-arm servos.
Software
- Install Miniforge with conda
Download the Miniforge3 installer for the current operating system and architecture, then run it.
- Choose an environment manager
The guide recommends conda with miniforge. If using another environment manager such as uv or venv, ensure Python >=3.12 is available.
- Create the conda environment
Create a conda environment named lerobot using Python 3.12.
- Create the uv environment
As a uv alternative, install Python 3.12 and create a virtual environment using it.
- Activate the conda environment
Activate the lerobot conda environment each time you open a shell to use LeRobot.
- Install evdev for conda under WSL
When installing LeRobot in WSL with conda, also install evdev from conda-forge.
- Activate the uv virtual environment
Activate the virtual environment each time you open a shell to use LeRobot. Use the Linux/macOS command on Linux or macOS and the Windows PowerShell command on Windows.
- Install evdev for uv under WSL
When installing LeRobot in WSL with uv, install the Linux evdev development package and the evdev Python package.
- Check Apple Silicon requirements
PyTorch on Apple Silicon requires macOS 14 or newer. MPS acceleration requires macOS 15 or newer; on macOS 14, LeRobot falls back to CPU.
- Check Linux driver requirement
The default PyTorch wheels on Linux require an NVIDIA driver version 580.65 or newer. For older drivers, use the PyTorch CUDA variant.
- Skip ffmpeg on unsupported platforms
On macOS Intel (x86_64) or Linux armv7l, skip ffmpeg installation and continue to Step 3 because LeRobot automatically falls back to pyav.
- Install ffmpeg with conda
Install ffmpeg in the conda environment for platforms that support TorchCodec. This usually installs ffmpeg 8.X with the libsvtav1 encoder.
- Install a specific ffmpeg version
If libsvtav1 is missing or ffmpeg has a version mismatch with torchcodec, explicitly install ffmpeg 7.1.1.
- Use a system-wide ffmpeg
With PyTorch >= 2.10 and TorchCodec ≥ 0.10, TorchCodec can dynamically link to a system-wide ffmpeg installation. This is useful when using uv or other non-conda environment managers.
- Install FFmpeg on Ubuntu or Debian
Install FFmpeg using apt so the robot recording and video workflows have the required system dependency.
- Install FFmpeg on Apple Silicon
Install FFmpeg with Homebrew on macOS systems using Apple Silicon.
- Use Conda FFmpeg for Older PyTorch
System-wide FFmpeg is supported with PyTorch >= 2.10 and TorchCodec >= 0.10. For older PyTorch versions, install FFmpeg with Conda instead.
- Install the LeRobot Base Package
Install the base lerobot package from PyPI. This provides only the core ML dependencies; add extras for most workflows.
- Install Feature Extras
Add the feature-scoped extras that match the workflow you need. When using uv, replace pip install with uv pip install.
- Install Composite Workflow Extras
Install composite extras for recording, replaying, calibration, training, or the full package. Multiple extras can be combined when needed.
- Install Policy and Hardware Extras
Install the specific extras required for a policy, simulation environment, or hardware support. Multiple extras can be combined.
- Install LeRobot on Linux
On Linux, the default PyPI wheels for torch and torchvision are CUDA 13 builds and require driver 580.65 or newer. macOS and Windows use the default PyPI wheels and can skip this section.
- Install matching CUDA PyTorch
For an older driver or GPU, install PyTorch from the matching PyTorch index before installing LeRobot. The cu126 index is for drivers that support CUDA 12; it installs torch 2.14 because torch 2.15 has no CUDA 12 build. Install torchcodec from the CPU index, and with torch below 2.11 choose the matching TorchCodec release from the compatibility table.
- Install LeRobot with uv pip
With uv pip, use --torch-backend to select the CUDA index in one step. The cu126 backend installs the CUDA 12 PyTorch build for supported older drivers.
- Configure uv lock CUDA source
uv sync always installs the committed lock. To change the CUDA build used by uv sync, add the index to [tool.uv.index] and [tool.uv.sources] in pyproject.toml, then re-run uv lock.
- Install Linux build dependencies
If build errors occur, install cmake, build-essential, python3-dev, pkg-config, and the listed FFmpeg development libraries on Linux. For other systems, refer to the Compiling PyAV installation guidance.
- Add wrist and top cameras
Add cameras to the setup using the camera Guide. The teleoperation example uses two cameras named wrist and top.
- Configure with LeRobot
The document suggests programming and using the robot with LeRobot.
Calibrate and test
- Connect the follower controller
Connect your computer to the follower arm’s controller board with USB and use the 12V power supply. The leader arm uses the 5V power supply.
- Prepare motor configuration
Run the motor setup command with the port found in the previous step and assign a name to the follower arm using the id parameter. The API example provides the equivalent configuration.
- Connect only the gripper motor
Connect the controller board only to the gripper motor, leaving every other motor disconnected. The gripper motor must not be daisy-chained to another motor, then press Enter so its ID and baudrate are set automatically.
- Check motor connections
If an error occurs, check the power supply, the USB cable between the computer and controller board, and the 3-pin controller-to-motor cable. On a Waveshare controller board, place both jumpers on the B channel (USB).
- Confirm the gripper motor ID
Confirm that the setup reports that the gripper motor ID has been set to 6.
- Connect only the wrist motor
After setting the gripper motor, connect the controller board only to the wrist_roll motor and press Enter.
Data and training
- Teleoperate with Rerun using CLI
Run the teleoperation command with an SO101 follower and leader. Configure the wrist camera at OpenCV index 0 and the top camera at index 1, both at 640×480 resolution and 30 fps, and enable data display.
- Run the Python teleoperation loop
Create SO101 follower and leader configurations with the wrist and top cameras, initialize Rerun visualization, and connect both devices. At 30 Hz, read the robot observation and leader action, send the action to the robot, and log the observation and action for visualization; the visualization backend can instead be Foxglove.
- Reset between recorded episodes
Reset the environment when recording is not stopping and either another episode remains or the current episode is being re-recorded.
- Re-record and clear episode buffer
When re-recording, reset the re-record and early-exit flags, clear the episode buffer, and continue recording.
- Save each completed episode
Save the completed episode in the dataset and increment the episode index.
- Finalize the recorded dataset
Finalize the dataset after all episodes have been saved.
- Disconnect devices and push dataset
Stop recording, disconnect the robot and teleoperation device, and push the finalized dataset to the Hub.
- Keep camera dataset keys consistent
Use the wrist and top camera names for observation.images.wrist and observation.images.top. A deployed policy expects the same camera names and resolution, so reuse the same --robot.cameras value throughout the tutorial.
- Choose timestamped or exact repository name
lerobot-record appends the session date and time to --dataset.repo_id. Add --dataset.no_stamp=true to keep the exact repository name passed.
- Locate the timestamped dataset name
Find the full repository name on the Hugging Face profile or with ls ~/.cache/huggingface/lerobot/${HF_USER}. Use that name wherever record-test_YYYYMMDD_HHMMSS appears.
- Print the uploaded dataset URL
The dataset is uploaded to the Hugging Face page at the end of recording. Print its URL using the timestamped dataset name.
- Add and discover dataset tags
The dataset is automatically tagged with LeRobot. Add custom tags such as --dataset.tags='["tutorial"]', and find other LeRobot datasets by searching for the LeRobot tag.
- Push the dataset to the Hub manually
Push the local dataset to the Hugging Face Hub manually.
- Upload the recorded dataset
Upload the timestamped dataset from the local LeRobot cache to the Hugging Face Hub as a dataset.
- Store recordings on disk
Recordings use the LeRobotDataset format and are stored on disk while recording.
- Disable automatic dataset uploading
Set --dataset.push_to_hub=False to disable uploading.
- Keep automatic recording checkpoints
Checkpoints are created automatically while the recording session runs.
- Resume an interrupted recording
Re-run the same recording command with --resume=true after an issue or to add episodes to the same dataset.
- Select the full dataset name
Pass the full timestamped dataset name with --dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS.
- Set additional episode count
When resuming, set --dataset.num_episodes to the number of additional episodes, not the dataset’s target total.
- Set the local resume path
Set --dataset.root="local_path" to the local path where the new dataset portion will be saved; this setting is required to resume.
- Start a new dataset
Running the command without --resume=true creates a new dataset with a new timestamp.
- Remove an existing unstamped dataset
Before using --dataset.no_stamp=true, delete the existing dataset directory.
- Set episode recording duration
Set --dataset.episode_time_s=60 to make each recording episode last 60 seconds.
- Set environment reset duration
Set --dataset.reset_time_s=60 to allow 60 seconds for resetting the environment after each episode.
- Set total episode count
Set --dataset.num_episodes=50 to record 50 episodes in total.
- Move to the next episode
Press Right Arrow or n to stop the current episode or reset period early and move to the next episode.
- Re-record the current episode
Press Left Arrow or r to cancel the current episode and record it again.
- Stop and finalize the recording
Press Escape or q to stop the session immediately, encode the videos, and upload the dataset.
- Use shortcuts in supported sessions
The recording shortcuts work on X11, Wayland, and headless or SSH sessions. Without a global keyboard backend, lerobot-record reads the same keys from an interactive focused terminal.
- Choose a dataset task
Create a larger dataset for training by grasping an object at different locations and placing it in a bin.
- Record enough episodes
Record at least 50 episodes, including 10 episodes for each object location.
- Keep recordings consistent
Keep the cameras fixed, maintain consistent grasping behavior, and ensure the manipulated object is visible on the cameras.
- Add variations gradually
After achieving reliable grasping performance, introduce additional grasp locations, different grasping techniques, or altered camera positions. Avoid adding too much variation too quickly, as it may hinder results.
- Review recording cadence
Read the cadence report before training and compare the effective cadence with the target. Note that timestamps come from frame indices, so a session running at 25 Hz can still produce a dataset claiming 30.
- Resume a Hub training run
Resume the ${HF_USER}/my_policy run on an a10g-small job with --resume=true.
- Resume a local training run
Resume from the last pretrained model in outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json. The checkpoint is first uploaded to a private Hub repository.
- Configure job and checkpoint settings
Job settings come from the current command, so override --job.target, --job.timeout, and other settings as needed. Keep --save_checkpoint_to_hub=true so the resumed run can be resumed again later.
- Upload the latest policy checkpoint
After training finishes, upload outputs/train/act_so101_test/checkpoints/last/pretrained_model to ${HF_USER}/act_so101_test.
- Upload an intermediate policy checkpoint
Set CKPT to the checkpoint step, such as 010000, and upload that checkpoint's pretrained_model directory.
Use it
- Use letter shortcut equivalents
Use n for next, r for re-record, and q for quit as alternatives to the arrow keys and Escape.
- Prepare Starting Manipuland Blocks
Prepare two blocks, each the same size as a 2x4 Lego block. They do not need to be printed and are useful as a starting manipuland.
Common problems
- SolidWorks version mismatch prevents opening the CAD files #6
- Regional parts suppliers and sourcing links are unavailable #7 #9 #17 #22
- Conflicting servo model recommendations complicate parts selection #11
- Leader base CAD and STL files differ from the assembly video #14 #24
- Servo connector port purposes are unclear, risking incorrect wiring #18
- Servo driver firmware code and IDE are difficult to locate #25
- Cannot update XL-430 firmware through the Waveshare servo driver #13
- Motor-chain setup leaves some or all motors undetected #23 #28
Parts
- Follower: 2 Dynamixel XL430-W250-T (shoulder pan and lift, about $50 each) + 4 XL330-M288-T (elbow, wrist flex, wrist roll, gripper, about $24 each)
- Leader: 6 Dynamixel XL330-M077-T (about $24 each), with a handle and trigger for the gripper
- One Waveshare serial bus servo driver board per arm; a 12V supply with a voltage reducer for the follower, a 5V supply for the leader
- XL330 frame and idler 4-piece set (3 used), XL430 idler set, jumper wires, USB‑C cables, table clamps
- 3D prints: 7 leader parts (including the leader platform) plus an FPX330-S101 frame, and 7 follower parts; optional Hugging Face and LeRobot blocks as objects to grasp
Tools
- A 3D printer: 0.2 mm layers or finer, a nozzle of 0.4 mm at most, about 30% infill, in PLA+, ABS or PETG; a glue stick and putty knife
- A 1.5 mm Phillips screwdriver; no soldering iron needed
Skills
- Assembling both arms from the video (the README notes the leader platform is now screwed on, unlike in the video)
- LeRobot: lerobot-find-port for ports, lerobot-setup-motors for servo IDs and baud rates, lerobot-calibrate for calibration
- Basic Python; teleoperation, dataset recording and policy training
Software
- LeRobot (Apache‑2.0): pip install -e ".[dynamixel]", robot type koch_follower, teleop type koch_leader
- Dynamixel SDK (original README: pip install dynamixel-sdk)