Which Robotic Arms Support ACT Imitation Learning with LeRobot?

Seeed reBot Arm B601 supports ACT imitation learning with LeRobot through Seeed’s documented integration; this guide follows the B601-RS workflow. Its robot adapter connects state feedback and action commands to LeRobot, while cameras provide visual observations for learning. That makes reBot a practical choice for developers who want a documented path from teaching a task to running a trained policy. SO-101 is another documented LeRobot arm option. When choosing an arm, check its adapter, observation and action interfaces, calibration, and demonstration workflow. For reBot, Seeed provides a B601-RS integration guide and course chapters covering data collection, ACT training and real-robot evaluation. Match the exact arm variant and software environment to those guides before starting.

Which Arms Have a Documented LeRobot ACT Workflow?

Two documented options to consider are reBot Arm B601-RS and SO-101. Their integration paths differ, so compare the complete workflow rather than treating “LeRobot compatible” as a guarantee that any software installation will work.

Robotic arm	Documented path	What to check
Seeed reBot Arm B601-RS	Seeed’s robot integration and Physical AI course connect data collection, ACT training and real-robot execution.	Follow the RS configuration, matching CAN interface, calibration and Seeed-documented environment.
SO-101	Hugging Face documents the arm setup and uses SO-101 in its real-robot imitation-learning tutorial, including ACT training.	Follow the SO-101 hardware setup and the matching upstream tutorial.

What Is ACT?

ACT stands for Action Chunking with Transformers. It learns from demonstrations that pair observations with actions. Given camera images and robot joint state, the policy predicts a sequence of future actions—a chunk—rather than only the next action. The controller executes actions according to the deployment configuration, then uses new observations for subsequent predictions. See the Hugging Face ACT documentation.

ACT maps visual observations and joint state to an action chunk. Source: Seeed Studio Wiki

For example, a demonstration might show an arm approaching a block, closing its gripper, moving to a tray and releasing. The training data must represent those stages consistently. A task label describes the recording; it does not by itself turn ACT into a language-conditioned vision-language-action model.

The original ACT project is useful for understanding the method’s research background. For a reBot implementation, follow the hardware-specific course and integration guide.

How to Choose an ACT-Compatible Robotic Arm

Treat compatibility as a complete data-and-control path. Ask for evidence at each point:

Selection criterion	Evidence to look for	Why it matters
Robot adapter	A maintained integration that reads robot state and sends actions	A policy must be able to observe and control the arm.
Demonstration method	A documented leader/follower or other supported teleoperation workflow	You need a repeatable way to record the task.
Camera and dataset support	Defined image keys, robot-state features, actions and timing	Training and execution must agree on what each input and output means.
Calibration and control	Joint mapping, gripper behavior, limits and a controlled motion check	Incorrect hardware mapping cannot be fixed by a longer training run.
Software identity	Repository revision, adapter packages and compatible dependencies	Commands from different versions may use different APIs.
Task fit	Reach, gripper, workspace and other requirements checked against the exact hardware	Software compatibility alone does not establish suitability for a particular task.

This checklist is a selection aid based on the interfaces described in Seeed’s LeRobot architecture chapter. Use the selected arm’s hardware documentation to verify physical requirements.

Why Use Seeed reBot for ACT Imitation Learning?

The strongest reason to consider reBot is its documented implementation path. You can inspect the B601 follower integration, prepare the hardware, record demonstrations, train ACT and evaluate a saved policy within one course sequence.

That is useful when your goal is to learn where a robot-learning experiment succeeds or fails. The B601-RS Quick Start covers hardware preparation; the course then connects calibration, cameras, data and policy execution. You can trace a problem back to a concrete stage instead of treating every failure as a model problem.

For the RS path, the integration guide specifies Seeed’s LeRobot repository and the robot, teleoperator and MotorBridge packages. Use that environment as a unit. The recommendation here is based on this documented learning and development workflow, not a comparative hardware benchmark.

How to Train and Run ACT on reBot Arm B601-RS

The following templates assume the RS environment is installed and working. Replace dataset names, the CAN port, robot ID and camera configuration with your own verified values. These commands have been reviewed against the documentation; they have not been executed on a robot for this article.

1. Prepare the Arm and Record Demonstrations

Complete the calibration and teleoperation chapter before collecting training data. Confirm that the follower moves correctly and that the gripper behaves as expected. Follow the hardware guide’s mounting, power and stopping procedure for supervised motion.

Your recording and inference configurations better use the same actual views. Source: Seeed Studio Wiki

Then use the camera and data-collection chapter to record one clearly defined task. For a first experiment, a useful example is moving a particular block into a tray, releasing it and ending in a defined pose. This is a proposed task definition, not a reported demonstration result.

Keep camera names, viewpoints and settings consistent. The course documents both single- and dual-camera workflows; the inference template below assumes a dataset recorded with the same front and side views. Inspect complete episodes, video and metadata using the dataset-quality chapter before training.

Inspect both camera views before training. Source: Seeed Studio Wiki

