LoginGet startedDashboard
AI Cloud Agents

Give your agents a computer, not a chat box.

Autonomous agents have to clone repos, install dependencies, run builds, browse, and read the output, on a real machine, not inside a text model. Sandal hands each agent its own microVM: full filesystem, its own kernel, and $0 the moment it pauses to think.

Start buildingRead the docs
npm i @sandal/sdk
warm claim
<200ms
warm claim
while paused
$0
while paused
kernel per agent
1
kernel per agent
concurrency
unlimited
concurrency
The problem

A text model can’t run code.

The moment an agent needs to actually do something, check out a branch, install a package, run a test, read a stack trace, reasoning isn’t enough. It needs a machine. Bolting one shared container onto the fleet leaks state between agents and falls over under real concurrency.

  • Agent capabilities

    Execution, not just tokens

    Agents need a filesystem, a shell, a network and real exit codes, the ground truth a model can act on.

  • Isolated machines

    One per agent

    A hundred agents need a hundred isolated machines, not a shared host where one poisons the next.

  • Session efficiency

    Idle is most of the loop

    Agents spend most of a session waiting on a model. Paying for that idle time is how sandbox bills explode.

How it works

Create, run, pause, fork.

The whole agent loop is four calls. The machine arrives faster than the model decides what to do with it, and disappears the moment it is done.

agent-loop.tsA machine per turn
const box = await sandal.sandboxes.create({ template: "node-24" });
// the model proposes, the machine executes, the output returns
while (!done) {
const step = await agent.next(context);
const run = await box.exec(step.command);
context = agent.observe(run.stdout, run.exitCode);
}
// pause between turns, a slow model costs nothing
await box.pause();
  1. 01

    A machine per agent

    Claim a pre-booted microVM in under 200ms. Own kernel, own network fence, fresh credentials, nothing shared with another agent.

  2. 02

    Run the loop

    Exec commands, read/write files, expose a preview URL, or drive a full desktop. Every action returns a value your code can branch on.

  3. 03

    Pause to $0

    Between turns the machine pauses, freeing CPU and RAM to disk. Resume sub-second with variables and open files intact.

  4. 04

    Fork to explore

    Branch a machine like a repo to try two approaches in parallel, then keep the one that worked and discard the rest.

Capabilities

Everything the agent needs, one SDK.

  • 01

    Exec & filesystem

    Run commands buffered, streamed or interactive; read and write the disk directly.

  • 02

    Preview URLs

    Expose any port on a signed HTTPS host so the agent can serve and check its own work.

  • 03

    Computer use

    On a VM, screenshot/click/type to drive GUI apps and a browser, not just a shell.

  • 04

    Snapshots & forks

    Branch state to explore, and roll back a bad step instead of starting over.

  • 05

    Default-deny isolation

    A fresh agent reaches nothing until you allow it; secrets are injected at the edge, never a file it can read.

  • 06

    Pause-to-zero

    Idle turns are free, so an agent that thinks for a minute between actions costs nothing to keep alive.

Built on Sandal

The products that power it.

AI agents run on Sandal’s core compute, in whichever shape the task needs.

Live desktop stream
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

60fps
Get started

Give your agents somewhere to run.

A machine per agent, per turn, isolated, instant, and free while it thinks. Free tier included.

Start buildingRead the docs
npm i @sandal/sdk