Quickstart

Connect a Bimanual YAM to hosted pi0.5.

Before you start

You need:

• A calibrated Bimanual YAM
• Local configuration files for each arm (Servo hashes these into an immutable hardware fingerprint; placeholder files work for testing)
• A zero-argument function in your robot application that opens its calibrated YAM runtime (see the Robots guide for the complete interface and reference implementation)
• Your Servo control-plane URL
• Hosted access enabled for your Servo organization

The Robots guide lists the runtime methods and fields Servo recognizes.

Install and sign in

Install the client on the robot computer:

pip install 'servo-client>=0.4,<0.5'
export SERVO_BASE_URL="https://<your-servo-control-plane>"

servo login opens a browser for interactive authentication. On a headless robot computer (for example, over an SSH session without a graphical browser), generate an API key on your development machine and export it on the robot:

# On your development machine:
servo login
servo key create --label yam-cell-01

# On the robot computer:
export SERVO_API_KEY="sk_servo_..."

SERVO_API_KEY authenticates the Python process and CLI commands without requiring an interactive browser login.

Register the robot

Use a stable name for the physical rig. Pass the left arm configuration file first and the right arm configuration file second:

servo robot setup yam-cell-01 \
  --config /opt/yam/configs/yam_left.yaml \
  --config /opt/yam/configs/yam_right.yaml \
  --region us-west-2 \
  --site sf-lab \
  --label line=assembly

--config accepts the hardware configuration files that your robot runtime uses on disk (generated during arm zeroing and motor calibration). If you are testing or running without physical hardware, generate placeholder files with:

mkdir -p /opt/yam/configs && touch /opt/yam/configs/yam_left.yaml /opt/yam/configs/yam_right.yaml

Servo hashes their contents to record an immutable hardware revision fingerprint; it does not parse or upload either file.

--region records the robot’s location using a familiar AWS region code. Choose the nearest region, such as us-west-2, us-east-1, eu-west-1, or ap-northeast-1. Servo treats the code as the robot’s location and chooses the underlying compute.

Setup returns a stable rob_* ID. The configuration files stay on the robot computer.

List the hosted models that work with this robot:

servo model list yam-cell-01

Run pi0.5

Export the zero-argument function your robot application already uses to open its calibrated YAM RobotEnv. Each call to robot.check() or robot.run() opens a fresh environment and closes it when the call finishes:

import os

import servo
from my_robot_app import open_yam

sv = servo.Servo(
    base_url=os.environ["SERVO_BASE_URL"],
    api_key=os.environ["SERVO_API_KEY"],
)

robot = sv.robots.attach("yam-cell-01", runtime=open_yam)
model = sv.models.get("pi0.5")
deployment = model.deploy(robot=robot).wait(timeout_s=900)
policy = deployment.policy(
    robot,
    instruction="place the red lid on the black box",
)

check = robot.check(policy)
print(check.completed, len(check.chunks), check.steps)

timeout_s=900 allows the client to wait for up to 15 minutes. wait() returns as soon as the endpoint is ready.

robot.check() makes two hosted inference requests without calling the runtime’s actuator method. A completed report confirms that Servo received three camera frames and 14 joint values and that the selected model returned valid actions.

report = robot.run(policy, seconds=120)
print(report.completed, len(report.chunks), report.steps)

robot.run opens the local devices, maintains the hosted session, applies validated joint targets, and closes the devices at the end of the run.

Servo rejects malformed or expired action rows. When a measured action-jump limit exists for the selected model and robot, Servo enforces it. The YAM controller remains responsible for motor limits and emergency-stop behavior.

model.deploy() creates hosted capacity and returns a stable deployment.id. Save that ID and use sv.deployments.get(deployment_id) on later runs. Review active deployments with servo deployment list, and stop unused capacity with servo deployment stop <deployment-id>.

For several robots, share managed capacity through Robot fleets.