Organizations are under heavy pressure to adopt AI agents to increase staff productivity and operational scalability. However, getting this wrong can quickly land them in hot water — and in the news.
The problem: Playing it safe by keeping AI agents out of the corporate environment does not work either. A competitor that first learns how to use AI agents in its development process and its products can build a market lead that is hard to catch up with. In other words, companies of any vertical and size now feel a lot of pressure to harness AI agents in a secure, compliant, cost-efficient and scalable manner. And this is what KubeCon + CloudNativeCon 2026 in Salt Lake City was all about.
Three requirements stood out across the Cloud Native Computing Foundation (CNCF) announcements, keynotes and our many conversations with platform vendors and their customers:
- Agents need to move off the laptop so the enterprise can govern them.
- Agents need stronger isolation than a standard container.
- Agent costs need to be tracked per agent or per task.
1. Agents need to move off the laptop so the enterprise can govern them
Most AI agents in enterprises run on employee laptops today, often outside of IT's view. There is no better chart to show the magnitude of this issue than the one showing GitHub stars of OpenClaw and Harness (see Figure 1).
Less than a year after its launch, OpenClaw is now one of the two most starred software projects on GitHub, apart from tutorial collections and link lists. It gathered about 395,000 stars, far more than the Linux kernel collected in 15 years. DeepSeek's Harness is not in that top tier, but its star count grew almost vertically. In only 15 days, it collected more GitHub stars than Linux or the React framework gathered over many years. Both are end-user tools that demonstrate users' extreme enthusiasm about AI that actually does things and shows them when they are ready.

Who should care and why: Platform engineers and security teams, who will inherit these agents whether they plan for it or not. Omdia research showed that 44% of organizations have employees running open source agent frameworks, such as LangChain or CrewAI, on their laptops, outside the control of corporate IT. The same research found that 52% of organizations are concerned about data leaks through the tool calls made by these unsanctioned agents. Half are just as concerned about compliance violations caused by autonomous agent actions.
Who owns what an agent does: Agents don't get fired; people do. The people who hand an agent a task stay accountable for what it does, so they need to see and limit what it does in their name.
In the keynote "The Identity Crisis: Who is the AI Agent in Your Cluster?" Google Cloud's Abdel Sghiouar posed this question to the whole conference. So far, most answers come from commercial products rather than from CNCF projects. Octopus lets teams register agents separately from people, so some approval steps stay human-only. Akuity's commercial Argo CD platform lets an agent act under its user's identity but with fewer permissions. The exception is Dapr, a graduated CNCF project maintained mainly by Diagrid. Since version 1.18 in June, Dapr can cryptographically sign every step of an agent's workflow under SPIFFE, an open standard for workload identity.
Key announcements
- CNCF accepted Nvidia's OpenShell into the sandbox. OpenShell is an open source runtime that platform teams can use to govern agents. It applies deterministic controls to what an agent does. It enforces policies as agents use tools, call inference services and run workloads. The protection therefore depends on the policies that platform teams write. For the business, the platform enforces the rules for agents instead of leaving them to each developer.
- Nirmata's AIControls, launched in July, applies Kyverno policies to AI agents. Kyverno is the CNCF policy engine many platform teams already use for Kubernetes. Developers deploy agents without approval, as long as they stay inside the boundaries set by IT and security. Companies can scale agent use without adding an approval step for every deployment.
- Nutanix Agent Gateway makes the approved route to a new model faster than going around IT. It also shows IT which teams and agents use which tokens. Companies get less shadow AI and can attribute AI spend to the teams that cause it.
- Broadcom's Tanzu Platform agent foundations run agents in deny-by-default sandboxes, with access only to models and Model Context Protocol (MCP) servers that IT curates. Companies can offer developers agents without exposing unapproved models or data sources.
- Flox turns a developer's request into a Nix environment that pins every library and tool to an exact version. An agent tests code on a laptop, which then runs on exactly the same software in the cluster. This cuts the time teams lose when code that worked on a laptop fails in production.
- LocalStack emulates cloud services, such as AWS, so agents can test their code without a real cloud account, real data or production credentials. Companies lower the risk of an agent damaging real cloud resources and avoid cloud charges for test runs.
- Most observability platforms, including Datadog, Splunk, Dynatrace, Groundcover and Cortex XCOR, now expose telemetry to coding agents through MCP. This has become a baseline capability rather than a differentiator. For buyers, the quality of the data an agent receives now matters more than whether a platform supports MCP.
- Spectro Cloud and AMD went the other way. Their AMD Instinct Coder 355 is an on-premises appliance that runs open-weight coding models and calls a frontier model only when the rules allow it. Companies keep source code on-premises and pay for frontier models only when a task needs one.

