CNCF AI TCG · November 2026 · Chaoyi Huang

Sandswap — ultra efficient sandboxes for AI agents

Different AI agents share and reuse the same strongly-isolated microVM at millisecond granularity — cutting agent execution-environment cost by 50–100×.
Cold path — mount + exec
≈2.3 ms
P95 gateway E2E · bare-metal KVM
Warm path — still mounted
≈0.96 ms
P95 gateway E2E · sticky-lease hit
Async swap-out
≈3.1 ms
off the response path · zero residue
Reuses per microVM
183 /s
ideal benchmark · A→B rotation ≈ 6 ms
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap1 / 18

01The problem: isolation is priced per second — agents need it for milliseconds

LLM thinking — seconds to tens of seconds
measured floor: minimal-token tool round trip P95 1.06–1.18 s (no real reasoning) ◀ tool exec ≈ 2 ms (e.g. read a 1 MB file) — sandbox needed only here
  • Agents run generated, untrusted code → need hardware isolation
  • One sandbox per agent → isolation sits idle ~all the time
  • suspend/resume VM-per-request → 50+ ms latency overhead · extra snapshot/restore complexity
  • Amortize via session-level suspend/resume → deeper idling · overcommit → bursty load → CPU / memory contention
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap2 / 18

02Core idea: swap the disk, not the machine

Compute and disk decoupled — the microVM is pure compute; the agent's disk is a directory.
microVM · CLEAN
kernel + warden (PID 1)
no mount · no processes
① swap in A
set-fs + guest mount
→
microVM · IN USE
A mounted · executing
allowed_dirs = [sf-a51f3c]
② swap out — async ≈3.1 ms
unmount + clearing chain
→
microVM · CLEAN
kernel + warden (PID 1)
no mount · no processes
③ swap in B
set-fs + guest mount
→
microVM · IN USE
B mounted · executing
allowed_dirs = [sf-b7e2d9]
↕ virtio-fs
↕ virtio-fs
— no active SandFS —
sf-a51f3c
agent A's SandFS — active
— no active SandFS —
sf-b7e2d9
agent B's SandFS — active
top row — one microVM over time (compute)
bottom row — volumes/ (storage)
dashed = nothing mounted
microVM = compute · SandFS = disk
  • Swap in = filter swap (~0.2 ms) + bind-mount — no boot, no copy, no snapshot
  • SandFS = the agent's persistent filesystem — everything it keeps: files, code, workspace/, home/ · storage backend: local disk · NFS · CephFS · Cloud FS, …
microVM redefinition: no task, no disk.
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap3 / 18

03Architecture — built from scratch

control plane
human gateway · prov sandlot · etcd — identities, templates, ownership
exec plane
gateway → sandlot → sandvmm → microVM (warden) — every agent command
storage plane
volumes + templates trees — prov writes · nodes access via virtio-fs
roles — concepts.md
gateway & sandlot: split by role — exec / human gateway · exec / prov sandlot — or one merged instance
sandvmm = VMM — fork + trim + dedicated extensions · warden = PID 1
             AI agents                             operators
(HTTP :3000 / MCP, same listener)         (human API :3100 when split)
             │                                         │
             ▼                                         ▼
   ┌───────────────────┐                     ┌───────────────────┐
   │ exec gateway      │                     │ human gateway     │
   │ agent+MCP :3000   │                     │ human API :3100   │
   │ stream :9998      │                     │ prov stream :9998 │
   │ auth · ownership  │                     │ SandFS CRUD ·     │
   │ sticky lease      │                     │ templates CRUD    │
   └──────────────┬────┘                     └───┬───────────────┘
      ▲           │                              │     ▲
      │           │ownership               SandFS│     │ gRPC bidi stream
      │           │routing state           state │     │ (sandlot dial out)
      │           │     ┌───────────────┐        │     │
      │           │     │ sandns [opt.] │        │     │
      │           │     │ on DNS :53    │        │     │
      │           │     └──────▲────────┘        │     │
      │           │            │watch,read-only  │     │
      │           │  ┌╌╌╌╌╌╌╌╌╌┴╌╌╌╌╌╌╌╌╌┐       │     │
      │           └─►│    etcd [EXT]     │◄──────┘     │
      │              │    (multi-gw)     │             │
      │              └╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┘             │
      │ gRPC bidi stream(sandlot dial out)             │
