Focus on your robot. We run the cloud.

Worlds to test in, generated by a frontier 3D world model, and physics scenes made from a photo. Twins of your robot you can check. Success rates with their error bars, from thousands of runs on our pools or your own machines. And, if you want it, a measure of whether your tests would notice your robot getting worse.

Runs on

17,000
tasks dispatched a second on one pool, measured on Cloudflare's edge.
55 ms
median lease latency at the edge.
100,000
tasks accepted in a single request, each quoted before it is.
$0
for the world, every time you run in one you already built. A world is paid for once.

One command. A thousand runs.

Each tile is one task: a scenario, a world, a verdict. The dispatcher hands them out, a managed pool or your own machines run them, and every verdict lands in the index with whatever decided it.

  1. 01
    Every task is a row firstBefore it is a queue entry. Leases carry a token and a deadline; a runner that dies hands its work back.
  2. 02
    Up to 256 shards a campaignStriped in blocks, so a 100,000-task sweep is leased as fast as it is asked for.
  3. 03
    Every outcome on recordSpec, output, duration and exit code, queryable per workspace for as long as you keep them.
What a run costs
seed sweep 001-024 · nightly-regression

24 tasks, one world each, simulated in this pageFAIL: a time to collision under 1.2 s

Your robot is the hard part. The cloud should not be.

You build the robot. We handle the places it is tested in, the machines that run the tests, and the record of what happened.

Worlds without a 3D artist

Describe a scenario; a frontier world model builds the place: splats, a collider mesh and, on the standard tier, a metric scale. Built once, reused for free.

Compute that is not yours to run

Managed pools run each task on RunPod Serverless, scale to zero when idle, and charge for the seconds RunPod bills.

Or your own machines

When a test needs your simulator, your robot's stack, a GPU or data that must not leave the lab, one runner binary pulls work over HTTPS. Nothing connects in.

Verdicts you decide

No model judges your robot. A verdict comes from your checker or an expression you wrote, and says whether it could have failed at all.

Said plainly: a generated world is static, with no dynamics or moving actors, so it tests perception. Closed-loop control runs in physics - a twin on the built-in tabletop, or in a scene from a photo whose objects are sized stand-ins, not scans. And whether a success rate in simulation predicts one on the bench is something to measure, not assume: export a campaign's outcomes and let mutational calibrate them against your real ones.

A twin you can check.

A simulated robot is only worth the evidence that it moves like the real one. SimCloud certifies twins: one canonical spec, exports for every engine, fitted to the robot's own recordings, with a report card anyone can read before trusting it.

  1. 01
    One spec, every formattwin.json is the source; URDF, MJCF and USD are exported from it and checked to agree on limits, masses and frames.
  2. 02
    Fitted to the robotSystem identification from its LeRobot recordings: gains, friction, backlash, latency, and the tracking error per joint that is left.
  3. 03
    Run in more than one engineThe same trajectories in MuJoCo and PyBullet. A twin that behaves in only one says so.
  4. 04
    Ready for a policy, and for mutationalWhether a policy's inputs and outputs are the twin's, and a fault catalogue for checking your tests against it.

a twin's report card

  • spec-validpass
  • joint-limits-agreepass
  • frames-agreepass
  • sysid-trackingpass
  • engines: mujoco, pybulletpass
  • gripper-backlashwarn
  • usd-physicsskipped
What a report card holds: every check and how it ended, warnings includedan illustration

A photo in. A physics scene out.

Point SimCloud at a photograph of a real place. A vision model finds what can move, an image model takes it out, the world model builds the room, and bodies sized from the model's estimates go back in: a MuJoCo scene a twin can act in.

  1. 01 · uncover

    What can move

    The objects in the photo, with sizes, masses and where they are.

  2. 02 · plate

    Take them out

    An image model removes them, so the world is built empty.

  3. 03 · world

    Build the room

    The world model makes the place, cached and billed as any world.

  4. 04 · objects

    Put them back

    Primitives sized from the estimates, placed where the photo had them.

  5. 05 · check

    Let it settle

    Loaded, settled for two seconds: nothing explodes or falls through.

Out of it come scene.zip (the MJCF and its meshes), objects.json, the plate, a preview and the world. Said plainly: the objects are stand-ins, a box where the mug was, and their sizes and masses are a model's estimates, which objects.json says. A draft world has no metric scale; use standard when distances matter.

Success rates with their error bars.

Run a policy for N episodes on a twin, in the built-in tabletop or a scene from a photo, under perturbations - friction, mass, damping, backlash, latency, noise, a shifted camera, the lighting - and read successes over trials with a 95% interval, per policy and perturbation.

  1. 01
    Your policy stays yoursScripted policies are built in. Yours is a server you host, called over HTTPS each step: hosted runtimes never run code of yours.
  2. 02
    Intervals, not just ratesSeventeen of twenty is 64% to 95%. The console draws the interval, so a difference inside the noise does not read as a result.
  3. 03
    Unreachable is not failureAn episode your server did not answer is excluded and reported, never counted against the policy.
  4. 04
    Calibrate against the real thingExport the outcomes in mutational's format, and measure how well these rates predict your real ones before you rely on them.
nonefriction ×0.5latency 50 msscripted95%19/2076% - 99%60%12/2039% - 78%85%17/2064% - 95%your server75%15/2053% - 89%30%6/2015% - 52%45%9/2026% - 66%
Two policies by three perturbation sets, twenty episodes a cell: overlapping bands are not a rankingan illustration

Submit, run, query.

Three moves from a JSON file to thousands of verdicts, with nothing to operate in between.

