Run Policy

Run Policy executes a trained policy on the robot autonomously: it streams the robot’s joint positions and camera frames to the policy, which returns action chunks that drive the arms. It runs on the same machine as data collection — the computer wired to the robot with the ZED cameras attached. By default, inference runs locally on that machine. Optionally, it can be offloaded to a more powerful machine on the network (e.g. a desktop with a discrete GPU): the robot machine sends observations over gRPC and receives actions back. You can launch a rollout from the web control panel or the CLI (axol run-policy).

Before you start

Axol installed (one-command install), CAN up, and motors verified.
The ZED cameras the policy was trained on connected (at least one), with their serials on hand — see the Data Collection tip for listing them.
A trusted trained checkpoint and any existing rollout dataset you append to that you created or obtained from a source you trust (local path or HuggingFace repo), plus the checkpoint’s policy type (act, smolvla, pi0, …). Upstream model deserialization and dataset parsing are not sandboxed. Assign the same cameras, and use the same camera resolution, stereo setting, and fps the policy was trained on.
For local GPU inference, a CUDA-capable PyTorch install — or offload to a remote server (below). The hosted aarch64/Jetson install deliberately receives PyPI’s CPU-only Torch 2.10 build; use an explicitly managed JetPack-compatible Torch + Torchvision build, select a remote server, or pass --device cpu. Axol’s hosted updater will not overwrite an existing custom/CUDA build.

Run it

Control Panel
CLI

Connect the robot and assign cameras

Connect the Axol Host and Axol, then assign the cameras the policy was trained on under Axol settings → Cameras (at least one). See Cameras.

Select Run Policy and fill the fields

Pick Run Policy. Set the policy path, policy type, and task description — the per-run inputs. Remote inference (server host/port), aggregation, and chunking now live in the Settings Inference tab.

Start and control rollouts

Press Start, then use the Episode control box that appears:

Button	Effect
Start episode	Begin the next rollout.
Save	Save the current episode and return to the reset gate.
Discard	Drop the current episode. Because a failed rollout usually leaves the arms somewhere they shouldn’t be, they go limp for hand-repositioning instead of driving home from that pose — clear them of the scene, then Return to rest.
Return to rest	Send the limp arms home, replanning the collision-aware return from wherever they were left. Appears after a Discard (limp cleanup), when the guarded between-episode return meets resistance, or when the opt-in rollout contact stop aborts an episode (a Contact hold).

To end the run, press Stop in the card header.

On the robot machine:

axol run-policy \
    --policy_path myorg/pick-place-policy \
    --policy_type act \
    --task "Pick the red cube" \
    --robot_config.cameras "{overhead: {serial: 41234567}, left_arm: {serial: 41234568}, right_arm: {serial: 41234569}}"

A PolicyServer child process is launched on localhost; the parent streams observations to it and applies the returned action chunks. For CPU inference add --device cpu. Replace the serials with your cameras’ — assign the same cameras the policy was trained on (at least one; omitted slots are dropped). The cameras dict is one inline YAML value — see Command configuration.Control the rollout from stdin in the run-policy terminal:

Key	Action
`s`	Save the rollout and end the episode
`r`	Discard the episode — the arms drop limp for hand-repositioning; clear them, then press Enter to return to rest and re-record
`q`	Discard and quit

See run-policy for aggregation, chunking, and dataset-saving fields.

--episode_time_s is a safety cap (default 120 s) that falls back to the same save / discard / quit prompt if no key is pressed. If a dataset repo is supplied, each saved episode is appended to a LeRobot-format dataset. Between episodes the arms return to the rest pose via a collision-aware IK trajectory — guarded: if a joint’s torque strays from the gravity model for a sustained window (something still grasped, or a person grabbing an arm) the move stops where it is and the arms drop into a limp gravity-compensation hold. Free them by hand, then continue (Enter on the terminal, Return to rest on the control panel) to replan from wherever they were left. Tune with --reset_torque_threshold (default 4.0 Nm; 0 disables the watchdog) or the control panel’s Reset contact threshold. You can also arm a watchdog for the rollout itself — while the policy is driving the arms. It’s off by default (a policy pushes on the scene on purpose): set --policy_torque_threshold (the control panel’s Policy contact stop; suggested 16 Nm) and a sustained torque past the threshold aborts the episode — nothing is saved — and drops the arms limp. Clear them by hand, then continue (Enter / Return to rest) to return to rest and start the next attempt. Discarding an episode uses that same limp hold up front: because a bad rollout usually leaves the arms somewhere they shouldn’t be, they go slack for hand-repositioning first, so you untangle them by hand rather than dragging them home from a failed pose — then return to rest replans from where you left them.

Rollout execution stays smooth on any inference hardware. Every command the policy produces is shaped by the same velocity/acceleration profile teleop and all training data go through, so a slow or bursty inference platform decelerates the arms to a brief hold and ramps back out instead of jerking at chunk boundaries. The shaping knobs (--exec_max_vel, --ensemble_blend_s, --align_fade_s) are in the run-policy reference.

Offload inference to a remote server (optional)

Start the inference server on the GPU machine

The inference server runs on the GPU machine from the CLI — it isn’t one of the control panel’s operations. With the lerobot extra installed there:

axol inference-server --host 192.168.1.99

Replace the example with the inference machine’s exact LAN IP, or omit --host to use the default 0.0.0.0 (all interfaces). It listens on port 8765 until Ctrl+C. See inference-server.Use remote inference only across an isolated trusted network (or authenticated VPN), with a host firewall allowing the robot IP alone. Axol replaces LeRobot 0.6’s pickle transport with bounded, versioned messages, but gRPC still has no TLS/client authentication: a peer can request checkpoint loads or impersonate the server and return arbitrary robot actions, so shared or untrusted networks remain unsafe.

Point Run Policy at it

On the robot machine, run Run Policy exactly as above but pointed at the server’s address:

Control Panel
CLI

In the Settings Inference tab, set the server host to the GPU machine’s address (e.g. 192.168.1.99) and Save, then press Start in the Run Policy panel.

Add --server_host:

axol run-policy \
    --policy_path myorg/pick-place-policy \
    --policy_type act \
    --task "Pick the red cube" \
    --server_host 192.168.1.99 \
    --robot_config.cameras "{overhead: {serial: 41234567}, left_arm: {serial: 41234568}, right_arm: {serial: 41234569}}"

The server downloads the policy itself, so --policy_path must be reachable from it (e.g. a HuggingFace Hub repo ID).

Get Started

Operations

Mantis

Remote Teleop

Web Interfaces

Advanced

Before you start

Run it

Offload inference to a remote server (optional)

Next steps

Data Collection

run-policy reference

​Before you start

​Run it

​Offload inference to a remote server (optional)

​Next steps

Data Collection

run-policy reference

Before you start

Run it

Offload inference to a remote server (optional)

Next steps