LoginGet startedDashboard
Virtual Machines

Full machines your agent can drive.

Full microVMs with their own kernel, a real desktop your agent can see, click and type on. Linux, Windows and macOS. Warm through a working day, paused to $0 between bursts, back in under 200ms with everything exactly where it was.

Start buildingRead the docs
npx sandal new --runtime vm --os ubuntu-desktop
drive-a-machine.tsCreate → see → click → pause
import { Sandal } from "@sandal/sdk";
const sandal = new Sandal({ apiKey: process.env.SANDAL_API_KEY });
// A full machine with its own kernel and desktop.
const vm = await sandal.sandboxes.create({
runtime: "vm",
template: "ubuntu-desktop",
resources: { vcpus: 8, memoryMb: 16384 },
});
// Drive it like a person: see the screen, move, click, type.
const shot = await vm.computer.screenshot();
await vm.computer.click(640, 360);
await vm.computer.type("hello world");
// Pause to $0 between turns; resume in under 200ms.
await vm.pause();
<200mswarm resume
$0while paused
1kernel per VM
3 OSesLinux · Win · Mac
64 vCPUmax shape
Computer use

A whole desktop, as an API.

A container gives your agent a shell. A VM gives it a computer, a real windowing system it can see and operate. The same loop a person runs, driven from your code.

See

The pixels an agent reasons over.

Full-resolution screenshots on demand, or a live 60fps stream. The screen the agent reads is the screen it just acted on, input and video share one clock.

computer-use.ts
// see the screen the way the agent does
const png = await vm.computer.screenshot();
// or watch it continuously
for await (const frame of vm.computer.stream({ fps: 10 })) {
await model.observe(frame);
}
Act

Move, click, type, at OS level.

Move, click, drag, type, key-combo and scroll against the real windowing system, not through a browser shim. Desktop apps, installers, legacy software, a browser, if it runs on a machine, the agent can drive it.

await vm.computer.moveMouse(420, 220);
await vm.computer.click("left");
await vm.computer.type("quarterly-report.xlsx");
await vm.computer.key("Return");
// scroll, drag, key-combos, all first class
await vm.computer.scroll({ dy: -600 });
await vm.computer.hotkey("cmd", "s");
Remote desktop

Hand the machine to a person, too.

Every VM streams its desktop at 60fps over WebRTC. Drop it into your product with one component, or send a signed link to a reviewer who takes the wheel for a moment, human-in-the-loop without an RDP client or a VPN.

RDP and VNC are there too if you would rather connect an existing client.

RemoteDesktop.tsx
import { RemoteDesktop } from "@sandal/react";
// a signed, per-VM stream, never your org key
const url = await vm.desktop.stream({ fps: 60 });
<RemoteDesktop
streamUrl={url}
interactive // forward mouse + keyboard
fit="contain"
onReady={() => console.log("connected")}
/>;
Stream
WebRTC60 fps, low-latency, watch or drive
Scoped tokenOne VM, the scopes you set, dies with the TTL
RDP · VNCStandard protocols for existing clients
Pause

Stays warm. Costs nothing paused.

Pausing freezes exact in-memory state to disk and stops both meters. Resume returns in under 200ms with your windows still open, your cursor where it was, your session still logged in.

await vm.pause(); // RAM + disk frozen, $0
// … hours later …
await vm.resume(); // < 200ms, same desktop
const shot = await vm.computer.screenshot();
// or branch it for the next task
const child = await vm.fork();
Every OS

Linux, Windows and macOS, one API.

Switch the machine with one field. The SDK, the lifecycle, the billing meter and the computer-use primitives are identical across all three; only the desktop underneath changes.

Linux

Ubuntu 24.04 and friends, with or without a desktop. From 2 to 64 vCPU, its own kernel, per-second billing.

ubuntu-24.04 · ubuntu-desktop · from $0.036 / VM-hr

Windows

A real Windows 11 / Server 2025 desktop, the OS agents struggle to get anywhere else. RDP, legacy apps, the lot.

windows-11 · windows-2025 · same machine + licensing

macOS

A macOS desktop on Apple silicon we own, one fixed instance, billed per minute. For Mac-only tools and Apple workflows.

4 cores / 8 GB · $0.01 / min
Persistence

A machine worth
keeping around.

A configured desktop, a logged-in session, an installed toolchain. Set it up once, then pause, resume, snapshot and fork it like a repo.

