Connecting to sources…

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

PartQtyUSCNJPEU
Dynamixel XL330-M077-T6USD 24CNY 255JPY 4070
XL330 Frame and Idler Wheel 4pcs set1USD 10CNY 100JPY 2024
Waveshare Serial Bus Servo Driver Board1USD 10CNY 24
5V Power Supply1USD 6CNY 10JPY 899GBP 10
Jumper Wires 3*40 pcs set (M-M, M-F, F-F)1USD 7CNY 10GBP 5
Table Clamp1USD 6CNY 8
Table Clamp 4pcs set1
1.5mm Star/Cruciform Screwdriver 2pcs set1GBP 4CNY 2
USB C-A or C-C 2pcs set1GBP 6CNY 12

Bill of materials · Follower Arm

PartQtyUSCNJPEU
Dynamixel XL430-W250-T2USD 50CNY 485JPY 6831
Dynamixel XL330-M288-T4USD 24CNY 255JPY 4070
XL330 Frame and Idler Wheel 4pcs set1USD 10CNY 100JPY 2024
XL430 Idler Wheel set1USD 7CNY 75JPY 836
Waveshare Serial Bus Servo Driver Board1USD 10CNY 24
Voltage Reducer1GBP 15CNY 11
12V Power Supply1USD 12CNY 20JPY 1685GBP 13
Jumper Wires 3*40 pcs set (M-M, M-F, F-F)1USD 7CNY 10GBP 5
Table Clamp1USD 6CNY 8
Table Clamp 4pcs set1
1.5mm Star/Cruciform Screwdriver 2pcs set1GBP 4CNY 2
USB C-A or C-C 2pcs set1GBP 6CNY 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)

Documents