┌─────▼─────────────────────────┐       ┌──────────────▼──────────────────┐
│ node × N — exec sandlot       │       │ instances × M — prov sandlot    │
│ sandvmm · microVMs (warden)   │       │ sandfs + template lifecycle     │
│ one SandFS per microVM        │       │ OCI pull/push [EXT]             │
│ at a time                     │       └──────────────┬──────────────────┘
└─────┬─────────────────────────┘                      │
      │ virtio-fs passthrough                          │ volume + template writes
      │ — only the active agent's                      │
      │ directory                                      │
      ▼                                                ▼
┌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┐
│      volumes + templates — one directory per SandFS                      │
│      local disk, or Cloud FS / NFS / CephFS / ... [EXT]                  │
└╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┘
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap4 / 18

04Topologies

Same binaries compose into four bare-metal shapes — then Kubernetes repackages the same topology.
one machine — in-memory
AI agentsoperator
▼▼
one machine
gateway
(single-node)
sandlot (exec+prov)
sandvmm
microVM (warden)
SandFS volumes — local disk
one machine — etcd
AI agentsoperator
▼▼
one machine
exec gateway
etcd [EXT]
human gateway
sandlot (exec)
sandvmm
microVM (warden)
sandlot (prov)
SandFS volumes — local disk
one gateway + N nodes
AI agentsoperator
▼▼
gateway host
exec gateway
etcd [EXT]
human gateway
exec nodes ×N
sandlot (exec)
sandvmm
microVM (warden)
prov nodes ×M
sandlot (prov)
SandFS volumes — shared FS
production — multi-GW + DNS
agentsoperator
▼▼
sandns ×2+
exec gateways ×2+
human gateways ×H
etcd ×3 [EXT]
exec nodes ×N
sandlot (exec)
sandvmm
microVM (warden)
prov nodes ×M
sandlot (prov)
SandFS volumes — shared FS
PlatformEmbeddedBoxout
Bare metal✓ (the only mode)—
Kubernetes✓✓
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap5 / 18

05Design principles: the contract every change must preserve

Deliberately independent of implementation, timer values, and file paths — the principles do not change as the code evolves.
P1
Everything persists
all meaningful AI agent state durable — resume after any failure
P2
Minimal E2E latency
gateway → sandlot → warden at the transport limit · no hot-path locks
P3
Minimal swap cost
swap-in on the critical path · swap-out in the background
P4 — SAFETY CORE
Never double-mounted
one SandFS on one microVM — at any instant, anywhere
P5
One sandlot, one gateway
a single outbound stream at any moment
P6
Sandlots stick, fail slow
switch gateway only after a bounded timeout
P7
Agents stick, fail slow
same time-gated failover — never flap
P8
Directories, not backends
any shared FS · any node serves any SandFS
together they guarantee: never double-mounted · resilient to failures · latency at the transport limit
weakening any one weakens the rest — all must hold
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap6 / 18

06SandFS: the agent's persistent filesystem — two modes

The microVM is the compute; the SandFS is the disk. Each agent owns one or more SandFS instances — everything it keeps lives here.

Flat — the build mode

chroot /mnt/rootfs — the whole volume, read-write
├─ template files → writable copy — /usr /etc /bin all persist
├─ /workspace     → plain dir in the volume (cwd)
├─ /home/agent    → plain dir in the volume
└─ /tmp           → plain dir in the volume — persists
  • apt / yum work — 10 ambient caps
  • seeded from local or OCI template
  • freeze → becomes a new template

Overlay — the serve mode

chroot /mnt/rootfs
├─ template files → read-only overlay (kernel-enforced)
├─ /workspace     → writable bind → volume
├─ /home/agent    → writable bind → volume
└─ /tmp           → fresh tmpfs — node-local, never shared
  • no upperdir/workdir → runs on any shared FS
  • layers extracted once, shared by all instances
  • zero capabilities — Strict profile
