# Archil for agent platforms: a disk for every tenant, open from any machine

Source: https://archil.com/solutions/agent-platforms

Give each tenant a durable Archil disk that mounts in whichever sandbox runs the agent, opens from your backend and app, and branches in milliseconds when the agent needs a few attempts.

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 specialist](https://cal.com/team/archil/demo)[Read the docs](https://docs.archil.com/getting-started/introduction)

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](https://docs.archil.com/mounting/linux#requirements).

## 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](https://docs.archil.com/details/comparison#benchmark-against-amazon-efs)

### 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](https://docs.archil.com/sdks/typescript)

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](https://docs.archil.com/concepts/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](https://archil.com/guides/building-agents/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

Workspace size

5 GiB

256 MiB100 GiB

Attempts

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](https://docs.archil.com/reference/limits), 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](https://docs.archil.com/administration/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](https://docs.archil.com/reference/byoc)

SOC 2 Type II, AES-256 at rest, TLS 1.2 or higher in transit. [Security](https://docs.archil.com/details/security).

## How the options compare.

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

Ways to keep an agent's workspace, compared
| Property | Pause-and-resume sandbox | Vendor's volume | Block volume per tenant | Shared NFS (EFS, S3 Files) | Archil |
| --- | --- | --- | --- | --- | --- |
| Open from another machine | Resume it first | Only that vendor's sandboxes | Only the attached machine | Any NFS client | Any machine, S3 API, or SDK |
| Machines writing at once | One sandbox | One, or vendor's sandboxes | One machine | Many clients | Up to 5,000 clients |
| A crash mid-session | Saved on stop; crashes rarely documented | Varies; check what fsync() means | Volume outlives the machine | Survives once flushed | Survives once fsync() returns |
| Fork a workspace | From a snapshot, mostly | Some copy the volume | Snapshot, then lazy restore | Copy the files | 13 ms checkpoint, 33 ms branch (managed disks, AWS) |
| Where it lives | Vendor's storage and region | Vendor's storage, the sandbox's region | Your account, one zone | Your account, one region | Your region, bucket, or cloud |

### 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 measured](https://docs.archil.com/reference/benchmarks/latency)[Compare Archil with sandbox providers](https://archil.com/compare/sandbox-providers)

## Give your next tenant a disk.

[Talk to an integration specialist](https://cal.com/team/archil/demo)[Start building](https://console.archil.com)

-   [Guide: storage for agents](https://archil.com/guides/storage-for-agents)
-   [Guide: how to build agents](https://archil.com/guides/building-agents)