Infrastructure that agents love.

Name: Run Cloud
Brand: Run Cloud

Spin up isolated Linux machines, control iOS simulators, and ship XCode builds, all through one API.

$curl -fsSL https://run.cloud/install | sh

Mobile simulators

npm install @run-cloud/sdk

simulator.ts

import { writeFile } from "node:fs/promises";
import { Client } from "@run-cloud/sdk";

const cloud = new Client();
const session = await cloud.ios.create({
  displayName: "Agent smoke",
  inactivityTimeout: "60s",
});

try {
  await cloud.ios.openUrl(
    session.id,
    "https://run.cloud",
  );
  await new Promise((resolve) => setTimeout(resolve, 3000));
  const screenshot = await cloud.ios.screenshot(session.id);
  await writeFile("run-cloud.png", screenshot);
  console.log(`Captured run-cloud.png (${screenshot.byteLength} bytes)`);
} finally {
  await cloud.ios.delete(session.id);
}

API

Migrating from another sandbox platform?

Keep your existing code and change the provider underneath.

Click for more info

COST

Compare sandbox pricing

Model your workload across Run Cloud and other providers.

Open pricing calculator

One platform

Simulators, builds, and microVMs under one API.

Start the machine your agent needs, run the work, and keep the state. No fleet management and no platform-specific orchestration.

Early access

┌──────────────────┐
│  iPhone  ·  9:41 │
│ ┌──────────────┐ │
│ │              │ │
│ │   app live   │ │
│ │              │ │
│ └──────────────┘ │
│         ●        │
└──────────────────┘

Early access

iOS Simulators

Create and stream iOS simulators, open URLs, install app builds, and control their lifecycle over API.

Early access

 source
   │
   ▼
[ archive ] ──▶ [ sign ✓ ]
                   │
                   ▼
              TestFlight ↑

Early access

XCode Builds

Archive, sign, export, and upload iOS builds without maintaining Apple hardware.

Private beta

┌──────────────────────┐
│ FIRECRACKER MICROVM  │
├──────────────────────┤
│  CPU   RAM   vsock   │
│  ▓▓▓   ▓▓▓    ↕      │
│  own kernel       ✓  │
└──────────────────────┘

Private beta

Linux Sandboxes

Firecracker microVMs with their own kernel. Snapshot, fork, pause, and resume.

Fast, scalable, stateful

Built to keep pace with agents.

Create quickly, fork state into parallel work, and pause at no cost.

<200ms

ready to work

while paused

1 → many

agents at once

Simple API

One command surface.

RUN CLOUD / CLI READY

$run-cloud createStart a sandbox

$run-cloud execRun a command

$run-cloud forkBranch a snapshot

$run-cloud pausePause at no cost

$run-cloud desktopOpen a live screen

The production cloud for agents.

simulator.ts

01import { Client } from "@run-cloud/sdk";02 03const cloud = new Client();04const session = await05cloud.ios.create({06inactivityTimeout: "60s",07});

Run Cloud SDK

Mobile sessions, in code.

Use TypeScript, Python, or Go for the native API. TypeScript and Python also include provider-shaped adapters for incremental sandbox migrations.

RUN CLOUD / LIVEHEALTHY

Warm create

<1s

Exec overhead

~1ms

REQUESTREADY

Agent-native runtime

Built for speed, with state.

Start isolated microVMs in under a second, execute with millisecond-class overhead, and preserve the environment between agent steps.

SNAPSHOT / BASE-07FAN-OUT

snapshot

agent-01

agent-02

agent-03

CONCURRENCY1 → 100s

Elastic sandbox capacity

Fork one environment into hundreds.

Snapshot once, fan out agent branches and test runs in parallel, then scale back down without managing a fleet of idle machines.

RUN / SBX-4F2AEXIT 0

00:00.012sandbox created

00:00.074files synced

00:01.482tests passed · 24/24

00:01.516snapshot saved

STDOUTARTIFACTSUSAGE

Production control

Every run has a result.

Stream output, capture exit status, enforce timeouts, retain artifacts, and follow each sandbox from creation through snapshot and teardown.

The primitives behind reliable agent work.

Run untrusted and AI-generated code inside KVM-backed microVMs with a dedicated kernel and filesystem.

Explore the API

MICROVM / SBX-4F2AISOLATED

KVM

hardware boundary

own kernel

private fs

FAQ

The practical details.

The pieces teams usually ask about before giving agents real infrastructure.

What is Run Cloud?

Run Cloud is infrastructure for agent builders and mobile development. It offers iOS simulators, XCode builds, and Linux sandboxes behind one API.

How fast do Linux sandboxes start?

Warm sandboxes resume from a full VM snapshot in under 200 milliseconds, and a fresh sandbox is running in under a second on the warm path.

How does billing work?

Everything is metered per second of actual runtime: vCPU, memory, and storage. Paused sandboxes have no cost.

Is it safe to run untrusted or AI-generated code?

Yes. Linux sandboxes are hardware-virtualized Firecracker microVMs with KVM isolation, not shared-kernel containers.

Can I snapshot and fork a sandbox?

Yes. Filesystem snapshots are point-in-time and copy-on-write, and can be restored on any host in the fleet.

I already use another sandbox provider. How hard is switching?

One line. Drop-in adapters for Modal, E2B, Blaxel, CodeSandbox, Vercel, Cloudflare, Fly.io, and Daytona let existing sandbox code keep working against Run Cloud.

Do I need a Mac to ship iOS apps?

No. XCode builds archive, sign, and export your IPA in the cloud and can upload straight to TestFlight.

Give every agent somewhere safe to run.

Start with Linux sandboxes, add iOS simulators when your workflow needs a screen, and ship iOS without managing Apple hardware.

Start building Compare products