Live runtime today
Exactly what runs on real infrastructure right now, how to reach it, and what is still served by test mode.
Everything on this site documents the full contract. Most of it is served today by test mode: simulated robots, real statistics. This page is the honest inventory of the live runtime, the Go control plane that schedules real cells, records evidence and scores outcomes independently of the policy. It is updated as capabilities land.
What is live
| Capability | Status |
|---|---|
| Submit a run with a reference policy on the tasks below, 1 to 20 episodes | Live |
| Exclusive cell allocation, durable queue, idempotent retries, cancellation | Live |
| Operator-confirmed reset before every episode, with recorded initial conditions | Live |
| Independent scoring from recorded observations, never from the policy's own claim | Live |
Result with n, success_rate, a fixed-n Wilson 95% interval (two or more scored episodes), published denominators and per-episode evaluations | Live |
robot_hours and environment_hours from recorded intervals, plus per-episode operator and execution minutes | Live |
| Five hashed artifacts per run (commands, telemetry, events, MCAP, manifest) behind authenticated downloads | Live |
Per-episode camera video (episode-NNN.<camera>.mp4, frame receipts on the MCAP camera channel) | Live for cells with cameras; the simulation cell records synthetic frames |
Live view of a cell camera (GET /v1/streams/{cell}?camera=top, MJPEG for an <img> tag or a JPEG snapshot with Accept: image/jpeg) | Live for cells with cameras; frames come straight from the cell's camera owner, stamped with capture time |
Console API keys (rbr_live_) authenticated through operator-written grants | Live |
| Ground-truth object poses, LeRobot and RLDS export | Test mode only |
| Container, checkpoint and endpoint policies | Test mode only |
auto(ci, moe) sizing, perturbation schedules, budgets, quotes, suites, gates, matrix, threshold, compare, transfer | Test mode only |
| Dollar pricing | Not metered; the two meters are reported in hours |
Tasks on the live catalogue
| Task | Environment | Reference policy | Scored by |
|---|---|---|---|
place-die@1 | dice-mat@1 | dice-place-reference@1 | Planar object observations from the trusted recorder: the die must finish settled inside the target zone |
pick-up-die@1 | dice-floor@1 | dice-pickup-reference@1 | Object lift and hold from fixture observations |
Both tasks run today on simulation cells with an explicitly simulated: true
result. Physical cells are refused before queueing until the installed
calibration, camera-to-arm registration and guarded executor exist; the
result never claims physical reliability it did not measure.
Statuses
Public runs report the contract's status, with the exact runtime state beside
it in execution_status and a phase where the status alone is not enough.
status | phase | execution_status | Meaning |
|---|---|---|---|
queued | queued | Accepted; no cell allocated yet | |
scheduling | dispatching | Cell allocated; the host is being reached | |
running | reset_wait | reset_required | Waiting for the operator's readiness attestation before the next episode |
running | executing | running | An episode is executing |
running | cancelling | cancelling | Cancellation requested; the cell has not yet verified a stop |
reconciliation_required | unknown or resolving | same | Execution outcome is uncertain; an operator must inspect the cell. Not terminal, never presented as stopped |
completed | completed | Every episode finished; read result once artifact_status is available | |
stopped | cancelled | cancelled | The cell verified a stop after cancellation; scored episodes stay scored |
failed | failed, expired or interrupted | same | The run ended without completing; the phase says why |
The SDKs' result() raises for stopped, failed and
reconciliation_required rather than fabricating a result. run.watch()
streams the same transitions as server-sent events, replaying the durable
history for late subscribers and resuming after Last-Event-ID; the stream
ends once the run is terminal and its evidence has settled.
Reaching it
The live runtime is hosted for design partners and is not the public sandbox host. Both SDKs already support the override:
export ROBORAMA_API_KEY=rbr_live_... # from the console, with a grant
export ROBORAMA_BASE_URL=https://<runtime host you were given>from roborama import Client, Policy
client = Client(mock=False)
run = client.runs.create(
robot="<cell>-robot@1", # from GET /v1/tasks
environment="dice-mat@1",
task="place-die@1",
policy=Policy.reference("dice-place-reference@1"),
episodes=10,
interventions="none",
idempotency_key="my-first-live-run", # persist before submitting
)
result = run.result(timeout=3600)
print(result.n, result.success_rate, result.ci95, result.robot_hours)A rbr_live_ key against the sandbox host returns 403 live_key_on_sandbox,
and a rbr_test_ key against the runtime is refused, so the two can never be
confused. Runs wait in reset_required until a local operator confirms the
fixture; customer code cannot acknowledge readiness.
Disclosure
- The live embodiment is a Waveshare RoArm-M2-S, a four-axis engineering testbed. It proves the control plane; it is not the pilot embodiment and it does not represent a premium robot-hour tier.
- Until the physical executor is installed, the live tasks run on simulation
cells and every record says
simulated: true. The scorer, statistics, artifacts and meters are the same code paths a physical cell will use. - Nothing is metered in dollars.
robot_hoursandenvironment_hourscome from recorded intervals; null means unobserved, never zero. - Every episode waits for a local operator's readiness attestation, recorded with initial conditions. Customer code cannot acknowledge a reset.
Reading this site
Pages that describe capabilities outside the table above carry a Test mode today marker. The request and response shapes on those pages are the contract the runtime is converging on; the sandbox serves them now so integrations can be written ahead of the hardware.