First motion

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

You have an action chunk from the 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.

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.

Preflight without motion

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

robot computer

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:

robot computer

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:

robot computer

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:

your computer

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

Keep your own loop

The two calls under run, and a session that keeps its connection.

Choose a model

Private buckets, revisions, and what the checkpoint expects.