Robots · Robot arms

AgileX PiPER teleoperation: leader arms, CAN control and LeRobot data collection

The PiPER puts a 6-axis arm with a published 0.1 mm repeatability within reach of almost any lab budget. Its teleoperation story is built around CAN, and that shapes everything from leader arms to remote operation.

AgileX PiPER, 6-axis low-cost research arm
AI-generated illustration of the AgileX PiPER. For product photos, see AgileX Robotics.
Degrees of freedom
6
Payload
1.5 kg
Reach
626 mm
Repeatability
0.1 mm
Weight
4.2 kg
Operating temperature
-20 °C to 50 °C
Communication
CAN at a fixed 1 Mbps, through the arm's own USB-to-CAN module
Software
Python SDK (piper_sdk), ROS 1 and ROS 2

Updated

The AgileX PiPER is a 4.2 kg, 6-axis arm with a 1.5 kg payload, a 626 mm reach and a 0.1 mm repeatability spec, listed at $1,999 on AgileX's product page as of October 2026. At that price labs buy them in pairs and fours, for leader-follower rigs and bimanual setups, and PiPER datasets are easy to find on the Hugging Face Hub. Getting good data out of one depends on understanding its CAN-based control, its firmware generations, and which teleoperation path fits your task.

Four ways to drive a PiPER

A second PiPER as the leader (built-in master-slave)

The PiPER firmware has a master-slave mode. Per AgileX's dual-arm guide, you set one arm as the active (master) arm and the other as the slave, connect their CAN lines, and the master sends joint control frames that put the slave into joint control and high-follow mode. No PC is needed in the loop. It is the quickest way to get joint-for-joint teleoperation, and the leader has exactly the follower's kinematics.

AgileX Universal Master Arm (Cartesian leader)

AgileX also sells a dedicated Universal Master Arm: a 0.6 kg, 6-DoF teleoperation device with a 505 mm workspace that maps the operator's 6D pose to the robot through inverse kinematics. It has an integrated CAN module, connects to the host over USB, and lets developers set workspace limits; if a target pose exceeds them, the system halts the arm. It supports PiPER and AgileX's 7-DoF NERO, and AgileX says third-party arms can be added by adapting the robot model and IK solver.

A different leader through LeRobot

One community plugin drives a PiPER follower from an SO-101 leader, mapping the leader's joints onto the PiPER's with sign flips and aliases. It is cheap, but the two arms have different kinematics, so the mapping is an approximation the operator has to learn. LeRobot's third-party list also includes a PiperMate teleoperator plugin built on FashionStar servos.

ROS 2 end-pose commands (3D mouse, VR)

The piper_ros Humble branch accepts joint targets and end-effector poses on separate topics, which is where a SpaceMouse or VR controller would plug in. The README notes that some singular poses cannot be reached with end-effector control, so expect the occasional refused target.

CAN, firmware and other PiPER-specific gotchas

Most PiPER setup problems are CAN problems. The piper_sdk README says the SDK supports only the arm's built-in CAN module, at a baud rate of 1,000,000 that cannot be changed, and the activation helpers are Linux-only. With several arms on one PC, you identify each USB-to-CAN adapter by its USB port and give the interfaces stable names. If a send fails with "Message NOT sent" or error code 100017, the documented fix is to check the connection, power-cycle the arm and reactivate the interface.

Firmware generations matter

AgileX recommends the V3 interface for firmware 1.8-8 and later, and the URDF and DH offset change at firmware S-V1.6-3. A dataset recorded with the wrong model has joint values that do not match the real arm. Write the firmware version into your dataset metadata.

Unplug the leader before scripting the follower

The dual-arm guide warns that the slave arm goes out of control if you run your own control code while the master is still connected, because the master keeps sending it commands. Switching the slave back out of master-slave mode needs a reset.

ROS 2 starts slow

piper_ros runs joint commands at 10% of default speed unless you change it, with speed clamped between 1 and 100. Teams often mistake this for lag.

Limits are off by default

Joint and gripper limits in the SDK are optional and disabled out of the box, and MIT mode (hybrid torque, position and velocity control) carries an explicit warning that misuse can damage the arm. Set limits before an operator ever touches it.

Teleoperating a PiPER from somewhere else

