> ## Documentation Index
> Fetch the complete documentation index at: https://servo.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 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](/guides/robots) for the complete interface and reference implementation)
* Your Servo control-plane URL
* Hosted access enabled for your Servo organization

The [Robots guide](/guides/robots) lists the runtime methods and fields Servo recognizes.

## Install and sign in

Install the client on the robot computer:

```bash theme={null}
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:

```bash theme={null}
# 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:

```bash theme={null}
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:

```bash theme={null}
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:

```bash theme={null}
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:

```python theme={null}
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.

```python theme={null}
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](/guides/fleet-deployment).