① build flat template — chroot-able rootfs, offline
→
② agent builds — flat SandFS · apt / pip
→
③ freeze — save-as-template → read-only base
→
④ publish — OCI artifact (optional, cross-site)
→
⑤ serve — overlay ×N · shared base + private workspace
  • Persists across swaps, VM recycle, node migration — pip / npm / files all survive
  • overlay SandFS: detach / attach template — swap the read-only base without losing agent work (workspace/ · home/ live in the volume)
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap7 / 18

07Swap-in: cold path — filter swap + mount & exec in ONE vsock round trip

A cold request lands on an idle microVM from the warm pool — the request path contains no boot.
 agent           gateway                sandlot             sandvmm       warden (PID 1)
   │ POST /execute  │                      │                   │                │
   ├───────────────►│ auth · claim · node  │                   │                │
   │                │ · open sticky lease  │                   │                │
   │                ├─────────────────────►│ bind idle pool VM │                │
   │                │                      ├─ vm.set-fs ──────►│ allowed_dirs   │
   │                │                      │                   │ = [B]  ~0.2ms  │
   │                │                      ├──── OP_MOUNT_AND_EXEC ────────────►│ mount stack ·
   │                │                      │                   │                │ chroot · exec
   │                │                      │◄─────────── result + output ────────┤
   │◄───────────────┤◄─────────────────────┤                   │                │
   │                │                      │ pool refills asynchronously        │
  • Mount + exec — one vsock RTT · cold path: one OP_MOUNT_AND_EXEC ≈ 2.3 ms · warm path: one OP_EXEC ≈ 0.96 ms
  • Ordering: filter before mount · stale mount out before filter swap — never stack
  • Egress identity published before the first guest process
  • Starved pool → fail fast NO_AVAILABLE_SANDBOX · refill async
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap8 / 18

08Swap-out: the clearing chain — async, ordered, fail-closed

Off the response path · ≈3.1 ms P95 · 100% < 5 ms even with 16 MB dirty pages.
1 · warden
gate (write)
wait out in-flight sync execs / file ops
2 · warden
cgroup.kill
SIGKILL the agent's whole process tree, poll empty
3 · warden
rule-A sweep
SIGKILL every live userspace process except PID 1
4 · warden
child mounts
home, workspace, resolv.conf + busybox file binds
5 · warden
masked mounts
proc covers, dev/pts, /dev/shm, /dev, proc, /tmp
6 · warden
umount /mnt/rootfs
flush dirty pages, detach the mount
7 · warden
drop_caches=3
evict clean pagecache + dentries + inodes
8 · warden
kernel-object sweep
SysV IPC, user keyring
9 · warden
socket sweep
dead-state TCP sockets, flush the neighbor table
10 · warden
final-state gate
zombie / D-state above PID 1 fails the unmount
11 · sandlot
set-fs clear
allowed_dirs = [] · bookkeeping · egress revoked
12 · outcome
VM CLEAN
back to pool — or destroyed
  • Unprovable teardown → VM destroyed & replaced, never reused — boot cost stays off the path
  • No MNT_DETACH — EBUSY → VM destroyed · filter clear runs after guest unmount · every mount step has its teardown twin
  • Recycle bounds (uses / mounts / agents / memory) = hygiene, not correctness
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap9 / 18

09Swap-out: zero residue — nothing of A survives into B

The hard part is not the mount — it is proving the machine is empty. Every leak vector has a named close.
Leak vectorClosed by
live processes / setsid stragglerscgroup.kill + rule-A sweep
zombie / D-state taskfinal gate → VM destroyed
tmpfs · /dev/shm · /tmp contentunmounted with contents — fresh for B
dirty pagesumount flush + detach
clean pagecache / dentriesdrop_caches=3
SysV IPC · keyring · mqueuesweep + seccomp denial
dead-state TCP tuplessock_diag destroy
ARP / neighbor entriesRTM_DELNEIGH flush
stale virtio-fs handlesrevocation epoch → ESTALE
freed memoryno path names A · pages zero-filled
  • Memory guarantee: no process · no fd · no page · no kernel object names A
  • Central invariant — one SandFS per microVM, enforced ×4: cluster · node · MOUNT_GATE · chroot
  • Residues by design: aggregate netns counters · machine-reuse linkability — documented
  • All pinned by e2e suites — cross-tenant residue · hostile warden · share-root escapes
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap10 / 18

