Documentation

The package-first workflow lives in open-source runrobot. Start here if you want the same policy package to run locally, in the browser, in headless validation, and on a robot before it reaches hosted evaluation.

my-policy/
  policy.yaml
  robot.yaml
  scene.yaml
  validator.py

1. Export your policy into the runrobot package contract.
2. Validate the package locally before it reaches shared evaluation surfaces.
3. Run the same package in the browser, in simulation, and on the robot.
4. Publish the exact package to RunRobot Cloud or an on-prem deployment of RunRobot Cloud.
5. Collect human preference data on the hosted package and land on the leaderboard.

Public URL patterns

Public browser runs are URL-based. Single-asset pages fill in missing defaults. Explicit run URLs pin the policy, robot, and scene.

https://runrobot.sh/<owner>
https://runrobot.sh/<owner>/<asset>
https://runrobot.sh/<owner>/<policy>/<robot>/<scene>

Open a published policy in the browser

You do not need an API call to run a published policy. Build the canonical URL, open it in a browser, and the simulator page does the rest.

import Runrobot from "runrobot";

const client = new Runrobot({ auth: process.env.RUNROBOT_API_TOKEN ?? "YOUR_RUNROBOT_API_TOKEN" });
const url = client.buildRunUrl({
  owner: "amazon",
  policySlug: "php-parkour",
  robotRef: "unitree/G1",
  sceneRef: "chasebrignac/parkour",
});

console.log(url);

Use buildRunUrl() when you want a browser run URL. buildUrl() still works for generic manifest or asset URLs.

Publish a scene GLB

Upload a GLB, get a public scene manifest back, then combine it with a policy and robot by URL or by defaults.

import { readFile } from "node:fs/promises";
import Runrobot from "runrobot";

const client = new Runrobot({ auth: process.env.RUNROBOT_API_TOKEN ?? "YOUR_RUNROBOT_API_TOKEN" });
const scene = await client.publishScene({
  title: "My Scene",
  glb: new Blob([await readFile("./scene.glb")], { type: "model/gltf-binary" }),
});

console.log(client.buildUrl(scene));

Get a URL of any robot or policy in your scene in seconds

Publish a MuJoCo robot bundle

Robot bundles are zipped MuJoCo assets with an entry XML. Published robots can then be pinned into explicit run URLs.

import { readFile } from "node:fs/promises";
import Runrobot from "runrobot";

const client = new Runrobot({ auth: process.env.RUNROBOT_API_TOKEN ?? "YOUR_RUNROBOT_API_TOKEN" });
const robot = await client.publishRobot({
  slugPath: "my-g1", title: "My G1", robotKey: "unitree-g1",
  bundle: new Blob([await readFile("./robot.zip")], { type: "application/zip" }),
});

console.log(client.buildUrl(robot));

Publish a browser-native policy artifact

The hosted API accepts ONNX policies plus the current runtime adapter config. Easily package policy workflows in our open-source runrobot, you can use to publish policies with RunRobot Cloud.

import { readFile } from "node:fs/promises";
import Runrobot from "runrobot";

const client = new Runrobot({ auth: process.env.RUNROBOT_API_TOKEN ?? "YOUR_RUNROBOT_API_TOKEN" });
const policy = await client.publishPolicy({
  slugPath: "my-policy", title: "My Policy", runtimeAdapter: "onnx_metadata_v1",
  model: new Blob([await readFile("./policy.onnx")]),
});

console.log(client.buildUrl(policy));

Use onnx_metadata_v1 for policies.

Generate a scene from an image

SceneGen jobs are asynchronous. Start a job with an image and boxes, then poll the job URL until the published scene is ready.

import { readFile } from "node:fs/promises";

const form = new FormData();
form.set("slugPath", "my-generated-scene"); form.set("title", "My Generated Scene");
form.set("boxes", JSON.stringify([{ x: 80, y: 60, width: 320, height: 240 }]));
form.set("image", new Blob([await readFile("./scene.jpg")], { type: "image/jpeg" }), "scene.jpg");
const response = await fetch("https://runrobot.sh/api/scenegen/jobs", { method: "POST", headers: { Authorization: `Bearer ${process.env.RUNROBOT_API_TOKEN ?? "YOUR_RUNROBOT_API_TOKEN"}` }, body: form });
console.log((await response.json()).job.id);

Run an arena evaluation

Arena is a hosted evaluation surface built on published runs. Launch a matchup only after your policies are already runnable in the browser.

const { matchup } = await fetch("https://runrobot.sh/api/arena/launch", { method: "POST" }).then((r) => r.json());
console.log(matchup.left.browserUrl);
console.log(matchup.right.browserUrl);

Vote and read the leaderboard

Leaderboard data is aggregate evaluation output. Use it after you already have published policies and completed arena votes.

await fetch("https://runrobot.sh/api/arena/vote", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ matchupId: "matchup_123", winner: "left" }),
});
console.log(await fetch("https://runrobot.sh/v1/leaderboard").then((r) => r.json()));

Read the aggregate leaderboard only

Use the public leaderboard endpoint when you only need aggregate standings and not the underlying arena workflow.

console.log(await fetch("https://runrobot.sh/v1/leaderboard").then((r) => r.json()));

What the SDKs cover today

The runrobot SDKs are developer clients for hosted RunRobot Cloud. They build canonical public URLs and upload scenes, robots, and policy artifacts. The package-first researcher workflow lives in the open-source runrobot repo.