persistence.ts
// named storage that outlives any VM
const home = await sandal.volumes.create({ name: "home", sizeGb: 50 });
const vm = await sandal.sandboxes.create({
runtime: "vm", template: "ubuntu-desktop",
volumes: [{ id: home.id, mountPath: "/home/agent" }],
});
await vm.pause(); // snapshot, not a machine, $0
const twin = await vm.fork(); // same desktop, new identity
await vm.resume(); // < 200ms, windows still open
  1. 01

    Pause to $0

    Freeze RAM and disk, release the CPU. A paused VM is a snapshot, not a machine, and a snapshot is not billed.

  2. 02

    Resume <200ms

    Come back to the exact desktop, open apps, cursor position, in-memory state, from a warm claim off the pool.

  3. 03

    Snapshot & fork

    Branch a configured machine like a repo. Set one up once, fork it per task, and each child gets its own clock and tokens.

  4. 04

    Volumes

    Named storage that outlives any VM. Mount a home directory or a build cache and a fresh machine starts where the last left off.

Need short-lived, high-concurrency machines instead? Containers →

Plans

One balance. Every machine you run.

Virtual machines draw from the same credit pool as your containers, runners and simulators, billed by the second at one published rate card.

Starter

For a solo build or a first agent in production.

$20/ month

$20 of usage credits

≈ 550 VM-hours or 33,000 CI minutes

Get started
  • 20 concurrent machines
  • Committed in-plan rates on every product
  • Linux & Windows, sandboxes, VMs, runners
  • Per-second billing, paused is free
  • Full API, SDKs, CLI & MCP server
  • Unlimited seats
  • Community support
Most popular

Team

Apple silicon unlocked, and a balance that rolls over.

$100/ month

$100 of usage credits

≈ 2,700 VM-hours or 10,000 Mac build minutes

Get started
  • 100 concurrent machines
  • Everything in Starter, plus:
  • macOS, iOS/Android simulators & Xcode builds
  • Unused credits roll over one month
  • Usage exports & per-second line items
  • Email support

Business

Higher ceilings for a team leaning on the fleet daily.

$250/ month

$250 of usage credits

≈ 6,900 VM-hours or 25,000 Mac build minutes

Get started
  • 300 concurrent machines
  • Everything in Team, plus:
  • Raised concurrency & start rate
  • Priority support & shared Slack channel
  • Single sign-on (SAML / OIDC)
  • Volume credit rate

Enterprise

Dedicated capacity, your compliance surface, one invoice.

Custom

Committed volume rate

Committed volume rate, negotiated per account

Talk to sales
  • Reserved bare-metal capacity
  • BYOC or self-host the control plane
  • SSO & SCIM, audit logs, data residency
  • Annual invoicing, MSA, DPA
  • Support SLA & solutions engineering
  • Custom regions on request

Every plan spends its credit pool first, then usage keeps flowing and bills per second at your committed in-plan rate, no hard stop mid-run, no forced upgrade. Without a plan you pay the on-demand rate instead. Prices are illustrative pending final list pricing; the per-second billing model is final.

Rate card

The virtual machine rate card.

Linux

MachineIn-plan / VM-hrOn-demand / VM-hr
1 vCPU / 2 GB$0.009$0.013
2 vCPU / 4 GB$0.018$0.027
2 vCPU / 8 GB$0.023$0.035
4 vCPU / 8 GB$0.036$0.054
4 vCPU / 16 GB$0.046$0.069
8 vCPU / 16 GB$0.072$0.108
8 vCPU / 32 GB$0.092$0.138
16 vCPU / 32 GB$0.144$0.216
16 vCPU / 64 GB$0.184$0.276
32 vCPU / 64 GB$0.288$0.432
32 vCPU / 128 GB$0.368$0.552
64 vCPU / 128 GB$0.576$0.864
64 vCPU / 256 GB$0.736$1.104

Windows

MachineIn-plan / VM-hrOn-demand / VM-hr
1 vCPU / 2 GB$0.018$0.027
2 vCPU / 4 GB$0.036$0.054
2 vCPU / 8 GB$0.046$0.069
4 vCPU / 8 GB$0.072$0.108
4 vCPU / 16 GB$0.092$0.138
8 vCPU / 16 GB$0.144$0.216
8 vCPU / 32 GB$0.184$0.276
16 vCPU / 32 GB$0.288$0.432
16 vCPU / 64 GB$0.368$0.552
32 vCPU / 64 GB$0.576$0.864
32 vCPU / 128 GB$0.736$1.104
64 vCPU / 128 GB$1.152$1.728
64 vCPU / 256 GB$1.472$2.208

macOS

One fixed instance, billed at $0.01 / minute.
MachineIn-plan / VM-hrOn-demand / VM-hr
4 cores / 8 GB · Apple silicon$0.60$0.90

Linux from $0.0065 / vCPU-hr + $0.00125 / GB-hr; Windows is the same machine plus licensing at 2x. macOS ships as one fixed Apple-silicon instance billed per minute. On-demand is 1.5× the in-plan rate. All usage bills by the second; paused machines are not billed.

Get started

Give your AI agents somewhere to run today.

Your agents get their own machines across Linux, macOS, Windows, iOS and Xcode in milliseconds, and you stop paying for idle.

Start buildingRead the docs
npx sandal init