10Guest kernel hardening: the kernel is the trust root under the swap

The kernel executes every in-VM clear — an implant would survive tenant switches. Every layer below cuts its probability or its reach.

Shrunk at build time — kernel/build.sh

  • Compiled out: USER_NS · TUN/VETH · KVM · BPF · IO_URING · USERFAULTFD · OVERLAY_FS · POSIX_MQUEUE · PROC_KCORE · ZSWAP · DEVMEM · x32 ABI …
  • Hardened in: UMIP · no legacy vsyscall · hardened usercopy · init_on_alloc
  • Backports: 17 stable fixes on pinned v7.2.8 (cloud-hypervisor 2026-10-09) — TCP synack UAF · skb/UDP/IPv6 UAF & csum · futex hash UAF · AIO recursion · netlink net_cookie
  • Gates: config check + nm symbol probe — a re-enabled symbol fails the build

Runtime posture

  • max_user_namespaces=0 — belt and braces
  • init_on_alloc default-on — zeroed allocations; init_on_free optional (fresh RAM already zero)
  • no vsock loopback transport → in-guest connect() = ENODEV
  • kernel + initramfs = pinned upstream artifact — guests can't influence boots

What agent code can ask of it — per-exec fence

  • seccomp deny 82: mount API · unshare/setns · ptrace class · bpf · perf · keyring · mqueue · modules · NUMA
  • sched / prlimit calls: self-target only (warden shares uid 0)
  • NO_NEW_PRIVS · caps ∅ (strict) / 10 (install)
  • balanced cBPF tree — log₂N comparisons, length unchanged

Blast radius — bounded by policy

  • compromise reads this VM's volumes only — never fleet-wide
  • affinity_vms 3 · max_distinct_agents 300 · max_mounts 10k · max_uses 100k
  • egress-only network · per-agent identity on every flow
  • high-security answer: dedicated cluster
  • TODO — make destroy-after-every-use practical: boot is only kernel + warden, inherently lightweight — once boot reaches the ms range (≈ swap-out cleanup), destroy-after-every-use drops the kernel-implant risk to its minimum
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap11 / 18

11Isolation · four layers (1/2): inside the machine — the warden & the VMM filter

The warden decides what can be named; the filter decides what exists — a sibling tenant is ENOENT, not merely forbidden.

Layer 1 · warden — PID 1, in-VM

why it isolates: a process can only name the current mount — the namespace root is the SandFS
mount stackshare mounted once (nosuid,nodev) · active volume → /mnt/rootfs · chroot
read-only rootfsoverlay: a kernel mount property — not a permission bit
modefrom the identity record — never probed from agent-writable disk
hardeningmasked /proc · minimal /dev · fresh tmpfs /tmp · read-only busybox
MOUNT_GATEone mount at a time · volume identity re-checked
per-exec fencesetsid · NO_NEW_PRIVS · caps ∅/10 · seccomp −82 · RLIMIT 70%
warden itselfPID 1 · dumpable=0 — untouchable

Layer 2 · sandvmm — the virtio-fs filter

why it isolates: a sibling does not exist — off-list lookup = ENOENT
one deviceborn at boot · never hot-plugged · no vm.add-fs · multi-fs refused
allowed_dirsexactly one directory · set-fs ≈0.2 ms · host-side only
aliasper-swap random name — real names = HMAC secrets, never in guest
path rulesone component · openat2(IN_ROOT) · O_NOFOLLOW · inodes as fds
share-root gateevery mutation denied pre-dispatch — exhaustive opcode match
revocationset-fs → inode + handle tables cleared, epoch bump → stale handle = ESTALE
always onempty default · no off mode · failed swap keeps the old list
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap12 / 18

12Isolation · four layers (2/2): the host — nobody is trusted, not even the VMM

One serializer drives a strictly ordered swap with secrets the VMM never sees; every host service — sandlot · sandserv · sandvmm · sandprov — lands on an identity with nothing left to take.

Layer 3 · sandlot / sandprov — per node

