Last week, we attended KubeCon + CloudNativeCon North America 2026 in Salt Lake City. It was our first time participating in KubeCon in several years, and we came away energized by how much the conference—and the cloud-native ecosystem—has evolved.
Kubernetes has long been the standard for orchestrating containerized applications. More recently, it has taken on an increasingly important role in AI infrastructure, from managing GPU clusters to serving large language models. Now, a new wave of interest in hosting, securing, and governing autonomous AI agents is creating another major growth opportunity for Kubernetes and the broader CNCF ecosystem.
This evolution was evident throughout the conference. KubeCon introduced a dedicated AI Inference + Agentic track this year, reflecting the growing importance of production AI workloads. The excitement around agent infrastructure was particularly apparent during the first morning’s keynote, which prominently featured two projects: Agent Substrate and OpenShell.
Both projects were welcomed into the CNCF Sandbox, signaling that agentic computing is becoming an important new frontier for cloud-native infrastructure.
The Obot AI team at KubeCon NA 2026 in Salt Lake City, UT
Agent Substrate: Running Agents Efficiently at Scale
Developed by Google and donated to CNCF, Agent Substrate addresses a fundamental challenge in hosting AI agents on Kubernetes: efficiently managing large numbers of stateful workloads.
Unlike traditional server applications, AI agents often spend most of their time waiting—for LLM inference, external API responses, user input, or other events. Yet they must preserve their execution state, including memory, files, and active workspaces, so they can resume their work later.
A conventional Kubernetes deployment might dedicate an entire pod to each agent. This becomes prohibitively expensive when thousands or millions of agents are running, with most of them idle at any given moment.
Agent Substrate takes a different approach. It separates an agent’s persistent identity and execution state from the Kubernetes worker that runs it. When an agent becomes idle, its memory and filesystem state can be snapshotted, freeing the underlying compute resources for other agents. When the agent needs to resume, its state is restored onto an available worker.
We believe technologies like Agent Substrate will become increasingly important as organizations move beyond experimenting with a handful of agents to operating thousands of persistent agents in production.
OpenShell: Building Security Into Agent Execution
The other announcement that caught our attention was OpenShell, originally developed by NVIDIA and now contributed to CNCF.
While Agent Substrate focuses on efficiently running agents at scale, OpenShell focuses on controlling what agents are allowed to do while they run.
This is a fundamentally important problem. Unlike conventional applications that execute largely predetermined code paths, autonomous agents can dynamically generate and execute code, access files, invoke tools, connect to external services, and make decisions based on unpredictable inputs.
Traditional application security approaches are not sufficient for this new execution model. Even well-designed agents can make mistakes, encounter malicious instructions, or take actions their users never intended.
OpenShell addresses this challenge by providing isolated execution environments with infrastructure-enforced security policies. Its capabilities include:
Runtime isolation: Execute agents within sandboxes that restrict their access to the underlying host and other workloads.
Filesystem and process controls: Limit which files an agent can access and which operations it can perform.
Network egress control: Restrict connections to approved external destinations and prevent unauthorized network access.
Credential and inference protection: Mediate access to model providers and external services without unnecessarily exposing sensitive credentials to agents.
Policy enforcement and visibility: Enforce security rules outside the agent’s own reasoning process and monitor activity at runtime.
The last point is particularly significant. Security cannot depend entirely on instructions embedded in an agent’s system prompt. Agents are probabilistic systems, and prompt-based restrictions cannot provide deterministic enforcement.
The security boundary must exist outside the agent, in the infrastructure that executes and connects it.
NVIDIA’s decision to contribute OpenShell to CNCF is an important endorsement of this architectural pattern. It also creates an opportunity for the open-source community to develop common security primitives that can be shared across agent frameworks and platforms.
Agentic Security and Governance: A New Frontier for Cloud Native
What excites us most about these developments is the broader opportunity they represent.
As agents become more capable, organizations will need to answer questions that go well beyond where an agent runs:
Who is the agent acting on behalf of? Which models, tools, and data can it access? What credentials should it receive? What code can it execute? Which external services can it contact? How do we monitor its actions, enforce organizational policies, and maintain a complete audit trail?
These questions span several distinct security boundaries: identity, LLM inference, MCP tool calls, filesystem operations, process execution, and network traffic.
No single control point can adequately govern all of them. For example, restricting an agent’s MCP tools is not enough if the agent can execute arbitrary shell commands and access the same services directly over the network. Similarly, network restrictions alone cannot determine whether a particular MCP tool invocation is appropriate for a given user.
Effective agent security requires coordinated enforcement across the entire agent execution lifecycle.
This is where we believe the next major opportunity lies for the cloud-native ecosystem.
Kubernetes provides the foundation for running workloads. Projects like Agent Substrate and OpenShell are extending that foundation to support the unique performance and security requirements of autonomous agents. Above and around these runtime technologies, enterprises will need comprehensive identity, access control, policy management, and audit capabilities.
This emerging stack could bring a new generation of developers, infrastructure engineers, and security practitioners into the Kubernetes community. Just as Kubernetes became the foundation for cloud-native applications, it has the potential to become a foundation for enterprise agentic AI.
For KubeCon, this represents an exciting new chapter of growth.
Obot’s Role in the Emerging Agentic Infrastructure Stack
At Obot AI, we have been working on many of these challenges over the past year.
We started with a relatively simple open-source MCP gateway, helping organizations securely connect AI agents to external tools and services.
As we worked with customers and learned more about the security challenges they faced, we realized that securing MCP traffic was only one part of a much larger problem.
Organizations need to govern not only the tools agents call, but also the models they use, the credentials they carry, the environments in which they execute, and the external resources they access.
That realization has driven Obot’s evolution from an MCP gateway into a more comprehensive open-source agent security and governance platform, with capabilities spanning multiple layers:
Agent and MCP server hosting: Run MCP servers and managed agent environments in isolated sandboxes on Kubernetes, with resource controls and workload lifecycle management.
Identity and access management: Authenticate users and agents, manage credentials, and enforce granular permissions across models, MCP servers, tools, and other resources.
LLM gateway: Centrally manage access to multiple model providers, with guardrails, usage tracking, budgets, and policy enforcement.
MCP gateway and registry: Curate approved MCP servers and tools, inspect and filter tool calls, and manage access based on user and organizational policies.
Network egress control: Use policy-enforcing network proxies to restrict the external destinations agents can access and protect credentials.
Observability and audit: Record agent activities across gateways and hosted environments, and extend governance to locally running coding agents through Obot Sentry.
Together, these capabilities provide enterprises with a unified way to manage agent security without requiring them to standardize on a particular model provider, agent framework, or execution environment.
We are particularly excited about the convergence between Obot’s architecture and the technologies now emerging within CNCF.
We have already incorporated Agent Substrate into Obot’s agent hosting infrastructure. For example, our Self-Hosted Claude Environments capability uses Agent Substrate to run isolated coding-agent sessions on Kubernetes, suspending idle workspaces and restoring them when needed.
Although we have not incorporated the OpenShell codebase itself, we have independently implemented many similar sandbox isolation, network control, and gateway capabilities.
We will closely follow OpenShell’s development and evaluate opportunities to adopt and integrate its technology as the project matures. We see these projects as complementary parts of an emerging open agent infrastructure ecosystem. Agent Substrate makes agent execution scalable. OpenShell helps make agent execution secure. Obot brings together identity, access management, gateway controls, security policies, and auditing to help enterprises govern agents across their environments.
We believe the future of agent infrastructure should be open, interoperable, and independent of any single agent framework or model provider. CNCF is a natural home for the collaboration needed to make that happen.
Try Obot today — the open-source AI gateway. Self-hostable, MIT licensed, full audit trail at every tool call.
We had a great time at KubeCon this year. It was exciting to reconnect with the cloud-native community and see so much innovation focused on the challenges of running AI agents in production.
What stood out to us was the growing recognition that agentic security and governance must be foundational infrastructure, not an afterthought. As AI agents move from experimental applications to systems that perform real work on behalf of individuals and enterprises, their security, identity, permissions, and behavior will become increasingly important.
We believe this creates an enormous opportunity for the Kubernetes and CNCF ecosystem—and for open-source companies like Obot AI that are building the security and governance infrastructure needed to make enterprise agent adoption possible.
We left Salt Lake City more convinced than ever that agentic security and governance are moving into the mainstream.
And with Kubernetes expanding its role from container orchestration to AI infrastructure and now autonomous agent execution, we can’t wait to see how much bigger KubeCon 2027 will be!