# nightly.json
{ "pool": "lab-cpu", "dedupe": true,
  "tasks": [{ "spec": {
    "world": {
      "scenario": "cut-in.xosc",
      "model": "draft" } } }, ...] }
01

Describe a campaign.

A pool, a priority, and up to 100,000 task specs per request. Every submission is quoted before it is accepted, and scenarios from the catalogue become signed inputs.

$ runner --pool=lab-cpu \
    --dispatcher=$SIMCLOUD_URL \
    --token=$SIMCLOUD_TOKEN

leased   c_7q2f.0.118   attempt 1
heartbeat ok
completed succeeded   41.2 s
02

Choose where it runs.

A managed pool, where each task runs on RunPod Serverless and nothing idles. Or your own machines: one runner binary that pulls leases, runs each task as a local process, and reports back.

  • succeeded12,480
  • parked3
  • retried17
  • duplicates0
  • expired0
03

SimCloud does the rest.

Leases with tokens and TTLs, retries with backoff, parking after repeated failures, fair scheduling between teams, and a queryable result index.

On your own machines, any simulator runs.

On a self-hosted pool a task is any command that reads a spec and writes a run summary. Exit 75 to ask for a retry; everything else is yours. Managed pools run the world-model engine. Ask for the task contract.

CARLA
esmini
Gazebo
Isaac Sim
AirSim
BeamNG
Webots
MuJoCo
Unity
Unreal
ROS 2
yours

Run campaigns with zero ops.

Durable rows, fair leases, admission control and a queryable index, all on the edge near your runners.

One task, five states

queued
leased
retry
leased
done

Dispatch that survives everything

Every task is a row before it is a queue entry. Leases carry a token and a deadline, heartbeats extend them, and a runner that dies simply hands its work back.

Pool lab-gpu

  • P9urgent smoke testnext
  • P5nightly regressionfair share

Fair between teams

A campaign joins the pool at its current virtual time, so a 100,000-task sweep never starves the ten-task smoke test submitted after it - and priority still jumps the queue when you need it to.

maxInflight 50 · 31 leased

Admission control per campaign

Cap in-flight tasks so a single campaign cannot flood a GPU pool. Releases are asynchronous, so the cap costs nothing on the hot path.

Re-submitted, dedupe on

skipped 11,900accepted 600

Skip what already passed

Turn on dedupe and re-submitting last night's campaign only runs the scenarios that changed or failed. Keys are content hashes of the canonical spec.

cut-in.xosc

entities 2events 1valid

OpenSCENARIO in, a model out

Upload .xosc files, get strict validation and an engine-neutral JSON model with entities, triggers and actions your tooling can reason about.

GET /v1/results?where=
  spec.map=rotterdam,
  output.summary.metrics.collisions>0
  &state=succeeded

Query results like a database

Every terminal task lands in an index with its spec, output and duration. Filter with a small expression language and page through millions of rows.

Infrastructure for simulation engineers.

Everything a regression pipeline needs, without a platform team to run it.

Bring your own simulator

On a self-hosted pool, any process that reads a spec and writes a summary. No SDK inside it is required.

Runs where you choose

Managed RunPod Serverless pools, or a single runner binary on your own machines.

Placed near you

Workspaces can pin campaign state to the Asia-Pacific region.

Live in the browser

Counters for every campaign in the console, polling less as a campaign goes quiet.

Idempotent everything

Idempotency keys on submissions; duplicate tasks are rejected, not run twice.

Result index in SQL

Durations, exit codes, outputs and specs, queryable per tenant.

Scenario catalogue

Content-addressed uploads, tags, search and signed download links.

Metered as it ran

Usage by day, pool or campaign: worlds generated, compute seconds billed, model calls at cost plus a margin. A world served from cache is free.

Secure and resilient by default.

Credentials stay where the compute is, never in a task spec. On a self-hosted pool the control plane sees only specs and summaries.

Self-hosted means self-hosted

On your own runners, only task specs and summaries cross the boundary; artefacts stay where you put them.

Scoped tokens

Runner tokens can be limited to named pools; user tokens cannot manage the workspace.

Signed scenario links

Inputs are fetched with HMAC-signed, expiring URLs, never bearer tokens.

Sessions done right

HttpOnly, same-site cookies with cross-site writes refused at the edge.

Auditable billing

Every credit and charge is a ledger row, and a charge comes from the provider's own receipt.

Residency on request

Workspaces can pin state to the Asia-Pacific region.

Optional add-on

Would your tests notice your robot getting worse?

A thousand passing scenarios prove nothing if none of them would fail. Mutational injects faults into the system under test, sweeps your corpus, and says which scenarios actually guard against which failures.

A separate product, with its own account and pricing. SimCloud works without it.

  1. 01

    What each scenario guards

    Which faults each scenario catches, through which check, and which scenarios catch nothing at all.

  2. 02

    What to add, what to delete

    A worklist of the gaps, most urgent first, and which scenarios are safe to remove.

  3. 03

    A gate for CI

    Did this build lose coverage? Asked of a shared history, with an exit code your pipeline understands.

  4. 04

    On your machines, or ours

    Run it on your own machines today. In preview, a whole sweep runs as one task on a SimCloud managed pool.

Visit mutational.in

Mutational and SimCloud are both made by Mutational. Each has its own account; neither needs the other.

Put your robot through a thousand places.

Free credit on every new workspace, enough for a few dozen draft worlds or hours of compute, and runs on your own machines in the worlds you build cost nothing more.

  • No subscription and no seats.
  • Every run priced before it starts.