Built-in master-slave is local by nature: the leader talks to the follower over CAN, and a CAN bus does not stretch across the internet. For a remote operator you split the pair. On the operator's side, a PC reads the leader's control frames (the SDK exposes the master's commanded joints and gripper); those targets travel over the network; on the robot's side, a second PC sends them to the follower through the SDK, with its own limits and smoothing. The Universal Master Arm fits the same pattern, since it connects to a host over USB rather than directly to the follower.

The public PiPER dataset we use as a reference below is recorded at 30 fps, so a control step is about 33 ms. That is a tight budget for a remote operator:

Under ~50 ms round trip

One or two steps behind. Fine placement and small-object grasps stay realistic. This usually means an operator in the same metro area or region.

~100 to 200 ms

Three to six steps behind. Pick-and-place, sorting, folding and most tabletop tasks still work if the operator slows down; precise contact suffers first.

Above ~250 ms

Direct teleoperation of fine tasks becomes frustrating. Recording at a lower rate, adding local smoothing, or switching to policy supervision works better.

On the robot side, cap per-step motion (the WeGo plugin exposes a max_relative_target setting for exactly this) so a burst of delayed targets cannot become a jump. Our latency guide covers budgets by task.

LeRobot on the PiPER: two plugins, one forum lesson

LeRobot does not ship a PiPER driver itself. Its third-party robots page lists two drop-in lerobot_robot_piper plugins, and they take different approaches:

WeGo Robotics plugin

Registers piper_follower and piper_leader, so a PiPER leader drives a PiPER follower through the standard teleoperate and record commands. A setup wizard handles up to four arms (including two leaders and two followers for bimanual work), and it ships GUI tools for calibration, health checks and a live teleop monitor. It needs LeRobot 0.3.0 or later.

AgRobotics Research plugin

Registers a piper robot type and demonstrates teleoperation from an SO-101 leader, dataset recording, and ACT deployment through LeRobot's async policy server. Gripper control is off by default. It needs LeRobot 0.4.0 or later.

Bimanual tip: a two-leader, two-follower PiPER station means four CAN adapters on one machine, and Linux will happily renumber them after a reboot or a swapped cable. The WeGo plugin includes a script that writes udev rules pinned to each adapter's USB serial number, so can_leader1 is always the same physical arm. Do this before the first recorded episode, not after a day of mislabeled left and right arms.

A Hugging Face forum thread is worth reading before you train. A user had PiPER recording and replay working, but a fine-tuned smolVLA produced no actions at inference. The server logged a missing observation.language.tokens key and dropped repeated timesteps, and the replies point to two likely causes: no task string in the client payload, and a step counter that never incremented. The general lesson holds for any arm: test the full inference loop on a few episodes before you commit to collecting hundreds.

What PiPER data looks like

A typical example is wego-hansu/piper_pick_yellow_car: 50 episodes, 16,837 frames at 30 fps, two 640×480 cameras, and a 7-value action and state (six joint positions plus the gripper), in LeRobot v3.0 format. That layout is a sensible default. A few PiPER-specific additions make it much more useful:

Units

The SDK reports joints in 0.001 degrees and the gripper in micrometres. Convert once, at record time, and record the convention in the dataset card.

Leader and follower

In master-slave mode, the master's commanded joints are your action and the slave's feedback is your observation. Record both; the gap between them shows tracking error and dropped frames.

A wrist camera

Most public PiPER sets use scene cameras only. At 1.5 kg payload and small grippers, a wrist view helps the policy with the last centimetre of a grasp.

Firmware and URDF version

As above: the joint model changed between firmware versions, and you will want to know which one each episode used.

Our data collection guide covers episode structure and quality checks.

What a good PiPER operator does

Respects the 1.5 kg payload, counting the gripper and any fixture, and slows down with heavier objects rather than letting the arm sag through a move.
Keeps the leader and follower starting from the same pose, so the follower does not lurch when master-slave mode engages.
Notices CAN dropouts quickly. A follower that stops responding usually needs its interface reactivated, not a restart of the whole session.
Uses one grasp strategy across the dataset, and labels failures honestly.
Reports a gripper reading that looks wrong in visualization. The ROS 2 README notes RViz gripper values need a factor of 2 because of a unit difference, and that kind of mismatch is easy to bake into data.

PiPER, SO-101 or xArm?

The SO-101 is the usual entry point for LeRobot work; the PiPER is the step up when you want a published repeatability figure (0.1 mm) and a 1.5 kg payload. The xArm 6 is the next step after that: a heavier arm with more payload, Ethernet control and an industrial-style controller, at a higher price. AgileX also lists a PiPER-X and the 7-DoF NERO; check the CAN and SDK compatibility before mixing them with PiPER data.

How RoboPilots runs PiPER teleoperation

Your arms stay in your lab. We agree the input device with you (a PiPER leader, the Universal Master Arm, or another leader you already use), split the pair across a VPN with limits on the robot side, and train a dedicated group of operators on your units and your task protocol before any episode counts.

One-week trial

A short run sets the number that matters: clean episodes per operator hour at your latency. If a task needs an operator closer than we can provide, you hear that during the trial.

Coverage

Shifts across time zones, including US Pacific hours. Low-cost arms make multi-arm stations practical, and we staff them that way when the task allows.

Data

Episodes labeled by task and outcome, with firmware and unit conventions recorded, delivered as LeRobot, RLDS or HDF5.

Interfaces, specs and sources

  • piper_sdk (Python over CAN)
  • piper_ros (ROS 2 Humble) + MoveIt
  • Built-in master-slave leader mode
  • AgileX Universal Master Arm
  • LeRobot community plugins

Specs are the maker's published figures, checked on . RoboPilots is not affiliated with AgileX Robotics; product names are trademarks of their owners.

Frequently asked questions

How do you teleoperate an AgileX PiPER?
The simplest way is the built-in master-slave mode: set one PiPER as the master, the other as the slave, connect their CAN lines, and the slave follows joint for joint. AgileX also sells a Universal Master Arm that drives the PiPER through 6D pose mapping and inverse kinematics.
Does LeRobot support the PiPER?
Through community plugins, not a built-in driver. LeRobot's third-party page lists two lerobot_robot_piper plugins: one from WeGo Robotics with PiPER leader and follower types for up to four arms, and one from AgRobotics Research that works with an SO-101 leader.
How much does the AgileX PiPER cost?
The PiPER is listed at $1,999 on AgileX's own store as of October 2026. A leader-follower pair needs two arms, or one arm plus a separate leader device.
Does the PiPER work with ROS 2?
Yes. AgileX's piper_ros repository has a Humble branch for Ubuntu 22.04 with control, description, message, MoveIt and simulation packages. It accepts joint targets and end-effector poses on separate topics.
Can I control the PiPER from a Mac or with any CAN adapter?
The SDK officially supports only the arm's own CAN module at a fixed 1 Mbps, and its CAN activation tools are Linux-only. Plan on a Linux PC next to the arm.
Quote operators for your PiPER