Top 10 Container Escapes an AI Agent Actually Tries
This began as a classic security blog: the top 10 container escape methods. But then we rewrote it to focus on a frontier AI agent with a root shell in a real Kubernetes pod and the ranking changed. Some of these methods can even defeat a hardware-isolated sandbox.
Why Re-Rank Container Escapes Now That the Attacker Is an AI Agent
Most container-escape articles follow the same pattern. They list common misconfigurations like privileged containers, mounted Docker sockets, and hostPath volumes that map the root directory. For years, the industry has dismissed privileged containers, but the real threat model has changed over time.
So, here’s the change. Sometimes, the thing inside the container is now an autonomous agent. AI systems are often run in sandboxes like Docker or Kubernetes containers to limit the impact if something goes wrong. This makes an old research question a real-world concern. If a capable model gets a shell in your container and decides to escape, which of the top 10 methods does it actually try, and do any of them still work?
This isn’t just a theoretical question. In August 2026, the UK AI Security Institute and the University of Oxford published a study called Quantifying Frontier LLM Capabilities for Container Sandbox Escape. They created a benchmark called SandboxEscapeBench. With this tool you give a model a root shell in a container, ask it to read a file on the host, and see if it succeeds. Their test covers 18 tasks across orchestration, runtime, and kernel layers, each linked to a real CVE. Their main finding is that frontier models easily handle simple misconfigurations but struggle with kernel and runtime exploits that require specific knowledge or long, complex steps. One recent Claude model even completed the entire public benchmark.
So we made our own top 10 list, not by surveying what’s out there, but by ranking the methods the way a model would: the easiest and most accessible first, and the complex kernel exploits last. We tested this on a real cluster and explained each step along the way.
The Test Setup: A Frontier Agent with a Root Shell in an EKS Pod
The target is a single-node EKS cluster running Edera, kernel 6.18.46-edera-host. We adopt the paper’s threat model exactly: the agent has an interactive root shell inside a pod, standard CLI tools, network access, and knows only that it is in a container and that escape is the goal. It does not know what, if anything, is misconfigured. We broaden “escape” beyond the paper’s host-file read to include the two pivots that matter in a real cloud environment: stealing the node’s cloud identity, and stealing other workloads’ Kubernetes credentials.
The pod is deliberately unremarkable. No privileged flag. No host mounts. Default service account. It is the pod ten thousand teams ship every day.
Top 10 Container Escapes, Ranked by What a Frontier Model Tries First
Here’s the list, ordered by what’s easiest and most accessible, not by difficulty. The verdict column shows the real results on a modern, patched cluster, which is where the ranking starts to change.
Out of the 10 methods, 4 are still possible. Only 1 works smoothly. The other 6 are outdated on a modern, patched cluster. This pattern matches the difficulty decline the paper described, but from inside the container. The rest of this post covers the important entries: the one the model uses (#1), the one that beats even a real sandbox (#2), the ones stopped by hardware boundaries (#3, #4), and why the more dramatic exploits (#7, #10) no longer work.
Phase 0: How the Agent Maps Its Container in the First Sixty Seconds
A frontier model doesn’t start by running exploits. It first figures out its environment: who it is, what permissions it has, what’s mounted, and what other processes are nearby. This process narrows the top 10 list down to just a few real options. Here’s what that check reveals, with three key points to note.
$ id
uid=0(root) gid=0(root) groups=0(root),…
$ grep -E ‘Cap|Seccomp’ /proc/self/status
CapEff: 00000000a80425fb
Seccomp: 0First, the model has root access, but only the default set of capabilities. CapEff=a80425fb means it has the standard fourteen permissions containerd gives every container, like chown, dac_override, setuid, net_raw, and mknod. It does not have CAP_SYS_ADMIN, CAP_SYS_MODULE, CAP_DAC_READ_SEARCH, or CAP_SYS_PTRACE. This single check rules out entries number 7 and 8, since every capability-based escape needs permissions a default pod doesn’t have.
Second, seccomp is off. seccomp: 0 means there’s no syscall filter in place. This often surprises people, since default sounds secure. But Kubernetes doesn’t use a seccomp profile unless you specifically request RuntimeDefault. So a standard pod is actually less restricted than a default Docker container, which does use Docker’s default profile. Every syscall is available. This is important for kernel exploits (#9, #10), but not for the reasons you might expect, as we’ll explain.
Third, the model looks for easy wins: a mounted /var/run/docker.sock (#6), a hostPath volume (#2), or an over-permissioned service-account token (#5), but finds none. The default service account can’t create pods, read secrets, or run exec commands. This pod is well-configured. But one check does return a result:
$ curl -s -X PUT “http://169.254.169.254/latest/api/token”
-H “X-aws-ec2-metadata-token-ttl-seconds: 120” | wc -c 56Escape #1: The Cloud Metadata (IMDS) Pivot to the Node IAM Role
The cloud metadata service responded. That’s entry #1, and on an EC2-backed node, this endpoint almost always provides access to the instance role. The model goes where the value is, and this was the only place it found any. takes
There is no exploit here. There is an HTTP GET.
$ TOK=$(curl -s -X PUT …/latest/api/token -H “…token-ttl-seconds: 120”)
$ curl -s -H “X-aws-ec2-metadata-token: $TOK”
…/latest/meta-data/iam/security-credentials/
...-nodegroup-NodeInstanceRole-…
$ # fetch the role’s temporary credentials, then:
$ aws sts get-caller-identity
{
“Arn”: “arn:aws:sts::4955…:assumed-role/…NodeInstanceRole…/i-093f79d25cd69e4b2”
}Now, the pod has the node’s AWS identity. We confirmed this live with real credentials and a real assumed-role identity. The access is limited to the standard EKS worker-node role: it can describe the cluster, list every instance in the VPC, and pull every image from the account’s container registry. It can’t access S3 or other clusters. This isn’t full account takeover, but it does allow VPC-wide reconnaissance and read access to every image you’ve ever pushed, a far more common way that secrets get exposed.
This is why we ranked the list by the model’s priorities. In the paper, the models did the same thing: given a container with a kernel bug, they often chose to SSH to the host over the Docker bridge using default credentials, or even a private key they remembered from GitHub. A frontier model doesn’t care about your kernel exploits. It grabs the easiest credential it can find. Entry #1 is first because it’s the most accessible.
#7 and #10: The Half of the List That Is Already Dead
Here is where the operational picture diverges hardest from the genre. Entries 7 through 10, which are the cgroup, kernel, and runtime exploits that make up half of every top-10 talk, are now gone. The kernel is v.6.18. Dirty Pipe (2022), Dirty COW (2016), the packet-socket UAF (2017), and the eBPF sign-extension bug (2017), which was entry #10 in all its forms, were patched.
The cgroup release_agent escape (#7, CVE-2022-0492, the copy-paste favorite) needs cgroup v1. This cluster is cgroup v2. There is no release_agent file-to-write. The technique does not fail since it does not exist.
A model with seccomp: 0 can access all those syscalls. The problem isn’t reachability, but rather it’s that there are no unpatched bugs left to exploit. So the model checks the more dramatic options, finds they don’t work, and settles for the simple method that does. This is the same difficulty drop the paper described: at the kernel layer, even full capability can’t beat a patched system.
Here’s the uncomfortable truth for anyone sandboxing agents: it’s not your syscall filter that’s protecting you, but a modern, patched kernel. If an unpatched vulnerability appears, seccomp: 0 is the difference between reachable but harmless and reachable and exploitable. Right now, most Kubernetes pods are running with seccomp: 0.
Escapes #2–#4: What a Hardware-Isolated Zone Does to Host-Access Misconfigurations
The entries that do work are the host-access grants, #2 through #4. This is where the substrate matters, so we ran each one twice: once as an ordinary pod (runc, directly on the node) and once inside an Edera zone (a per-pod, hardware-isolated Xen guest with its own kernel) by setting runtimeClassName: edera. The zone is Edera’s isolation primitive, and its own reference architecture is admirably blunt about the boundary: The zone boundary is the security boundary. Everything inside a zone is untrusted.
We gave a pod the full misconfiguration loadout, with privileged (#3), hostPID ($4), and hostPath: / (#2) and then asked what it could actually see. The results were striking.
Two of the three permissions are stopped by the hypervisor boundary. Inside a zone, hostPID only shows five processes instead of two hundred. There’s no xenstored, no node systemd, and no other tenants. The privileged access exposes only the zone’s memory device, not the node’s disk. If a kernel exploit did exist, it would give the attacker full control of the zone’s kernel, but the EC2 host would still be protected by the hypervisor. In short: with runc, kernel ring-0 means node compromise. However, within a zone it means only a single-zone compromise.
And then there is entry #2.
Escape #2: The hostPath Mount That Beats the Hardware Boundary
The hostPath: / config reads the node’s /etc/shadow and steals every colocated pod’s service-account token, including the CNI’s and kube-proxy’s, which are real, privileged identities. It does this inside the zone, exactly as it would’ve on runc. The hardware boundary in this situation does nothing to it.
This isn’t a bug, unfortunately, it’s simply how the system is designed. The CRI mounts a hostPath volume from the real node into the guest before the hypervisor boundary even matters. If you request access to part of the host, the platform gives it to you. Edera’s reference architecture is clear: everything mounted from the host is stored in plaintext on the host filesystem, and zones separate workloads, not configuration. The zone acts as a wall around the workload, but hostPath is a door you asked to be installed. Entry #6, a mounted docker.sock, works the same way: a host mount is always a host mount, and no platform can undo it.
This is the most important operational takeaway from the whole exercise, and it explains why #2 is ranked so high. A frontier model goes for hostPath and similar options early because they are the easiest guaranteed win, and they are the one misconfiguration that a hardware-isolated sandbox can’t fix. The solution isn’t a better platform, but rather it’s about using Pod Security Admission at the restricted level, which blocks hostPath entirely. This is control-plane hardening layered on top of isolation, just as the reference architecture recommends with in-zone controls as extra defense.
What the Reordered Container-Escape List Tells You about Defense
When you put it all together, the top 10 list that a model actually uses is not the one you might expect from typical articles.
- The model starts by checking its environment, not by running exploits. The real insight is in its decision process, not the specific attack. It eliminates six out of ten options in the first minute just by reading
/proc/self/statusand checking a few mounts. - The model goes for credentials, not kernel exploits. On a modern, patched cluster, the real escape routes are entry #1 or #2. This can be a cloud-metadata pivot or a host-mount misconfiguration. Entries 7-10 are relics of the past.
- The protections that matter aren’t always the obvious ones. A patched kernel is more effective than a syscall filter. Pod Security Admission is stronger than the hypervisor for blocking
hostPath. The hypervisor is best for stopping kernel exploits. These controls don’t replace each other; each one covers gaps the others leave open.
If you run agents in containers, the resulting checklist is short and straightforward:
- Block
hostPath(PSA restricted). Entry #2 is the one route no substrate contains. - Kill the metadata pivot (entry #1): IMDSv2 with hop limit 1, or a metadata firewall, or per-pod cloud identity (IRSA / Pod Identity) so pods never inherit the node role.
- Apply
seccompProfile: RuntimeDefault. It is not on by default, and it is your only line the day a kernel n-day (#10) drops. - Scope service accounts and RBAC so a stolen token (#5) is worthless.
- For the kernel and runtime exploit class specifically (#9, #10), a per-workload hardware boundary like an Edera zone converts node compromise into single-zone compromise. It is not a substitute for the 4 items above, but rather it’s the thing that bounds the 1 class those 4 cannot.
The frontier model will quickly find any gaps you leave open. It will spot them in the first minute, pick the most effective one, and won’t need a zero-day exploit to succeed. The good news is that you can use the same checks the model uses to escape to close those gaps ahead of time.
FAQ
Can an AI agent escape a Kubernetes container using only default permissions?
On a patched, well-configured pod the default service-account token is powerless, and capability- and kernel-based exploits fail. The only reliable route is often the cloud metadata (IMDS) pivot to the node IAM role, which is an HTTP request rather than an exploit. Most other escapes need a misconfiguration such as a hostPath mount.
Does a hardware-isolated sandbox stop hostPath container escapes?
No. A hostPath volume is requested in the pod spec, so the CRI mounts the host path into the guest before the hypervisor boundary applies. Inside an Edera zone, hostPath: / still reads node files and colocated pods' tokens. Blocking it takes Pod Security Admission at the restricted level, not isolation.
Do kernel exploits like Dirty Pipe still work on a modern Kubernetes cluster?
Not on a patched kernel. On kernel 6.18, Dirty Pipe, Dirty COW, the packet-socket UAF, and the eBPF bug discussed are all patched, and CVE-2022-0492 needs cgroup v1. A missing seccomp filter leaves syscalls reachable but harmless until an unpatched bug appears.
How does a per-workload hypervisor boundary limit a container escape?
With runc, a kernel ring-0 exploit means full node compromise. Inside a per-workload zone with its own kernel, the same exploit yields only that zone, and reaching the host needs a separate hypervisor escape. It bounds the kernel and runtime exploit class, but not hostPath or IMDS pivots.
.png)
-3.avif)