AWS Nitro Sandboxes isolates each EKS pod in a microVM with a single configuration line

- Reading
- 6 min
- Tables
- 1
AWS launched Nitro Sandboxes, a feature that runs each EKS pod, ECS task, or EC2 workload inside its own microVM with a separate kernel. The change in a Kubernetes cluster comes down to a single field in the pod manifest.
AWS announced Nitro Sandboxes on November 16, 2026, a feature that places an Amazon EKS pod, an ECS task, or an EC2 workload inside a lightweight virtual machine with its own kernel, isolated from the rest of the EC2 instance by the Nitro hypervisor. In Kubernetes, the entire change fits into a single manifest field: runtimeClassName: isolated-sandbox or runtimeClassName: confidential-sandbox.
The feature is available in all commercial regions at no additional cost. AWS targets workloads where the tenant or the code it runs is not trusted, and cites coding agents as the first use case, according to the AWS blog launch post.
How the microVM gets into the pod's path
According to the Amazon EKS documentation, a containerd-shim-nitro-sandbox-v2 process on the parent instance boots a Firecracker microVM as a first-level guest, with hardware-assisted virtualization. Inside that VM, an agent runs the pod's containers with its own containerd, and the two sides communicate via virtio and vsock.

The result is a sandbox that shares neither kernel nor memory mapping with the parent instance or with any neighboring sandbox, while the containers themselves come up unchanged. In EKS Auto Mode, both RuntimeClasses already come ready in every cluster, and sandbox-capable nodes spin up on demand. In standard EKS, the team needs to build a sandbox-enabled AMI for the node groups or for Karpenter.
Isolated or confidential: the difference lies in who is trusted
The two modes solve different problems because they invert which side of the boundary is treated as trusted:
- Isolated mode: trusts the parent instance and distrusts the guest. That's why
kubectl exec, logs, and process listing keep working normally. - Confidential mode: treats the parent instance as untrusted and moves policy enforcement inside the VM. A Cedar policy generated from the pod spec pins the image digest, arguments, environment variables, mounts, and capabilities;
execandstdinare blocked; the Nitro Secure Module measures image and policy into PCRs; and a KMS key policy only releases secrets to a sandbox whose measurements match.
In confidential mode, image layers can also be encrypted, so that the parent instance only handles ciphertext it never reads. This chain of trust only holds, however, if someone checks the measurements: AWS's own documentation warns that, without a KMS policy or an external verifier checking the PCR values, "the attestation measurement is recorded but never verified, and the confidentiality guarantees of confidential mode are incomplete."
the attestation measurement is recorded but never verified, and the confidentiality guarantees of confidential mode are incomplete.
Amazon EKS User Guide documentation
A third option, independent of the two modes, is the network isolation annotation: it brings up the sandbox with no network device at all, which removes DNS, NTP, IMDS, and Pod Identity, and breaks HTTP and TCP probes that depend on the network.
What the AWS blog doesn't highlight, according to an AWS Container Hero
Carlos Santana and Trishi Mehta, authors of the AWS post, sum up the feature's proposal like this:
Each pod gets its own operating system, completely separate from the host and from every neighbor.
Carlos Santana and Trishi Mehta, AWS
Sandip Das, recognized as an AWS Container Hero, read the same documentation and pointed out what isolated mode leaves up to the operator: protection only runs in one direction, so a compromised parent instance can still observe or tamper with unencrypted traffic and DNS, write to the pod's /etc/hosts, and issue Pod Identity credentials to any pod on the node.
the protection only runs in one direction
Sandip Das, AWS Container Hero
Das also lists prerequisites that the launch post doesn't mention: Kubernetes 1.36 or later, a launch template with Nitro Enclaves enabled on managed node groups (without it, sandboxed pods get stuck in Pending), and using Pod Identity instead of IRSA for credentials. On AWS's promise of "near-native" performance, he recommends treating it as a vendor claim and measuring boot latency, I/O throughput, and tail latency before trusting it.
as a vendor claim
Sandip Das, AWS Container Hero
The limits: no GPU and reduced density
AWS's considerations page lists the launch's restrictions, and the biggest one is GPU and device passthrough, which isn't supported because Firecracker can't pass host devices through to the guest; GPU pods therefore run without the sandbox class.
Density also has two simultaneous ceilings:
- The total number of sandboxed vCPUs can't exceed five times the node's vCPU count.
- The number of sandboxes follows the same limit, but it's cut in half on instance types with CPU overcommit.
In practice, this gives a 4-vCPU node room for twenty 1-vCPU sandboxes or five 4-vCPU sandboxes. Simultaneous multithreading (SMT) costs more than the arithmetic suggests: core scheduling prevents two sandboxes from sharing the sibling threads of the same core, which leaves roughly half of the advertised vCPUs effectively usable. Graviton instances, with one thread per core, don't suffer this penalty.
How this compares to GKE Sandbox
The closest comparison in the market is Google's GKE Sandbox, which has offered the gvisor RuntimeClass since 2019 and, more recently, a microvm class built on Kata Containers and Cloud Hypervisor.
| Feature | AWS Nitro Sandboxes | GKE Sandbox (gVisor) | GKE Sandbox (microVM) |
|---|---|---|---|
| Isolation technique | Firecracker microVM with its own kernel | user-space kernel intercepting syscalls | microVM with Kata + Cloud Hypervisor |
| Boot time | not detailed by AWS | under 200ms | 1 to 2 seconds |
| GPU support | no, at launch | CUDA on a subset of GPUs | no |
| Resources per pod | variable, limited by node density | variable | fixed: 250 mCPU and 130 MiB per pod |
AWS chose the VM side of that split and expressed the cost of isolation in node density and CPU threads, rather than in fixed per-pod resources, as Google does in the microVM option.
What changes for teams running clusters in Brazil
For teams that already run EKS, the first practical effect is that strong isolation no longer depends on running the whole cluster on dedicated instances or adopting an extra runtime layer on their own: it's enough to declare runtimeClassName on the pod, as long as the node group has the right AMI and Kubernetes is on version 1.36 or above.
This changes the calculus for anyone currently isolating third-party workloads, CI pipelines, or AI agents with namespaces and network policies, since those controls don't stop a compromised process from escaping the shared kernel. Before migrating anything sensitive to confidential-sandbox, though, it's worth checking whether there's actually a KMS policy or an external verifier checking the PCRs: without that, AWS's own documentation admits the confidentiality guarantee doesn't hold.
For anyone evaluating the feature for remote IDEs, multi-tenant CI builds, or coding agents (the cases AWS cites first), the open-source agent-sandbox project offers pools of pre-booted VMs that deliver a ready machine in about two seconds, which directly tackles the boot latency that usually counts against VM-based isolation for this type of workload.
Translated from the Brazilian Portuguese original · Read the original
Uber creates framework to decide whether an AI agent's action is appropriate in context
The company detailed a framework that goes beyond identity and API permissions to assess whether an autonomous agent's action makes sense in context, covering the agent's entire lifecycle.







