LoginGet startedDashboard

Sandboxes that do more than run code

Lightning-fast, isolated compute for AI agents and developers. Sandboxes, GitHub Runners, Xcode builds, and iOS & Android simulators, across every major platform, through one API.

Get started for free
Quick start
$ curl -fsSL https://sandal.dev/install | sh
Our platform

Every kind of computer, ready in milliseconds

Stop stitching vendors together. Containers, virtual machines, CI runners, simulators, Macs and browsers all come from one SDK, one API key and one bill.

Run your agent’s code in under 90ms

Give every agent its own isolated Linux container: it boots in under 90ms, keeps its state between calls, and costs you nothing while it waits.

Discover containers
Sub-90ms cold starts
From API call to executing code in under 90 milliseconds.
Bring any Docker image.
Your dependencies, preinstalled, and paused costs nothing.
Alternative toE2BE2BModalModalDaytonaDaytonaVercel SandboxVercel SandboxCloudflareCloudflare
.co
llm
terminal

user@user-mac: sandal

user@user-mac: ~new ComputerUse (sandboxe)

Hand your agent a full desktop

Boot persistent Linux, Windows and macOS machines with their own kernel and desktop. Snapshot them, restore them in seconds, and clone as many as you need.

Linux, Windows, and macOSFull desktop GUIDedicated kernel per machineHardware-isolatedSnapshot, restore, and cloneRestore in 2.1s
Discover virtual machines
Alternative toAWS EC2AWS EC2Fly.ioFly.ioHyperbeamHyperbeam
vm_7c31 · full desktop
◐A>_✦✳
machines
ubuntu-24.04dedicated kernelrunning
windows-11full desktop guirunning
macos-15from snapshotcloning ×3
snapshot → restore · 2.1s

Run your CI at any scale

Swap slow hosted runners for ephemeral ones on Linux, Windows and macOS: a thousand jobs at once, no queue, nothing to maintain.

Discover GitHub Runners
Sub-150ms
Ephemeral Boot Time
Instant spin-up with zero cold starts.
Up to 70% Cheaper
Cheaper Vs Standard Cloud Runners
High-concurrency Mac & Linux runners.
Auto-Scale Fleet
High Concurrency
Scale up to 1000+ concurrent jobs no effort.
Native Multi-OS
Full OS Support
Linux, Windows, and macOS runners in one fleet.
Alternative toGitHub-hostedGitHub-hostedDepotDepotBlacksmithBlacksmithNamespaceNamespace
GitHub Actions · workflow run

sandal-runner-macos · ephemeral

Checkout

Install dependencies

Run cross-platform tests

Upload artifacts

1000+ jobsqueue: 0
build.yml · PR #284

Test on every phone, without owning one

Drive real iOS Simulators and Android emulators: accessibility tree, gestures, screen capture. Fan out a device per test, then tear them all down.

Discover simulators
iOS & Android SimulatorsQuickstart
1
2
3
4
5
6
7
8
9
~
// Connect agent to an ephemeral iOS Simulator
 
const simulator = await agent.connect("ios-simulator", { os: "17.4" });
 
// Visually locate and interact with the app GUI
await simulator.tap({ x: 240, y: 520 });
 
> [System]: Screen interaction triggered successfully.
 
 
Alternative toSauce LabsSauce LabsAWS Device FarmAWS Device FarmAppetizeAppetizeGenymotionGenymotion
iPhone 16 Pro · iOS 17.4
Pixel 9 · Android 15
ios · tap(240, 520)

Ship for Apple without waiting on a Mac

Get dedicated Apple-silicon machines for zero-latency Xcode builds and Swift test suites, billed by the minute you actually use.

Zero-latency Xcode compilationNative Mac hardware infrastructure
Discover Xcode builds
Xcode BuildsQuickstart
1
2
3
4
5
6
~
~
$ xcodebuild -workspace Sandal.xcworkspace -scheme SandalApp
 
** BUILD SUCCEEDED **
 
[Elapsed time: 12.4s]
 
 
 
Alternative toXcode CloudXcode CloudBitriseBitriseCodemagicCodemagicMacStadiumMacStadiumDepotDepot
Xcode · build in progress

1

2

3

4

5

6

7

8

9

~

~

xcodebuild -scheme MyApp
 
Compiling AppDelegate.swift
Compiling ContentView.swift
 
** BUILD SUCCEEDED **
 
[Elapsed time: 02:14]
 

Browse the web the way a person does

Drive headful Chrome on its own kernel over Playwright or CDP. Keep your sessions, snapshot and clone them, and go out from a static IP you own, not a headless build in a shared container.

Headful Chrome, not headlessOwn kernelPlaywright and CDP endpointsDrop-inPersistent sessionsSnapshot & clone
Join the browsers waitlist
Alternative toBrowserbaseBrowserbaseHyperbrowserHyperbrowserSteelSteelKernelKernel

