ARCHIL

Agent platforms

A disk for every tenant, open from any machine.

Give each tenant an Archil disk that outlives the sandbox. It mounts in about 50 ms in whichever sandbox runs the agent, and your backend reads it while the agent works.

Talk to an integration specialistRead the docs

Snapshotted on a clean stop. After a crash, the latest changes aren't in it, and only that vendor's sandbox opens it.

Mounts wherever your agents run

  • Linux
  • Kubernetes
  • Google Cloud Run
  • AWS Lambda MicroVMs

Any sandbox or VM with FUSE, Cloud Run, Lambda MicroVMs, or Kubernetes; elsewhere, serverless exec, the S3 API, or the SDKs. Where you can mount.

Snapshots work until a second machine needs the files.

The best sandboxes pause with memory intact, resume in about a second, and fork from a snapshot. Here is where they stop.

Only the sandbox can open the files

Reading a paused workspace means resuming its sandbox, and a vendor's volume mounts only in its own sandboxes.

One writer

Some vendor volumes take one read-write mount at a time, and read-only mounts see a point-in-time copy.

Saved on a clean stop, then expired

Snapshots happen on a clean stop and expire after 3 to 30 days unused; few vendors say what a crash keeps.

From each vendor's public documentation, read November 2026.

The sandbox runs the agent. The disk keeps the work.

The agent still works in /workspace. Here is how fast that is on a disk, and what it keeps.

The work loop

One cache serves every client, a checked-out directory runs at local-disk speed, and a cold file comes from the bucket once, however many sandboxes open it.

The full EFS benchmark

Pausing still has a job

A memory snapshot brings back running processes; the disk keeps the files after it expires, or on another machine.

Durable at fsync

Writes are durable once fsync returns and are sent about once a second otherwise, so a crash loses only the last unsent ones.

What the integration looks like.

Create a disk per tenant, mount it in a sandbox, branch it per attempt, and run tool calls without a sandbox.

TypeScript SDK docs
tenant.ts
1. A disk per tenant
import * as archil from "disk";
 
// When a tenant signs up: one disk, and a token that mounts only it.
// About 9 ms at the median, from the same region.
const { disk, token } = await archil.createDisk({
  name: `tenant-${tenantId}`,
});
// Encrypt it at rest: Archil can't show it to you again
await db.tenants.update(tenantId, { diskId: disk.id, token });
 
// A read-only token for your app's preview server, good for a day
const preview = await disk.addUser({
  type: "token",
  nickname: "preview",
  readOnly: true,
  ttl: "24h",
});
sandbox.sh
2. Mount it in a sandbox
# In any sandbox or VM with FUSE, as root. About 50 ms at the
# median, from any zone in the disk's region, at no extra charge.
mkdir -p /workspace
ARCHIL_MOUNT_TOKEN=$TOKEN archil mount $DISK_ID /workspace \
  --region aws-us-east-1 --conditional
 
# ... the agent works in /workspace ...
 
# Send every buffered write before the sandbox goes away
archil unmount /workspace
attempts.ts
3. Branch it for a few attempts
// In the agent's sandbox, before a hard task:
//   archil checkpoints create /workspace before-fix
 
// Three attempts, one writable branch each
// (Archil-managed disks, in AWS regions)
const disk = await archil.getDisk(diskId);
for (const name of ["fix-a", "fix-b", "fix-c"]) {
  await disk.createBranch({ name, fromCheckpoint: "before-fix" });
}
 
// Each attempt mounts its own branch in its own sandbox:
//   archil mount $DISK_ID /workspace \
//     --region aws-us-east-1 --branch fix-a
Branches and checkpoints
tool-call.ts
4. Tool calls, no sandbox
import * as archil from "disk";
 
// A tool call with no sandbox: org context read-only, the user's
// files, and this session's scratch, in one fresh microVM
const { stdout, exitCode } = await archil.exec({
  disks: {
    org: { disk: orgDiskId, readOnly: true },
    user: { disk: tenantDiskId, subdirectory: `users/${userId}` },
    scratch: { disk: sessionDiskId, conditional: true },
  },
  command: "cd /mnt/archil/user && rg -n TODO src && npm test",
});
  • 82 ms at the median from a laptop; writes are on the disk before it returns.
  • 2 vCPU and 4 GiB for up to 5 minutes, in AWS regions.
Guide: serverless tool calls

Fork the workspace.

Best-of-N, a rollback point, and a warm template are one checkpoint and a branch, at any disk size.

The task

5 GiB
256 MiB100 GiB
3
28

Copy it 3 times

15 GiBcopied before work starts

Full workspaces
4

Each attempt waits for its own full copy.

Branch it 3 times

112 msto checkpoint and branch

Copied before work starts
none

Copy-on-write: every branch shares the workspace, at any size.

Times are the medians on the limits page, with branches made one after another. Branches run on Archil-managed disks in AWS regions.

Draw the tenant boundary once.

These live on the disk, not the sandbox, so they hold whichever vendor runs the agent.

A token per disk, scoped per machine

Each token mounts one disk: read-only, once, or until a TTL. Archil stores only a hash of it.

One tenant per disk

A token reaches every branch and checkpoint of its disk, so give each tenant its own.

Best practices

In the region you choose

Active data stays in the disk's region on AWS or Google Cloud, or in your own cloud.

Bring your own cloud

SOC 2 Type II, AES-256 at rest, TLS 1.2 or higher in transit. Security.

How the options compare.

Each is right for some platform. Archil gives each tenant a disk every machine can open.

Pause-and-resume sandbox

Open from another machine
Resume it first
Machines writing at once
One sandbox
A crash mid-session
Saved on stop; crashes rarely documented
Fork a workspace
From a snapshot, mostly
Where it lives
Vendor's storage and region

Vendor's volume

Open from another machine
Only that vendor's sandboxes
Machines writing at once
One, or vendor's sandboxes
A crash mid-session
Varies; check what fsync() means
Fork a workspace
Some copy the volume
Where it lives
Vendor's storage, the sandbox's region

Block volume per tenant

Open from another machine
Only the attached machine
Machines writing at once
One machine
A crash mid-session
Volume outlives the machine
Fork a workspace
Snapshot, then lazy restore
Where it lives
Your account, one zone

Shared NFS (EFS, S3 Files)

Open from another machine
Any NFS client
Machines writing at once
Many clients
A crash mid-session
Survives once flushed
Fork a workspace
Copy the files
Where it lives
Your account, one region

Archil

Open from another machine
Any machine, S3 API, or SDK
Machines writing at once
Up to 5,000 clients
A crash mid-session
Survives once fsync() returns
Fork a workspace
13 ms checkpoint, 33 ms branch (managed disks, AWS)
Where it lives
Your region, bucket, or cloud
How latency is measuredCompare Archil with sandbox providers

Give your next tenant a disk.

Talk to an integration specialistStart building