Most of these announcements govern the laptop, the cluster runtime and the model gateway. Only the observability vendors reach production, and only to read telemetry.
Video: Jim Bugwadia, CEO of Nirmata, explains how deterministic Kyverno policies can govern AI agents from the CI/CD pipeline through the AI gateway to runtime.
"Everybody's moved from simple prompt engineering to building harnesses to now we want continuous agents running 24/7," said Jim Bugwadia, CEO at Nirmata. "If you tell each developer you need approval every time you're deploying an agent, it's not going to work. It doesn't scale."
2. Agents need stronger isolation than a standard container
For a decade, the industry gave up some isolation to pack more workloads onto each server as it moved from virtual machines to containers to serverless functions. Agents reverse that trade. They write code and run it on the spot, often with no initial human review. Platform teams must treat that code as untrusted and needing stronger isolation, even if each server then runs fewer workloads.
OpenAI and Anthropic both made the news this summer when their own agents broke out of test sandboxes. In July, OpenAI disclosed that models under a cybersecurity evaluation escaped their sandbox and breached Hugging Face's production systems. Nine days later, Anthropic reported three incidents in which Claude models reached the internet from misconfigured test environments and gained access to systems at three outside organizations.
Anthropic later said it had relied on a single layer of defense: the configuration of the test environment itself. An agent sandbox runs untrusted code behind a stronger boundary than a standard container, such as a user-space kernel, a micro VM or a full VM. This also gives VMs a new role next to Kubernetes, beyond hosting legacy applications.
Who should care and why: Security teams and platform engineers who let agents run code, and infrastructure teams planning their virtualization future. Omdia research found that data leakage through agent tool calls is the most frequently named security threat (51%). Nearly one-third (32%) of organizations run a sandbox or code-execution tier in production.
Key announcements
- Google donated Agent Substrate and gVisor to the CNCF as sandbox projects. GVisor places a separate kernel, which runs as an ordinary user-space program, between the agent's code and the server. Every request that code makes to the operating system goes to gVisor first, so an attack must get through gVisor before it can reach the server's own kernel. Agent Substrate manages these sandboxes at scale. Companies can let agents run code they generated without putting the servers that run other workloads at risk.
- In the keynote "Sandbox Your Agents," Jessica Forrester, senior distinguished engineer at Red Hat, presented OpenShell as part of Red Hat's AI platform. In Red Hat OpenShift AI 3.5, every OpenShell sandbox starts with no outbound network access. An agent reaches only the destinations a policy allows. Platform teams keep these policies as YAML files under version control, and Linux kernel features enforce them instead of the agent's own code. This limits how much data a compromised agent can exfiltrate from the company. The feature is still in developer preview.
- CNCF graduated KubeVirt, which runs VMs on Kubernetes, in the project's 10th year. Each VM runs inside a regular Kubernetes pod. Platform teams can give a long-running agent the boundary of a full VM and still schedule, connect and govern it with their existing Kubernetes tools. Companies get VM-level protection for agents without running a second management stack.
- Broadcom's VM API, which joined the CNCF sandbox shortly before KubeCon, gives teams one Kubernetes-style API to request VMs on different hypervisors and clouds. A provider for each platform translates the request the same way Cluster API works for Kubernetes clusters. Broadcom built the vSphere provider, and community developers have started providers for Nutanix and Proxmox. It only pays off if the large cloud providers build theirs too. If they do, companies can manage VMs from several vendors with one set of automations, which makes it easier to switch hypervisors.
- Nutanix is working with the OpenShell team to make a VM on its AHV platform a sandbox back end for OpenShell. OpenShell can hand its sandboxes to different compute back ends. Nutanix wants teams to be able to run a long-running autonomous agent in a full AHV virtual machine instead of a container. Nutanix customers could then isolate agents on the VM infrastructure they already pay for.