project124

https://203.0.113.42/
The problem

The bottleneck isn't writing code anymore.
It's giving agents somewhere to run it.

Engineers now run fleets of agents that write code in parallel. Each one needs a real computer: isolated, ready in milliseconds, gone when the job is done.

Everyone else
  • Sandboxes that cold-start every run
  • Hosted runners: shared, queued, slow
  • Headless browsers, easily detected
  • Device farms billed by the hour
  • Mac CI at $0.08 a minute
  • VMs that keep billing while idle
Sandal's model
  • One API for every kind of computer
  • Own kernel and desktop, per agent
  • Six products, one bare-metal fleet
  • Warm in under 200 ms, paused for $0
  • Snapshot, restore and clone any machine
  • Programmable for agents and humans
One platform. Every computer your agents need.

Everything your agents run sits on one compute layer we own, so each product is fast on its own and they get faster together.

agent
1234567
container: clone acme/apprunners: ci on windows-11xcode: build MyAppmobile: tap(240, 520)browser: open /reportsvm: restore windows-11** task completed · 02:14 **
APISDKCLI
Cloud Computer
CPU
Memory
Storage
Network
GPU
Linux
Windows
macOS
Containers
.co
llm
terminal

user@user-mac: sandal

user@user-mac: ~new ComputerUse (sandboxe)

iOS & Android Simulators
iOS
Android
GitHub Runners
GitHub Actions · workflow run

sandal-runner-macos · ephemeral

Checkout

Install dependencies

Run cross-platform tests

Upload artifacts

1000+ jobsqueue: 0
build.yml · PR #284
Browsers

project124

https://203.0.113.42/
Xcode Builds
Xcode · build in progress

1

2

3

4

5

6

7

8

9

~

~

xcodebuild -scheme MyApp
 
Compiling AppDelegate.swift
Compiling ContentView.swift
 
** BUILD SUCCEEDED **
 
[Elapsed time: 02:14]
 
Virtual Machines
ubuntu-24.04 · vm
ActivitiesAug 27 16:45
>_
agent@sandal: ~/workspace

agent@sandal:~/workspace$ pytest -q tests/

collected 24 items

tests/test_agent.py ........ [ 33%]

tests/test_browser.py ...... [ 66%]

tests/test_vision.py ........ [100%]

24 passed in 6.41s

agent@sandal:~/workspace$ xdotool key ctrl+s

agent@sandal:~/workspace$

Home12 items
HomeDesktopDocumentsDownloadsPictures
sandboxeval-runsscreenshotsdatasets
README.md2 KBrun_eval.sh4 KBepisode-042.json18 KB
windows-11 · vm
Workspace
NewCutCopyRenameShareSortView
HomeGalleryDesktopDownloadsDocumentsPictures
This PC›Workspace
NameDate modifiedSize
agent-runs27/08/2026 16:40
datasets27/08/2026 15:02
build.ps127/08/2026 14:113 KB
report.xlsx26/08/2026 09:2048 KB
episode-042.json26/08/2026 08:5518 KB
Windows PowerShell

PS C:\Workspace> .\build.ps1 -Target Release

Restoring packages…

Building 42 projects…

Build succeeded in 38.2s

PS C:\Workspace> sandal desktop --click 412,280

✓ input delivered · frame 60fps

PS C:\Workspace>

>_
16:4527/08/2026
macos-15 · vm
CodeFileEditSelectionViewGoTerminalWindowHelpWed 16:45
agent.py · sandbox
Explorersandboxagent.pybrowser.pyvision.pytestsREADME.md

1from sandal import Sandbox

2

3# boot a desktop the agent can see

4vm = Sandbox.create(desktop=True)

5vm.screenshot("before.png")

6

7vm.click(x=412, y=280)

8vm.type("hello from the agent")

9vm.key("cmd+s")

10

11# read the screen back

12frame = vm.stream.latest()

13assert frame.contains("Saved")

zsh, sandal

➜ sandbox sandal desktop --stream

connecting to vm_7c31…

✓ stream open · 60fps · 18ms latency

screenshot → before.png

click(412, 280) · type · cmd+s

✓ saved

➜ sandbox

  • APIREST, from any language
  • SDKTypeScript and Python clients
  • CLIFrom a terminal or a CI job
What's included

Everything you'd have to build yourself, already built

Browser and desktop control, remote desktop, static IPs, your own domains, SSH, GitHub and more. Every capability your agents will ask for next is already on the machine, so you ship the product instead of the plumbing.

Computer Use

Control any desktop like a human, clicks, keyboard, apps

https://project124

terminal

Browser Use

Control any desktop like a human, clicks, keyboard, apps

project124

https://203.0.113.42/

