> ## 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.

# First motion

> Preflight without motion, run a guarded 30-second episode, and stop the deployment.

You have an action chunk from the [quickstart](/quickstart). This page ends with a recorded 30-second episode on the robot computer and a stopped deployment.

## Before the arm moves

Keep the hardware stop within reach for every run on this page, and clear the space around both arms.

<Warning>
  **Before the arm moves.** Setup recorded a rest pose. Every run returns the arms to it on every ending: the time budget, a guard abort, a lost connection, or Ctrl-C. A check sends nothing and leaves the arms where they are. Torque is turned off only at rest, never mid-air.
</Warning>

## Preflight without motion

Reconnect to the deployment and let Servo observe and infer for ten seconds without sending anything to the arms:

```python robot computer theme={null}
import servo

sv = servo.Servo()
robot = sv.robots.attach("yam-cell-01")
model = sv.models.get("hf://allenai/MolmoAct2-BimanualYAM")

deployment = model.deploy()
deployment.wait(timeout_s=900)
session = deployment.start(robot, instruction="pick up the red cup")

report = session.check(robot, seconds=10)
print(report.guard, report.first_step_jump_max)
```

`deploy` returns the deployment you kept, or starts it again if you stopped it. `start` returns the open session for this robot and instruction, or opens one. `check` runs the whole path except the last step and reports the guard it would use. The guard limits how far the first row of a new chunk may sit from the arm's current, freshest observed pose, and a chunk beyond it ends the run instead of lunging.

`guard` is `armed` when the model and arm pair has a measured bracket, `not armed` when nobody has measured one, and `supplied` when you pass your own. When it is not armed, run `check` for a minute, read `first_step_jump_max`, and pass a bracket a little above it to `run` as `max_jump`. The bracket is in the action space's own units, and a healthy run stays inside it.

The guard only checks the first row of each new chunk; every row sent is also held under `max_relative_target`, a continuous per-second clamp on how far one command may move from the arm's last observed state. Each robot type ships a default; pass your own to `run` when you need it tighter.

## Run a bounded episode

Run one episode, bounded by wall-clock time:

```python robot computer theme={null}
report = session.run(robot, seconds=30)
print(report.steps, report.aborted or "completed", report.episode)
```

A 30-second run's step count still depends on round-trip latency that run, so two such runs are not directly comparable on `report.steps`.

Bound by chunk count instead for a step count that stays fixed across robots or code changes:

```python robot computer theme={null}
report = session.run(robot, chunks=40)
print(report.steps, report.aborted or "completed", report.episode)
```

Pass both to stop at whichever bound comes first. The run also ends on the first guard abort, a lost connection, or Ctrl-C, and the arms return to rest each time. Servo asks for the next chunk while the current one plays and blends a short window across the switch instead of cutting over on the row, so the arm neither pauses nor jerks at a boundary. A send that fails to reach the arm retries automatically before the run aborts. The report carries the executed steps and seconds, why it ended, round-trip and boundary-gap latency as percentile maps, and the rate to use next time. Pass `on_chunk` to see each chunk's round trip and server time as it arrives.

Every run is recorded to the path in `report.episode`: the exact frames and state the model saw, the chunks it returned, and per-chunk timing. On the robot computer, `servo episode show --last` summarizes the newest recording, and `record=False` skips recording a run.

## Stop the deployment

Stop it from your computer, which also ends the session:

```bash your computer theme={null}
servo deployment stop --model hf://allenai/MolmoAct2-BimanualYAM
```

Stopping a deployment ends its sessions, and closing a session never stops the deployment.

## You now have

* A `RunReport` with `steps`, `aborted`, `round_trip_ms`, and `boundary_gap_ms` (each a percentile map).
* A recorded episode at the printed path: `servo episode list` shows it.
* No deployment left running: `servo deployment list` is empty.

## Next

<CardGroup cols={2}>
  <Card title="Keep your own loop" icon="rotate" href="/guides/your-loop">
    The two calls under `run`, and a session that keeps its connection.
  </Card>

  <Card title="Choose a model" icon="cube" href="/guides/models">
    Private buckets, revisions, and what the checkpoint expects.
  </Card>
</CardGroup>