2. Start an ACT Training Run

In the environment prepared from the RS guide, check GPU availability for this CUDA training example:

python -c "import torch; print(torch.cuda.is_available())"
nvidia-smi

Adapt the Chapter 16 ACT training command to your recorded dataset:

lerobot-train \
  --dataset.repo_id=YOUR_NAMESPACE/YOUR_DATASET \
  --policy.type=act \
  --policy.device=cuda \
  --output_dir=outputs/train/act_rebot_task_v1 \
  --job_name=act_rebot_task_v1 \
  --batch_size=4 \
  --steps=100000 \
  --wandb.enable=false \
  --policy.push_to_hub=false

Replace YOUR_NAMESPACE/YOUR_DATASET with the dataset you recorded. The batch size and step count shown are example settings, not universal requirements. Adjust the batch size to available GPU memory and review the course’s training guidance before changing optimization settings.

Monitor loss and GPU status, and keep the run’s configuration and checkpoints identifiable. Training loss is evidence about optimization; selecting a checkpoint still requires a task-level test. Chapter 16 explains checkpoint management and resuming a saved run.

3. Load the Checkpoint on the Real Arm

Seeed’s Chapter 17 RS workflow uses lerobot-record with a policy checkpoint. Keep the robot and camera configuration consistent with data collection:

lerobot-record \
  --robot.type=seeed_b601_rs_follower \
  --robot.port=can0 \
  --robot.can_adapter=socketcan \
  --robot.id=follower1 \
  --robot.cameras='{"front":{"type":"opencv","index_or_path":0,"width":640,"height":480,"fps":30,"fourcc":"MJPG"},"side":{"type":"opencv","index_or_path":2,"width":640,"height":480,"fps":30,"fourcc":"MJPG"}}' \
  --dataset.repo_id=YOUR_NAMESPACE/eval_act_rebot_task_v1 \
  --dataset.single_task="Place the block in the tray" \
  --dataset.num_episodes=10 \
  --dataset.episode_time_s=60 \
  --dataset.reset_time_s=10 \
  --policy.path=outputs/train/act_rebot_task_v1/checkpoints/last/pretrained_model \
  --display_data=false \
  --policy.push_to_hub=false

Use the same calibrated robot ID and the actual CAN interface for your arm; can0 and follower1 are examples. The camera indices, resolutions and task text must match your experiment. Confirm that --policy.path points to the checkpoint you intend to evaluate. The episode count and timings are example test settings.

The inference diagram connects observations, preprocessing, ACT prediction, action conversion and execution. Source: Seeed Studio Wiki

4. Evaluate and Improve the Dataset

Define task success before testing. Record every trial, including interventions and failures, along with its checkpoint and starting conditions. Compare successful autonomous trials with all trials started under that protocol. Keep tests with changed objects or camera views separate from repeatability tests.

If the arm moves incorrectly, first check configuration, calibration and preprocessing. If the setup is consistent but a particular grasp or position repeatedly fails, inspect that part of the demonstrations and collect targeted examples. Retest under the same conditions after changing the data. Use a short evaluation record to keep each iteration comparable:

Record	What to save
Task	Starting conditions and the required physical outcome
Run	Dataset, checkpoint and software revision
Setup	Arm variant, calibration, cameras and execution settings
Outcome	Success, failure or intervention, with video and a reason

FAQ

Does ACT Require a Special “ACT Arm”?

ACT is a policy, so the practical requirement is a working observation, action and demonstration pipeline. A documented adapter and consistent data are more informative than an “AI-ready” label. Use the compatibility checklist above for a new arm.

Is reBot the Only Arm That Can Use ACT with LeRobot?

No. SO-101 is another documented option in Hugging Face’s real-robot tutorial. This article focuses on the B601-RS implementation because Seeed provides the corresponding integration and course path.

Can I Use B601-RS Commands for B601-DM?

Use the configuration for your variant. Seeed’s architecture chapter distinguishes the motor and CAN communication paths, and Chapter 17 gives separate inference examples. Do not assume the RS robot type, port and adapter values apply to DM.

How Many Demonstrations Do I Need?

There is no task-independent count that guarantees success. Start with a narrow task, inspect the recordings and use repeated evaluation failures to identify missing examples. Demonstration quality and coverage matter alongside quantity.

Does Lower Training Loss Mean the Task Is Solved?

No. Checkpoint selection needs real-task evaluation with defined outcomes and recorded failures. A successful clip or a falling loss curve alone does not establish reliable task completion.

Start Your reBot ACT Workflow

Have a working setup? Open Chapter 16 to train your first ACT policy, then continue to Chapter 17 for real-robot evaluation.

Selecting hardware? Review the reBot Arm B601-RS configuration and check the selected bundle, teleoperation equipment, cameras and host requirements against the integration guide.

For discussion, share your arm variant, software revision, dataset setup and one reproducible failure in the Seeed Studio Facebook Group or Discord Channel. That gives the community a concrete experiment to discuss.

About Author