60 FPS Remote Desktop

Low-latency visual streaming for live agent oversight

live desktop stream

https://203.0.113.42/
Chat

60fps

Dedicated IP

Stable outbound identity for allowlists and webhooks

outbound203.0.113.42

Tailscale

Private mesh networking between machines and your stack

Quick GitHub Repo Setup

Clone and index repos
in seconds at machine boot

git clone

acme/app · 2.1s

BYO Domain

Serve agents from your own domain with managed TLS

agents.yourco.com

SSH Access

Key-based shell into any running machine

ssh sandal@vm-8f2a

Connected · key auth

No session cap, 24/7 workloads.

Long-running agents with no session time limits

https://project124

99.99%

no session cap

Any Coding Model

Bring OpenAI, Anthropic, Gemini, Mistral and more

Select coding model

Instance Resize

Scale CPU and vRAM live, without a restart

CPU

54%

Low

High

vRam

42%

Low

High

Fast Snapshots

Capture file system, config and memory in seconds

SNAPSHOT

12:42:08

Complete

1

Branching

Fan one base environment out into parallel branches

Branch A

Running

Branch B

Running

Branch C

Running

Forking

Clone a running machine into an identical copy

Restoring

Roll any machine back to a restore point

August 2026

MoTuWeThFrSaSu
303112345
6789101112
13141516171819
20212223242526
27282930123

Restore Point

August

Oct 13, 10:00 AM

Oct 14, 10:00 AM

Oct 15, 10:00 AM

Persistent Storage

Volumes, databases and state blocks that outlive machines

Custom Images

Bake dependencies, config and tooling into reusable images

Dependicies

Node.js - Python • Packayes Loraries • Drivers

Configuration

Environment variables Settings • Secrets

Environment 1

Ready

Environment 2

Ready

Environment 3

Ready

Tooling

Chrome • Git - Playwright vS Code - More

Networking Controls

Inbound and outbound rules per machine

Inbound

PortProtocolSourceAction
443HTTPS0.0.0.0/0
22SSH10.0.0.0/24
80HTTP0.0.0.0/0

Outbound

PortProtocolSourceAction
443HTTPS0.0.0.0/0
Performance

Built for scale

  • 99.99% Uptime
  • <50ms Response
  • 10k+ Concurrency
  • Up to 90% Cheaper
sandal · boot

$ sandal create --pool warm

matched pre-warmed container

allocating from warm pool…

** completed **

[Elapsed time: 01:00s]

0 idle wait · instant execution

1s cold starts with pre-warmed containers and intelligent resource allocation. Zero waiting, instant execution.

Learn more
Developer experience

You call a function.
A machine appears.

If you can call a function, you can start a machine. The hard parts stay ours.

SANDAL CLI
$ npm install -g sandalInstall
Then
$ sandal newStart a sandbox
$ sandal execRun a command
$ sandal forkBranch a snapshot
$ sandal pausePause at no cost
$ sandal sshOpen a live shell
Quickstart
$ npm i @sandal/sdkInstall
1
2
3
4
5
6
7
8
9
10
11
12
~
~
~
import { Sandal } from "@sandal/sdk";
const sandal = new Sandal({ apiKey: process.env.SANDAL_API_KEY });
const sb = await sandal.sandboxes.create({
template: "node-24",
timeoutSeconds: 900,
});
await sb.fs.write("/app/index.ts", src);
const result = await sb.exec("node --version");
console.log(result.stdout); // v24.3.0
const url = await sb.expose(3000);
await sb.pause();
SDK

Every computer you need, a few lines each.

Boot a container, a VM, a runner, a phone or a Mac from the same client, with the same calls. Pick a runtime on the left; the windows that open are what your agent gets back.

Containers
Running
12345678910111213141516171819
# container.py
from sandal import Sandbox
# Fast Linux container, boots in under 90ms, paused costs nothing
box = Sandbox.create(runtime="container", image="ubuntu-24.04", cpu=4)
# Run code inside it, state persists across calls
result = box.run("python train.py --epochs 3")
print(result.stdout)
box.exec("pip install numpy pandas")
# Snapshot the running container, then fork it
snapshot = box.snapshot()
fork = snapshot.fork()
# Idle costs nothing, pause and resume in milliseconds
box.pause()
box.resume()
container · zsh

$ sandal run container ubuntu-24.04

✓ container booted · ctr_9f2a · 88ms

$ python train.py --epochs 3

epoch 1/3 loss 0.42 acc 0.86

epoch 2/3 loss 0.19 acc 0.94

epoch 3/3 loss 0.08 acc 0.98

✓ completed in 4.2s · idle cost $0.00

Pricing

Not just faster. Up to 90% cheaper.