"If it's a long-running autonomous agent, maybe you want to run it on a virtual machine and not in an ephemeral container," said Jose Gomez, director of technical marketing at Nutanix. Isolation has limits, though. "Sandboxes are just like micro VMs. They don't recover the business process itself," said Mark Fussell, CEO of Diagrid. In other words, a sandbox limits the damage a failing agent can do, but it does not bring back the work the agent lost.
Video: Jose Gomez, director of technical marketing at Nutanix, explains Nutanix Kubernetes Platform 2.19: Kubernetes on bare metal with NKP Metal, a self-service AI catalog for data scientists, and the platform's CNCF AI conformance certification.
3. Agent costs need to be tracked per agent or per task
AI bills made the news this year. On its first-quarter earnings call in May, Uber's CFO said the company had underestimated the impact of AI tools when it set its 2026 budget. Uber has since increased its AI investment and plans to offset it with slower growth in head count. Much of that bill pays for tokens. Agents also add a second, less visible cost line on Kubernetes: the CPU and memory they hold while doing nothing.
Kubernetes was built for services that run continuously. Agents spend most of their time waiting for a user, a tool or another agent. Google's open source team named two problems that standard Kubernetes was not built for: Idle agents keep CPU and memory reserved, and thousands of agents starting at once can overload the cluster's control plane. Once many agents share a pool of workers, the pod also stops being a useful unit for cost allocation. The number that matters becomes the cost per agent or per task.
Who should care and why: FinOps teams and platform engineers who have to explain AI spend. Omdia research found that 44% of organizations rate per-agent observability and cost attribution as a demand with severe or major impact. Yet only 22% track inference cost per task or per agent, while 36% track GPU utilization.
Key announcements
- Google's Agent Substrate suspends idle agents, snapshots their memory and local files, and restores them onto an available sandbox with sub-second responsiveness. Many agents then share a small pool of workers instead of each holding its own pod. Companies then pay for compute only while an agent works rather than for all the time it waits.
- CloudBolt made GPU optimization in StormForge generally available and added GPU cost allocation that matches the cloud bill. StormForge maps GPU use back to individual pods, which informs the cost per agent. Finance teams can then tie GPU costs to specific workloads and teams.
- AWS added dynamic resource allocation (DRA) to EKS Auto Mode and Karpenter for Nvidia GPUs and Elastic Fabric Adapter high-speed network devices. With DRA, a pod describes the GPU it needs instead of requesting a fixed number of devices. According to AWS, Karpenter then launches the lowest-cost instance that meets those requirements. Microsoft announced managed DRA for Azure Kurbernetes Service GPU node pools the same week. Companies are less likely to pay for GPU capacity that their workloads do not use.
- IBM's Kubecost team said version 3.4, due in about two weeks, will turn its GPU savings recommendations into automated actions. Savings then arrive without waiting for an engineer to act on each recommendation.
- Nutanix plans to route each coding task to either a frontier model or a cheaper, self-hosted open-weight model, starting with Nutanix Enterprise AI 2.9. Nutanix said it expects about 80% of its own engineers' AI work to move to open-weight models. Companies keep frontier-model spend for the tasks that actually need it.
- Llm-d, which joined the CNCF sandbox in March and reached version 1.0 in October, routes each inference request to the model server that already holds the matching context in memory. Each request requires less GPU time, so the same hardware serves more users.
- Hami, which became an incubating project in July, slices a GPU's memory and compute so several workloads can share it. An agent that sits idle most of the time only needs a slice. Companies need fewer GPUs to run the same number of agents.
- The Kubernetes AI Conformance Program reached 40 certified platforms, which lets teams move AI workloads between platforms instead of being locked into one vendor's GPU pricing.

"You're taking the two most complex things that you possibly can and shoving them together, and no one knows what it's going to cost," said Danielle Zeis, principal product marketing manager at IBM Kubecost.
Video: Danielle Zeis of IBM Kubecost explains how Kubecost compares the GPU capacity teams have allocated with what they actually use. Developers and FinOps teams can then decide from the same data whether to share, release or buy more GPUs.
What it adds up to
All three requirements show that AI agents do not fit the way platform teams run ordinary workloads. KubeCon delivered building blocks for each requirement but not in equal measure. Isolation and GPU efficiency received most of the announcements, while guardrails for agents in production and cost reporting per agent received the fewest. Most of the CNCF projects behind these announcements are still in the sandbox, and agent identity still depends mostly on commercial products.
This gives platform teams a clear task for the next 12 months: They need to bring the agents that already run on employee laptops onto a governed platform before those agents reach production systems on their own. The sandbox escapes at OpenAI and Anthropic showed what happens when a single layer of defense fails, and Uber's budget showed how fast agent spend grows. We expect the first production-ready controls to come from the CNCF projects that move from sandbox to incubation over that period, with Agent Substrate and OpenShell as the two to watch.
Torsten Volk is principal analyst at Omdia covering application modernization, cloud-native applications, DevOps, hybrid cloud and observability.
Omdia is a division of Informa TechTarget. Its analysts have business relationships with technology vendors.