Layer 03 — Infra

Your agent runs on a real computer

Every run boots a Firecracker microVM with a persistent filesystem, scoped secrets, and cron. Integrations are just code running inside it. No cluster to operate, no ops team required.

Start building freeRead the docs
01 — APPSAppswherever you work
02 — MODELSRouterfrontier + open-weight
03 — INFRAInfrasandboxes in 90ms
Wander
"Wander runs on Adapt end to end, and the sandboxes are our factory pattern: every change gets a fresh microVM, runs the full suite, and only ships when it's green. We move faster because we ship confident."
Nathan Potter

Nathan Potter

CTO at Wander

wander/factory
  • sandbox_01build41s
  • sandbox_02unit + integration2m 04s
  • sandbox_03e2e against staging3m 12s
  • sandbox_04canaryshipping

fresh microVM per step · green before it ships

The filesystem

Your company, mounted at /state.

The filesystem is the abstraction. What your agent knows, what it can do, and what it has done are files on a durable volume that every sandbox mounts.

  • Files, not a databaseKnowledge, skills, and integrations live as ordinary files your agent (and your team) can read, write, and diff.

  • State that outlives the runSandboxes are disposable; /state is not. Every run mounts the same volume, with snapshots on by default.

  • One filesystem, every surfaceThe Slack bot, the cron job, and the web workspace all see the same files, so nothing has to be synced.

Persistent volume
  • integrations/84 MB
  • knowledge/486 MB
  • skills/132 MB
  • apps/96 MB
  • company.md48 KB

1.1 GB of 10 GBsnapshot 4m ago

Orchestration

Boot instantly. Scale to zero.

Runs are the unit, not servers. Each one gets a fresh hardware-isolated microVM, your filesystem, and its secrets, then disappears when the work is done.

run_7f3a91
Cold start 90ms
  • boot sandbox90ms
  • mount /state62ms
  • load secrets41ms
  • router → fable-5-xhigh1.24s
  • tool: github.search310ms
  • router → kimi-k3-high190ms
  • write run.json48ms
  • post to slack88ms

total 2.05sretries 0cost $0.0038

Automations
  • 0 9 * * 1standup digest—
  • */15 * * * *inbox sweep—
  • grain.call.finishedpost call transcriptwebhook
  • stripe.invoice.paidreceipt → CRMwebhook

  • A microVM per run

    Every run boots a fresh Firecracker microVM behind KVM. Hardware isolation, not a shared container.

  • No cluster to babysit

    Scheduling, scaling, retries, and teardown are the platform. You ship files; runs happen.

  • Cron and webhooks built in

    Automations are runs on a schedule or an event. Same sandbox, same filesystem, same traces.

Integrations

Integrations are just code.

The Slack integration is code that exposes a webhook. The Stripe integration is code that calls Stripe. There is no connector runtime in between, only your sandbox.

  • Any API, day oneThere is no connector catalog to wait on. If it has an API, the integration is a file away: code that calls it, running in your sandbox.

  • Code composes, tool calls chainOne script joins Stripe, Postgres, and Slack in a single pass. The tool-calling version is a dozen round trips, each one re-reading the whole conversation.

  • Fewer tokens, better answersTool schemas and intermediate payloads never flood the context. The sandbox does the heavy lifting and only the answer comes back, so the model spends its attention on the question.

automations/revenue-digest.ts
1import { Adapt } from "@adapt/sdk";
2 
3const sandbox = await Adapt.launch({
4  vcpu: 2,
5  memory: 4096,
6  mounts: [{ source: "basin://adapt/calendar", path: "/mnt/calendar" }],
7  network: { egress: "allowlist", allow: ["calendar.google.com", "slack.com"] },
8});
9 
10await Adapt.run({
11  model: "moonshotai/kimi-k3",
12  prompt: "Pull the week-ahead calendar and post an upbeat standup digest to #general.",
13  sandbox: sandbox.id,
14  limits: { max_turns: 6, max_tree_sandboxes: 0 },
15});
Context cost

tool-call chaining12 round trips · every payload in context

one sandbox run1 pass · only the digest returns

Why it's different

Built for how agents actually work.

Server infrastructure assumes long-lived processes and stateless requests. Agents are the opposite: thousands of short-lived runs over one long-lived memory.

Fan out, scale to zero

A backfill can be a thousand sandboxes for ten minutes. When it finishes, you are running nothing and paying for nothing.

Memory you can read

Durable memory is files on the volume, not an opaque vector store. Inspect it, edit it, version it, delete it.

Instant to useful

Cold starts are effectively instant, so every event gets a fresh, clean machine instead of a warm, dirty one.

Secrets that stay scoped

Each run gets exactly the credentials it needs, injected at boot and gone at teardown. Nothing sprawls across environments.

No cluster
to babysit.

A real computer per run, a filesystem that remembers, and integrations you can read. Live in minutes.

Start building freeTalk to an engineer