Run every agent, test and build you want without watching the bill. You pay by the minute, at up to 90% less than you pay today, and nothing at all while a machine sits idle. Scale stops being a budget conversation.

OS
CPU
Memory
Concurrent machines50
Hours each240 hr each

Compare Price

Sandal4 vCPU / 8 GB · $0.036/hr$432
Modal$0.0236/vCPU + $0.008/GB4.4×$1,900
Daytona$0.0504/vCPU + $0.0162/GB9.2×$3,974
E2B$0.0504/vCPU + $0.0162/GB9.2×$3,974
Vercel Sandbox$0.128/vCPU + $0.0212/GB19×$8,179

Pricing breakdown

ItemQuantityCost
VM time12,000 VM hrs$432
Paused timeUnmetered$0
Estimated total for 12,000 VM hrs$432
You save 77% a month against
$1,468

Billed by the second at $0.036/hr for 4 vCPU / 8 GB. Others at their published unit rates for the same shape, wall-time assumed; a paused Sandal machine is not billed.

Pause it and the meter stops

A machine is billed for every second it is running. Pause it between bursts and it costs nothing until you resume, so a fleet that works in office hours is not a fleet you rent around the clock.

running
freefreefreefreefreefreefreefreefreefreefreefreefreefreefreefree
freefreefreefreefreefreefreefreefreefreefreefreefreefreefreefree
freefreefreefreefreefreefreefreefreefreefreefreefreefreefreefree
paused overnight · $0
resumed
PaidFree
BilledPer second, while running
PausedCosts nothing
RestoreBack in about 2 seconds
Use cases

What you can build now

Sandal is the infrastructure underneath real products. At these prices you can build the ones that were never viable before: a thousand sandboxes at once, a device for every test, a Mac for every build.

acme/app · coding agent
src/checkout.tsxpricing.tscart.tsxcheckout.test.ts
export function Checkout({ user }) {
- const plan = user.plan.tier
+ const plan = user.plan?.tier ?? "free"
+ if (!plan) return redirect("/pricing")
return <Cart plan={plan} />
3 changes savedPR ready
terminal
$npm test
142 passed

Cloud Coding Agents

Give every agent its own repo, terminal and test run, on machines that cost nothing idle.

Runs on
ContainersVirtual Machines
Build your own
ConductorCursorDevin
Discover use case
spec
Checkout v26 tasks · planned
factory · 6 agents
auth
cart
checkout
api
tests
docs
6 agents · in parallelPR #302 · 14 files

Software Factories

Turn a spec into a tested pull request, with a fleet of agents building in parallel.

Runs on
ContainersGitHub Runners
Build your own
FactoryWarpSourcegraph
Discover use case
acme/app · pull request #284
src/billing/trial.ts+12 -4
const tier = user.plan.tier
-if (tier === "pro") unlock()
+if (tier === "pro" || trial) unlock()
return tier
142 passed · 1 finding
agent_0001changes requested

user.plan is undefined for trial accounts. Suggested: user.plan?.tier

AI Code Review

Clone the PR, run the suite and reproduce the bug before you comment, on every pull request.

Runs on
Containers
Build your own
CodeRabbitGreptileGraphite
Discover use case
iOS
Android

Mobile QA Agents

Let your agents tap through real iOS Simulators and Android Emulators, a device per test.

Runs on
iOS & Android Simulators
Build your own
MomenticMaestroTester Army
Discover use case
live on simulator
mac · xcodebuild
xcodebuild -scheme MyApp
build succeeded
signed · 2m 14s
›installed on sim

AI Mobile App Builders

Compile, sign and ship iOS apps for your users on real Macs, in minutes, at any volume.

Runs on
Xcode BuildsiOS & Android Simulators
Build your own
RorkReplitVibecode
Discover use case

AI Coworkers

Give your agent a real desktop it can see and drive, so it finishes work in the apps people use.

Runs on
Virtual MachinesBrowsers
Build your own
ManusCometGenspark
Discover use case
“We’ve tried more sandbox tools than I can count, so we built our own. Sandal outperforms them all by a mile. Honestly, it’s the only AI sandbox that doesn’t annoy the s**t out of me.”

12,400+

Machines launched

4.2s

Avg startup time

6.8h

Avg agent runtime

*Environments:LinuxmacOSiOS simulatorsGitHub Runners
Jakub Klima

Jakub Klima

CEO @ Enter

View case study
From the blog

Learn more

All articles
Engineering

How we start a Linux microVM in under 90ms

8 min readAug 12, 2026
AI Cloud Agents

Agents need more than a text model

6 min readJul 29, 2026
Product & Pricing

Why you should not pay for idle

5 min readJul 15, 2026
FAQ

Everything you need to know before you start

Environments spin up in sub-seconds (under 150ms for standard sandboxes). Agents go from intention to execution almost instantly without waiting for cold starts.

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