The serverless runtime for intelligence.

Sandboxes and durable disks for AI. Run code on demand, keep files between calls, and share data across your stack.

Start building
Illustration: one cable of fine lines, the shared data, runs unbroken across the page. Four groups of strands lift out of it and fall back in, labeled research, training, analytics, and agents. Each works from the same data and returns what it produces, notebooks, checkpoints, results, and traces, to the same cable.

Powering millions of agents each week. Trusted by teams at

  • Agents

    • ClayClay
    • Gamma
    • Gumloop
    • Cobbery
    • Concourse
  • CI/CD

    • Depot
  • ML research

    • microAGI

Get started with a few lines of code.

Read the docs
// Install: ai@7 disk @archildata/ai-sdk
// Set ARCHIL_API_KEY, ARCHIL_REGION, and AI_GATEWAY_API_KEY.
import { generateText, isStepCount } from "ai";
import * as archil from "disk";
import { createDiskTools } from "@archildata/ai-sdk";
 
const { disk: agentDisk } = await archil.createDisk({ name: "agent-workspace" });
 
// Give the agent your whole filesystem as tools
await generateText({
model: "anthropic/claude-sonnet-4.6",
prompt: "Write a short story, format it nicely and save it as story.pdf",
tools: createDiskTools(agentDisk),
stopWhen: isStepCount(30),
});
 
// Read the saved file after the agent finishes
const story = await agentDisk.getObject("story.pdf");
import * as archil from "disk";
 
const { disk } = await archil.createDisk({ name: "analytics" });
 
// Call 1: write a small CSV to the disk
await disk.exec("printf 'region,revenue\\nwest,120\\neast,95\\nwest,80\\n' > /mnt/archil/sales.csv");
 
// Call 2: a fresh microVM summarizes it with stdlib Python
const { stdout } = await disk.exec(`python3 - <<'EOF'
import csv
from collections import Counter
totals = Counter()
for row in csv.DictReader(open("/mnt/archil/sales.csv")):
totals[row["region"]] += int(row["revenue"])
print(dict(totals))
EOF`);
 
// Example stdout: {'west': 200, 'east': 95}
import * as archil from "disk";
 
// Prerequisites: ARCHIL_API_KEY in your CI secrets, an existing disk,
// and a repository the exec microVM can clone. Steps run for up to 5 min.
const disk = await archil.getDisk("dsk-abc123");
const checkout = `/mnt/archil/build-${crypto.randomUUID()}`;
 
// Step 1: clone and build in a fresh microVM
const build = await disk.exec(
`git clone https://github.com/your-org/app.git ${checkout} && cd ${checkout} && npm ci && npm run build`
);
if (build.exitCode !== 0) throw new Error(build.stderr);
 
// Step 2: a later step tests the same checkout, already on the disk
const test = await disk.exec(`cd ${checkout} && npm test`);
if (test.exitCode !== 0) throw new Error(test.stderr);
# Prerequisite: an existing disk, "training-data", that already holds
# your dataset, and a mount token for that disk.
 
# On your own GPU host: install the client
curl -s https://archil.com/install | sh
 
# Mount the dataset read-only
sudo mkdir -p /mnt/training-data
export ARCHIL_MOUNT_TOKEN="<disk-token>"
sudo --preserve-env=ARCHIL_MOUNT_TOKEN archil mount training-data /mnt/training-data \
--region aws-us-east-1 --read-only
 
# Your training job reads it like any local directory
ls /mnt/training-data

Everything agents need to work with real data.

Give your agent a bash tool.

Each call runs Bash, Python, or Node against the disk on demand, and the files it writes are there for the next call. Need a server that stays up? Use a persistent sandbox.

They approached sandboxes from the perspective of data, not compute — and it's beautiful. This is serious engineering.
Andy Jefferson
Member of the Technical Staff
microAGI

One file system, from prototype to petabytes.

Give every agent its own disk.

A disk per user, session, or task, mounted in your sandboxes or ours.

50 ms

to mount a disk

Stream datasets straight from S3.

A shared SSD cache in front of your bucket feeds every node at local speed.

5 GB/s+

read throughput per disk

Make small‑file work fast.

Source trees and package installs run at block‑storage speed, not NFS speed.

<1 ms

small-file reads, even on a cache miss

Every number above is on our published limits page, with a two‑minute script that reproduces the latencies on your own account.

See the limits and the script

Run here. Work from anywhere.

Archil runs tool calls and sandboxes beside a durable, shared filesystem. Your servers and applications work on the same files.

Inside Archil, serverless tool calls and persistent sandboxes run beside one durable shared filesystem. A request starts a tool call that runs python report.py, writes reports/report.pdf, and exits. One of your servers, connected over POSIX, runs python eval.py and adds reports/results.csv. Your application, connected over the S3 API, reads both files. The files stay on the filesystem after the tool call finishes.

Local-disk speed, S3 economics.

Archil keeps hot data on SSD and cold data in object storage. Connect an existing S3 bucket, or start with managed storage. With your own bucket, every file is an ordinary S3 object that any S3 tool can read without Archil.

Faster package installs

npm ci, 598 packages: 7.6 s on Archil, 86.3 s on Amazon EFS

11×

Archil
Amazon EFS1×

Faster small reads

4 KiB cache-miss read: 0.5 ms on Archil, typically 10 to 30 ms from S3

20×

Archil
Amazon S31×
99.99%availability design target
SOC 2 Type IIHIPAAEncrypted at rest & in transitYour bucket stays readable without ArchilBYOC available

Every benchmark uses only the public API, the released CLI, and standard tools like fio, git, and npm, and the published results include the tests we lost.

Teams build on Archil so they can stop building storage.

ComputeSDKComputeSDK
Archil gave us a single filesystem layer that works identically across the 10+ providers ComputeSDK orchestrates. Our users stopped thinking about where their files live — that's exactly the point.
Garrison Snelling
Founder
This is my trifecta of a new-gen cloud — Archil for storage, compute alongside it, and a database. It just fits together.
Darren Shepard
Chief Architect
Obot
Biggest surprise for me was Archil's speed. Incredible tech, and it should have more visibility with AI-native teams.
Michael Chomsky
Founder
SetupClaw