why it isolates: one serializer drives a strictly ordered swap — the VMM sees no secrets
bindingone sandfs ↔ one VM · per-VM mount lock
invariant ×4cluster · node · VM · chroot — each alone suffices
orderingfilter before mount · unmount before filter-clear · never stack
hostile-peer wiremount_point pinned · identity re-asserted at exec · bad frame → close, never PID 1
storage writerprov sandlot only · egress identity before mount · revoked at swap-out
volume namessf- + HMAC-SHA256 = 2128 · seed 0640 sandprov · rotation re-keys

Layer 4 · the host — 5 roles + vsockguard

why it isolates: sandlot · sandserv · sandvmm · sandprov — each an identity with nothing to take
5 rolessandlot 985 exec · sandserv 986 credentials · sandvmm 987 zero caps · sandprov 983 storage · sandtmpl 982 templates
vsockguardBPF LSM on connect() — warden port: uid 985 only
warden port ×3guest: no loopback (ENODEV) · vhost: no guest→guest · warden: host CID 2 only
share rootsandprov-owned · VMM group traverse-only · nosuid,nodev
devices/dev/vsock 0600 sandlot · /dev/vhost-vsock 0600 sandvmm
nftablesVM↔VM deny · per-TAP anti-spoof · guest→host default-deny
VMM compromisedthis VM's volumes only — no listing · no guessing · no warden · no writes
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap13 / 18

13Latency engineering: where the milliseconds go

Client round-trip decomposition, P95 in ms — bare metal, single-node HTTP · cold = cross-agent mount_and_exec · warm = sticky-lease hit.
Cold — 2.1 ms total
client → gateway
0.13
gateway → sandlot — auth · lease
0.14
sandlot — set-fs + vsock
0.21
warden — mount + fork/exec
1.69
Warm — 1.0 ms total
client → gateway
0.13
gateway → sandlot
0.14
sandlot — vsock only
0.10
warden — fork/exec only
0.66
00.51.01.52.0 ms
Why the overhead is this low — the design
  • 8 design principles (p.6) drive every hot-path choice — P2 latency at the transport limit · P3 swap-out in the background · P5–P7 stick, never flap
  • All work in memory — the main path never touches slow persistent storage: no boot · no storage op · no etcd I/O
  • Every transport hop cut — 1 gRPC → 1 set-fs (0.2 ms) → 1 vsock RTT · no locks across RPCs — bookkeeping lock only
…and it stays low
  • Swap-out ≈ 3.1 ms — async, never on the response path
  • Distributed ≈ single-node — within noise
  • A→B rotation on one VM ≈ 6 ms
  • Every response carries ns-precision metrics — the platform measures itself
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap14 / 18

14Ownership & resilience: tolerance first, confirmed switching — never double-mounted

agent → sandns → gateway → node → microVM — pure delivery, zero coordination on the command path.

The normal path — routing on two facts

why it is fast: one owner, one node — nothing is re-decided per command
sandnsstateless owner-aware DNS router — decides ownership
ownershipwhich gateway — etcd plain key · no lease · CAS — the never-double-mounted guard · gateway decides placement
placementwhich node — affinity · survives unmount · reconnect · takeover
schedulingbinpack ∥ spread · affinity → filter → score
warm pathsticky lease short-circuits Claim · DNS once per connection

Failure — tolerance first, confirmed switching

why it is safe: no lease expiry → no race — every release path completes before any switch
stream = truththe gateway on a node's live stream holds its whole mount state — nobody else can mount onto that node
connect-cleana node connecting to any gateway proves its old mounts released — the confirmation under both paths
defaultblip → ownership unmoved · 503 + retry · heals in place
anchorswarden countdown: heartbeats only — release ≤ 10 min < T_safe 11 < T_iso 12
owner releasethe living owner confirms → delete keys
migrated takeoverthe living sandlot confirms → CAS overwrite
both deadno living confirmer → safe-stuck · manual reap
etcd partition: fail-closed Claim · self-fence — a partition cannot forge a switch
in-VM: one VM, one SandFS · umount EBUSY → destroy — MNT_DETACH forbidden
agent view: 503 + retry · blips heal in seconds · never double-mounted
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap15 / 18

15Egress enabler: one identity, two carriers — traffic attribution the guest cannot forge

Sandswap sets no network policy — it turns "who is this traffic" into a host-side fact; the vendor's enforcer decides allow/deny. Identity = (agent_id, sandfs_id, mount_epoch, vm_id), resolved at every mount.

