AWS Nitro Sandboxes give every EKS pod its own hardware-isolated VM at no extra cost
On 9 November 2026, AWS launched Nitro Sandboxes, lightweight VMs managed by the Nitro hypervisor that give every EKS pod, ECS task, and lightweight VM its own hardware-isolation boundary, at no additional charge. For teams running untrusted, multi-tenant, or LLM-generated code, this is hypervisor-level isolation you can enable in one line without changing your stack.
9 November 2026. AWS announces the general availability of Nitro Sandboxes, lightweight VMs managed by the Nitro hypervisor. The same day, the EKS, ECS, and EC2 documentation is updated, and the Compute blog post details the use. No extra charge: the service is included on most Nitro instances in all commercial regions. Why it matters: for the first time, every pod or task can inherit the hardware isolation of the Nitro hypervisor — the same boundary that already isolates EC2 instances from each other — without rearchitecting, without a dedicated machine, and without added cost.
Closing the container-isolation gap with hardware
For years, the default isolation of a Kubernetes pod or an ECS task has been the container’s: a shared kernel, namespaces, and cgroups. That is enough for trusted workloads but insufficient the moment you run untrusted code, multi-tenant workloads, or regulated workloads that demand a harder boundary. The classic fix — one instance per tenant, or one hypervisor per workload — costs density and complexity.
Nitro Sandboxes changes the equation by placing each workload inside its own hardware-isolated VM, driven by the Nitro hypervisor. The result reads simply: a pod that escapes its container cannot reach the host kernel, because that pod’s host is no longer a shared machine but a dedicated hardware boundary. Performance stays near-native to EC2, and isolation inherits the same Nitro System that already secures instances from one another.
One line of configuration, nothing else to change
The most striking part is the adoption effort. Enabling Nitro Sandboxes on EKS or ECS is a one-line change, and each pod or task gets its own VM without rewriting anything: Pod Identity, the VPC CNI, EBS/EFS/S3 storage, and CloudWatch all keep working out of the box. That is what separates the product from yet another component: it imposes no new control plane and no migration of your operating chain.
For those who want full control, Nitro Sandboxes also runs directly on EC2 with your own AMI, orchestration, and virtual machine monitors (VMMs). Amazon Linux and Firecracker are supported natively, and patches for other options are already available. The same building block therefore serves two audiences: the platform team that wants per-pod isolation without thinking about it, and the infrastructure team that wants to build its own layer on top.
Attestation, the piece that secures secrets
Hardware isolation only pays off if you can prove who is running. Nitro Sandboxes adds cryptographic attestation: secrets are released only to sandboxes that have proven their integrity. That is the missing link in hand-rolled “VM per workload” strategies — a workload can demonstrate its identity before receiving a key, rather than receiving it by network position alone.
The property opens a specific use case: running LLM-generated code in an isolated environment. Instead of letting an AI agent run on the machine that holds the secrets, you isolate it in an attested sandbox, where any escape stays confined to its VM. AWS pushes exactly this scenario: execute model-generated code safely while improving utilization by sharing a single EC2 instance across multiple agentic workloads.
The isolation also composes with existing controls: on EKS, sandboxed pods support encrypted images and per-pod policy enforcement, so the boundary is not just hardware but policy too. A pod that cannot even mount its own image without the right keys raises the bar, for attackers and misconfiguration alike.
Why now, and what remains to measure
The other driver is economic. One AI agent per workload, isolated in its sandbox, enables densification: several tenants or several agents share a single EC2 instance without seeing each other, turning an over-provisioned machine into usable capacity. For FinOps teams, that is the exact counterpart of the zero surcharge: hardware isolation stops being a luxury reserved for regulated workloads.
The timing is not a coincidence. The rise of AI agents — which run code, read files, and call APIs on the user’s behalf — makes default isolation untenable: handing an agent a shared container means handing it the keys to the node. Nitro Sandboxes answers exactly that need, which explains the “no additional charge” positioning: AWS is nudging agentic workloads toward an isolated model without taxing it.
In practice, one cost remains to measure: starting a sandbox adds a slight cold start overhead over a bare container, and the image must be available on the node. For long-lived workloads — an agent processing a file, a resident tenant — that cost is negligible; for short-burst serverless, benchmark it before generalizing.
Nitro Sandboxes versus gVisor and microVMs
The per-workload isolation field is not empty: gVisor intercepts syscalls, Kata Containers wraps each pod in a microVM, and Firecracker already powers AWS Lambda and Fargate. Nitro Sandboxes stands out on two points: native EKS/ECS integration — one line, not a runtime to install or a node to reconfigure — and cryptographic attestation tied to the Nitro System, which purely software solutions lack.
The trade-off is symmetric. Where gVisor runs with no special hardware requirement, Nitro Sandboxes assumes Nitro instances, which excludes older types and some bare metal. And where Kata lets you choose your hypervisor, Nitro Sandboxes stays bound to the Nitro hypervisor — not a weakness if you are already on AWS, but it limits portability outside Amazon’s cloud.
What it does not solve
Nitro Sandboxes isolates each workload from the others and from the node, not the bill or the governance. A sandbox runs on your instances: you still pay for the machines, and sharing one instance across several sandboxes is precisely what lowers that cost. For the strictest regulated cases — physical separation between customers, a contractual dedicated-instance requirement — a sandbox on a shared instance will not replace a dedicated instance or a separate account. Hardware isolation is a complement to the per-account or per-instance isolation model, not a universal substitute.
The verdict
If you run untrusted, multi-tenant, or LLM-generated code on EKS or ECS, enable Nitro Sandboxes: per-pod hardware isolation comes in one line, at no extra cost and with no migration, and attestation secures secret release. That is the scenario with the best effort-to-benefit ratio — you harden the boundary without touching your operating chain.
But if your workload is already isolated by account and by instance, or runs on non-Nitro instance types, don’t force adoption. First confirm your instances are Nitro (availability covers “most” of them), measure the impact on latency-sensitive workloads, and treat Nitro Sandboxes as a defense-in-depth layer — not the only boundary in a regulated scenario that demands instance or account separation.
References
- AWS What’s New — Introducing AWS Nitro Sandboxes on Amazon EKS, ECS and EC2 (9 November 2026)
- AWS Compute Blog — Nitro Sandboxes: hardware isolation for every EKS pod, ECS task, and EC2 workload
- EC2 documentation — Isolate workloads with AWS Nitro Sandboxes
- EKS documentation — Sandboxing on Amazon EKS with isolated and confidential pods