KubeCon NA 2026 Recap: Isolating AI Agents at Scale
Did you make it to KubeCon + CloudNativeCon North America in Salt Lake City? If so, you might have stopped by the Edera Ski Mountain at Activation Zone 143 to try your luck at mini golf, where one lucky hole-in-one winner was in with a chance of taking home a snowboard or ski set. Or maybe you followed the trail up to the Edera Chalet at Booth 226 to see how Edera’s hardened runtime isolation boundary works with Kubernetes, or maybe you just managed to grab some limited-edition Ivy swag along the way.
Beyond the fun, one theme came through louder than anything else all week, and that was how AI agents are no longer experiments, they're effectively production-ready workloads at this point, and the industry is now working out how to isolate them properly. Whether you missed the conference or just didn't get a chance to chat with us, here's a look at the talks our team gave and the sessions we followed, all of which, in one way or another, kept coming back to that same question of how we safely run agents on shared infrastructure.
Talks from the Edera Team at KubeCon NA 2026
Agents on the Platform: Four Perspectives on the Conversation We’re Already Having in Private
Tuesday, November 10th (4:40–5:10 PM)
Jed Salazar (Edera), Kasper Borg Nissen (Dash0), Juraci Paixão Kröhling (Maintainer of OpenTelemetry), Joseph Sandoval (Adobe), Alexa Griffith (Red Hat)
The clearest place to start is the conversation platform teams are already having behind closed doors, which is exactly what Edera's Jed Salazar and his fellow panellists brought out into the open. As AI and agentic systems move onto cloud-native platforms as everyday workloads, the hard questions tend to land with the platform team: how an agent proves who it is, what it's allowed to reach, how quickly it can act, how much it can spend, how its actions are audited, and what evidence exists when something goes wrong. Those concerns usually sit with different groups, so the panel deliberately put 4 of those viewpoints side by side, combining an end-user platform practitioner, an OpenTelemetry maintainer, a security practitioner and an AI infrastructure engineer.
Together they worked through what shared infrastructure has to guarantee once agents are treated as workloads that need governing, from identity for non-human callers and observability that goes beyond dashboards designed for people, to policy, blast-radius limits, inference and routing demands, build-versus-buy decisions, and accountability spread across the application, the model and the vendor. For us, the blast-radius question in particular is where isolation stops being a nice-to-have and becomes a mandatory foundation that everything else rests on.

5 Stages of Kubernetes Security Grief
Tuesday, November 10th (4:40–5:10 PM)
Kavitha Daula (Edera) with Ann Wallace (Girls Gone Wildwood)
If the panel asked what platforms owe their agents, Kavi and Ann's session in the very same time slot managed to explain why so many teams find out the hard way that their existing isolation isn't up to the job. Framed as the 5 stages of grief, the talk began with Denial ("Our namespace isolation is fine"), moved through Anger ("Why does everything touch the kernel?") and Bargaining ("What if we just add a Pod Security Policy?"), sank into Depression ("The CVE dropped on a Friday"), and finally arrived at Acceptance, the realisation that isolation can't be bolted on afterwards and has to be built in from the start.
Kavi brought the kernel-level detail, covering the surfaces every container shares, the subsystems that rarely get watched, and the failures that never produce a CVE or an alert, while Ann voiced the human side, from the justifications teams lean on to the moment their mental model finally breaks. It was played for laughs, but every stage reflected real failure modes and real conversations, and it carries extra weight now that the workloads sharing that kernel increasingly include autonomous agents running code nobody has reviewed. Attendees left with a more honest view of where Kubernetes isolation holds, where it doesn't, and what accepting that really involves.

What’s New With Kubectl and Kustomize … and How You Can Help!
Wednesday, November 11th (3:10–3:40 PM)
Marly Salazar (Edera), Eddie Zaneski (Defense Unicorns), Yugo Kobayashi (Maintainer of kubernetes-sigs/kustomize), Maciej Szulik (Defense Unicorns)
However new the workloads become, platform teams still manage them with the same everyday tools, and on Wednesday Edera's Marly Salazar joined fellow Kubernetes SIG CLI maintainers to show how 2 of the most familiar, kubectl and kustomize, actually evolve. The interactive session lifted the lid on how enhancements are designed and built, and why some popular feature requests take longer to land than people expect, while touring the wide range of tooling the SIG looks after and walking through how to make a first contribution. Attendees got an early look at the upcoming roadmap, a recap of the biggest improvements shipped over the past year, and an open forum to share feedback and help shape tools they rely on every day, with seasoned contributors and complete newcomers alike encouraged to get involved.