Carrier A — binding region · authoritative

why it holds: identity lives host-side, keyed by the TAP — the guest cannot touch it
regionnode-local shared memory · keyed by TAP ifindex · no event stream — readers poll (on-demand read)
shm/dev/shm file 0640 · mmap — any local reader · zero dependencies
bpfBPF_F_MMAPABLE array pinned to bpffs — tc / XDP / eBPF read in kernel context
entrystate · mount_epoch · agent_id · sandfs_id · vm_id
readseqlock — lock-free · torn read detected ⇒ unidentified → default-deny
lifecyclepublish at mount · revoke at unmount · erase at destroy

Carrier B — identity-in-IPv6 · stateless

why it holds: the address is the identity — parsed statelessly anywhere · anti-spoof: knowing ≠ forging
WHERE /64site prefix + 16-bit subnet — one routed /64 per TAP · host = router at ::1
WHO IIDlast 64 bits = the template — comma-separated field:width · widths sum to exactly 64
fieldsagent:32 · sandfs:32 — verbatim id suffix · epoch (low bits) · rand (per mount) · deployment:16=42
layoutsagent:32,sandfs:32 — one stable address per sandfs · agent:32,epoch:16,rand:16 — never repeats
stampall-zero IID at boot → mount flips one SNAT map element · static rule · ≈0.4 / 0.8 ms
degradefailed stamp = unstamped egress — unknown → deny, never a wrong identity
ordering: publish before traffic (no guest process yet) · revoke after process death · switch = new epoch
hot path: one memory-write set ≈0.2 µs per mount · warm exec zero
production must enable one carrier — require_egress_binding
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap16 / 18

16Measured capacity: 183 reuses/s per microVM

Bare-metal KVM · Xeon 8255C — 48 physical cores (96 threads) · pinned cores/NUMA · 1 vCPU / 256 MiB VMs · capacity defined by latency tiers.
Ideal reuse rate
183.95 cold/s
per microVM · zero failures · 5 ms knee
Host total — 32 VMs
5,886 cold/s
one whole physical core per VM
Traffic-shaped
53.06 cold/s
per VM · 2,048 agents queued · 2.0× tier held
Agent density
64 agents/VM
traffic-shaped · 53.06 cold/s × 1.2 s mean think
Scenario — physical-core mappingPer microVMPer hostGate
Ideal paced lanes — pure cold183.95 cold/s5,886 /szero failures at 5 ms knee
Ideal — mixed, 1–3 requests/turn155.96 + 132.25 warm/s4,991 + 4,232 /szero failures at 6 ms knee
Traffic-shaped — pure cold · 2,048 agents53.06 cold/s1,697.8 /s2.0× tier held · 8 ms knee · 64 agents/VM
  • Cost math: 64 agents/VM measured ⇒ ~64× fewer VMs — density scales with think time; ideal ceiling ⇒ ~100× and beyond
  • SMT mapping adds no host capacity — physical-core mapping is the recommendation · raw logs published
  • Core budget: of 48 physical cores — loadgen 4 · gateway + etcd 4 · sandlot 4 · 4 spare for boot-failure replacement — 32 cores run microVMs
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap17 / 18

17Takeaways: Sandswap in five lines

  • microVM = compute · SandFS = disk — kernel + warden in the VM · the agent's whole disk is one host directory
  • Swap the filesystem, not the machine — 2.3 ms cold · 0.96 ms warm · 3.1 ms async out
  • Zero residue — proven at every layer, or the VM is destroyed
  • No isolation traded for speed — hardware VM isolation throughout, plus hardening beyond a plain VM
  • Think in seconds, swap in milliseconds — 183 reuses/s · 64 agents/VM · 50–100× cost cut
microVM redefinition: no task, no disk.
hardware isolation at 1/50 – 1/100 the cost
persistent workspace follows the agent
HTTP + MCP · API key — zero code change
bare metal · Kubernetes
Try it: github.com/ChaoyiHuang/sandswap · docs & quickstart every benchmark reproducible — scripts + raw logs published
Sandswap · CNCF AI TCG · github.com/ChaoyiHuang/sandswap18 / 18
scroll or ← → to navigate · F fullscreen · P print
1 / 18