KubeCon Talks We Followed on AI Agent Isolation
Agent Substrate: Secure, High-Density Sandboxing for AI Agents
Tuesday (3:00 PM)
Outside our own sessions, it was striking how many of the talks we chose to attend were tackling the agent isolation problem head on, starting with Mofi Rahman and Brandon Royal of Google at the demo theatre. Their focus was Agent Substrate, an open source framework built around a tension anyone running agents on their own infrastructure will recognise: untrusted agents need strict isolation, but they also need to scale quickly and cheaply. Agent Substrate addresses both on Kubernetes by pairing workload isolation with high-density execution, and the speakers described its architecture in two parts, with security and isolation covering kernel-level sandboxing, credential injection, workload identity and policy enforcement, and density and efficiency covering fast suspend and resume, persistent state and node-level caching. This is very close to the problem we're solving at Edera, so it was great to see how Google were approaching this.
Agent Sandbox on EKS: Hardware-Isolated microVM Pods for AI Agents
Wednesday (11:25 AM)
Where Google's session balanced isolation against density, Carlos Santana and Todd Neal of AWS made an even firmer case for strong boundaries, arguing that every agent deserves its own kernel. Using the CNCF project Agent Sandbox on Amazon EKS, they ran each agent session in a pod backed by a hardware-isolated microVM, so the boundary is enforced by hardware rather than shared with the host, while keeping everything Kubernetes-native through a runtimeclass on a standard pod spec, scoped egress and scoped credentials. The live demo was the highlight, as they launched an agent, gave it real work, checkpointed it, moved it to a different node and restored it with its in-memory state and in-progress work fully intact. It was a practical blueprint for anyone wanting hardware-level isolation for agents on EKS, and another strong signal that the shared-kernel model is being left behind for this class of workload.
Lima as the Universal AI Sandbox
Tuesday (4:40 PM)
The same idea showed up well beyond the hyperscalers, as Akihiro Suda of NTT, a Maintainer of the Lima project, discussed in detail. Lima began life in 2021 as simply a way to run Linux containers on a Mac, but was later reworked to support other host OSs and workloads beyond containers, and then in 2026 it added support for non-Linux guests such as macOS and Windows, meaning it can now run almost any guest OS on almost any host. That flexibility makes it a natural fit for sandboxing AI agents, because if an agent was tricked by malicious content it finds online, such as instructions to install a fake package, the damage would stay inside the VM, or at least be limited to the files deliberately mounted from the host. Seeing a developer-focused tool like Lima evolve in this direction was clear validation that the need to isolate agentic workloads stretches from the laptop all the way to production clusters.
Beyond Harnesses and Sandboxes: Runtime Protection for AI Agents with eBPF
Wednesday (1:20 PM)
After a run of sessions making the case for sandboxes, Yusheng Zheng (eunomia) and Lebin Cheng (RailXia) offered a useful counterweight by arguing that the sandbox is only part of the answer. They pointed out that sandboxes are sometimes managed by a provider, which creates an accountability gap similar to the cloud's shared-responsibility model, where platform teams remain responsible for protecting data yet often lack any independent way to observe or enforce what their agents are doing. Their proposal was a runtime data security layer that sits alongside existing harnesses and sandboxes rather than replacing them, using eBPF for OS and network observability without code instrumentation, combined with continuous scanning for misconfigured cloud storage, data anonymisation and anomaly detection. The takeaway was that it isn't a choice between sandboxing and runtime controls, because teams need both, and this approach delivers independent visibility and control even over opaque runtimes. It was a fitting complement to the rest of the week, since strong isolation and good visibility work best together.
CTFs and other fun
Talks were only half of the story, and the hands-on activities around the venue reflected the same focus on AI and isolation. We ran our first-ever Edera Capture The Flag, giving players a single-node Kubernetes cluster running Edera and letting them use kubectl and the Edera CLI to see first-hand how runtime isolation works in Kubernetes, with no sign-up required, and the lab is still live if you'd like to try it.
We weren't the only ones running challenges, either, as ControlPlane hosted an AI security-focused CTF for 2 hours on Wednesday morning, and NVIDIA ran an eight-and-a-half-hour DSX Inference workshop on Monday covering AI inference deployments, load testing, scaling and platform operations. If you were interested in learning how to secure agent infrastructure, there was no shortage of valuable activities going on around Salt Lake City.
Securely Sandboxing Agents in Production
If one message came through clearly at KubeCon this year, it’s that agent runtimes, isolation and sandboxing are now central to how agents run in production. Vendors are taking different approaches. Some rely on userspace isolation in the style of gVisor, others turn to WebAssembly, and Edera runs every agent inside its own microVM, isolated by our best-in-class type-1 hypervisor built on Xen. Throughout the week we talked with teams about our AI Agent Runtime and the agent substrate behind it, which lets platform teams snapshot, restore and fork agents at scale.
But a strong isolation boundary only solves half the problem. An agent that’s perfectly contained can still do real damage if it holds credentials that it shouldn’t be trusted with. And that’s why Edera made the choice to lockdown agents further with Object Capabilities. Through OCAP, the agent gets bounded authority to use a service like GitHub without ever seeing the token behind it, so security teams no longer have to trust over-privileged credentials being shared with untrusted robots. Edera’s truly different isolation boundary controls what an agent is realistically capable of breaking, but also provides OCAP as the control needed to dictate what agents are allowed to do within that Edera sandbox.
AI was realistically always going to dominate discussions at KubeCon this year, but the speed of change was still remarkable to see. In just 12 short months the industry has shifted from simply getting LLM-based workloads onto Kubernetes to running autonomous agents at massive scale, and the question now is whether that can be done securely. We believe it can, and that it starts with isolation built in from Day 1 rather than bolted on afterwards. It was another brilliant KubeCon, and we can’t wait to see how far things have moved by the next one.

-3.avif)