Companies that let each team pick its own AI tooling end up with fragmented, hybrid AI workflows for 54% of their developers. Companies that run a custom internal developer platform get that number down to 5%. That gap, from a CNCF and SlashData report released on the first keynote day, sums up KubeCon North America 2026 better than any product launch.
The conference ran November 9-12 in Salt Lake City, with more than 9,000 attendees and over 400 sessions. Most of the stage time went to AI agents: where they run, how they are isolated and what they cost. Our main takeaway for enterprise leaders is that platform engineering has turned into the control point for AI. Teams with a real platform can absorb agents without losing track of security and spend. Teams without one are collecting new control planes faster than they can govern them.
In our KubeCon preview we promised to sort the news into what to assess now, what to pilot and what to watch. This recap does that.
The headline from KubeCon NA 2026
This year Kubernetes took on virtual machines, GPU inference and autonomous agents under one control plane. The hard questions moved with it, from “can it run?” to “who controls it and who pays?” For a CIO, that means the platform team now sits on the path of every AI initiative, whether it was planned that way or not.
Agents behave differently from the web services Kubernetes was built for. They hold state while waiting for a model or a person, run code nobody reviewed and spin up bursts of short tasks. CNCF added a dedicated AI Inference + Agentic track this year to reflect that.
Survey data shows how far control lags behind use. Futurum’s survey of 839 IT decision makers found that 75% had a production incident in the past year where AI played a part, while only 18% have standardized agent governance. Omdia, cited by TechTarget, adds that 44% of organizations have employees running open-source agent frameworks on laptops outside IT’s view.
The announcements that matter
The week produced dozens of launches. These are the ones that change something for an enterprise platform team:
| Announcement | Status | Why it matters |
|---|---|---|
| Agent Substrate (Google) | CNCF Sandbox; 1.0 and GA on GKE | Suspends idle agents and restores them in under 500 ms, so idle agents stop holding CPU and memory |
| gVisor and OpenRL (Google) | CNCF Sandbox | gVisor isolates untrusted, agent-generated code without nested virtualization |
| KubeVirt | Graduated | VMs and containers on one platform, with 2,088 contributors and production use at Cloudflare, CoreWeave and NVIDIA |
| Red Hat Developer Hub 2.1 | Announced for November GA | Gives coding agents access to golden paths and the software catalog through MCP |
| Dynamic Resource Allocation in EKS, Karpenter and AKS | Available | Workloads request the GPU they need, and Karpenter picks the cheapest instance that fits |
| IBM Kubecost 3.4 | Due late November | Turns GPU savings recommendations into automated actions |
Agents get their own runtime
Google’s Agent Substrate separates an agent’s session, its memory and identity, from the compute that runs it. Idle agents are written to storage and brought back on any free worker. Google claims ten times the density of standard containers, though it does not publish its test method. Several other vendors shipped sandboxes, gateways and policy layers for agents the same week.
VMs become ordinary Kubernetes workloads
KubeVirt’s graduation after ten years makes it the default way to run VMs next to containers. Recent releases added confidential VM support and beta GPU claims through Dynamic Resource Allocation. For companies leaving VMware, this is the most practical news of the week, and it fits the OpenShift Virtualization migrations many are already planning on the OpenShift platform.
Enterprise impact: platform engineering and Kubernetes cost optimization
Two things decide whether AI on Kubernetes stays manageable: who owns the platform and whether anyone can see the cost.
Platform ownership decides AI sprawl
The CNCF and SlashData numbers are the clearest argument for platform engineering we have seen:
| How teams get their tooling | Developers with fragmented, hybrid AI workflows |
|---|---|
| Each team manages its own tools | 54% |
| Several teams share platform work | 43% |
| A central team curates third-party tools | 18% |
| A custom internal developer platform | 5% |
Among organizations with a custom platform, 38% run a separate AI platform and 33% extend their existing one.
The same report’s Technology Radar is a useful shortlist for standardizing the rest of the stack. OpenTofu and OpenTelemetry sit in the “Adopt” ring, with 96% and 92% of users likely to recommend them, and 80% of users rate Prometheus four or five stars for maturity. Standard, boring components leave the platform team time for the new AI work.
Meta gave the strongest production example. Its Cloud Foundation team, just over 15 engineers looking after about 100 Kubernetes clusters, won the CNCF end-user case study contest by splitting infrastructure provisioning from application delivery. Terraform still builds infrastructure, while Argo CD and Kargo handle releases with automated health checks. Routine deployments dropped from more than four hours to minutes.
The developer portal now has two users
An internal developer platform used to serve engineers. It now also serves coding agents. Red Hat Developer Hub 2.1 lets agents trigger approved software templates and query the catalog through MCP, so they follow the company’s golden paths instead of inventing their own steps. An agent that can see which services, owners and templates already exist is less likely to duplicate a service or pull in an unapproved dependency, and that is cheaper than catching the problem in code review.
Kubernetes cost optimization moves to GPUs and agents
Kubernetes cost optimization used to mean rightsizing CPU and memory requests. KubeCon showed the expensive problems have moved:
- Idle agents that hold a pod while waiting for a model response.
- Whole GPUs reserved for workloads that use a fraction of them.
- Model and token spend that nobody attributes to a team or a task.
The tooling is uneven. Omdia found only 22% of organizations track inference cost per task or per agent, and 36% track GPU utilization. Of eight cost announcements at the event, only two reported cost at the workload level. The rest stopped at the cluster.
The most useful practical change is Dynamic Resource Allocation. Instead of asking for a fixed number of GPUs, a workload describes the device it needs, and on AWS, Karpenter launches the cheapest instance that meets that description. Combined with GPU sharing and invoice-reconciled allocation, it lets FinOps show a business owner what one AI workflow actually costs.
Gaps, trade-offs and open questions
Budget overruns and stalled pilots usually come from limits nobody checked before signing. Three of them stood out in Salt Lake City.
Most agent infrastructure is in the CNCF Sandbox
Agent Substrate, gVisor and OpenRL all sit in the CNCF Sandbox, the foundation’s earliest maturity tier. Managed versions such as Agent Substrate on GKE are generally available, but the open-source projects are new to neutral governance. For now they are pilot material; standardizing on them would be early.
Control-plane debt is growing
Futurum’s summary of the week was that buyers leave KubeCon with more control planes to govern, not fewer. Sandboxes, agent gateways, MCP servers and policy layers from different vendors rarely work together. Each one adds identity rules, logs and costs that someone has to reconcile.
Sandboxes contain damage but do not recover work
Stronger isolation means less packing density, so better security costs compute. Isolation also leaves one problem untouched. “Sandboxes are just like micro VMs. They don’t recover the business process itself,” said Diagrid CEO Mark Fussell. When an agent fails halfway through a multi-step task, someone still has to resume or undo the work. That job belongs in workflow and integration design.
Practical next steps
Here is how the five questions from our preview sorted the news:
| Verdict | What belongs here | Condition |
|---|---|---|
| Assess now | KubeVirt for VM consolidation; GitOps split between infrastructure and app delivery; Dynamic Resource Allocation for GPUs | Documented releases with production references |
| Pilot with controls | Agent Substrate or gVisor sandboxes; MCP access through the developer portal; automated GPU rightsizing | Sandbox-stage or new; limit scope and keep humans approving production changes |
| Watch | Cross-vendor agent identity and approval standards; per-agent cost reporting | No shared standard yet |
For the next 90 days, five moves make sense for most enterprise platform teams:
- Move shadow agents onto the platform by offering an approved sandbox path that is faster than a laptop, with deny-by-default network rules.
- Give one team ownership of the platform. The 54% versus 5% gap shows what fragmented ownership costs.
- Separate infrastructure from releases, as Meta did: Terraform or OpenTofu for infrastructure, GitOps for application and model delivery.
- Open the developer portal to agents through MCP with scoped, read-mostly access instead of handing out credentials.
- Measure cost per task, with GPU allocation reconciled to the actual invoice and model spend tracked per agent or workflow.
Before buying any agent runtime or gateway, apply Futurum’s three tests: each action carries the agent’s own identity, the approval travels with the change, and the record exports in an open format such as OpenTelemetry. Products that fail them add to the control-plane pile. The same thinking runs through our piece on agent sprawl as an integration problem.
Five takeaways
- Kubernetes now runs VMs, GPU inference and agents. What remains open is who controls them.
- Platform engineering decides whether AI scales cleanly: 5% fragmentation with a custom platform, 54% without one.
- The developer portal must serve coding agents as well as people.
- Kubernetes cost optimization now centers on GPUs, idle agents and cost per task.
- Most agent infrastructure is Sandbox-stage. Pilot it with limits and buy only what passes identity, approval and export tests.
Is your platform ready for AI agents?
In a 30-minute call we review your Kubernetes platform, delivery path and cloud bill, and point to the one or two changes that cut the most operating work or spend.
One call, no commitment.
One call, no commitment.
FAQ
What is platform engineering?
Platform engineering is the practice of building and running an internal developer platform as a product. A dedicated team provides self-service paths for building, deploying and operating software, so application teams can ship without filing tickets while security, cost and compliance rules are applied automatically.
What is the difference between platform engineering and DevOps?
DevOps is a way of working that brings development and operations together. Platform engineering is one way to make DevOps work at scale: a platform team packages tools, templates and guardrails into an internal platform that other teams use.
How do you optimize Kubernetes costs?
Start by allocating spend to teams and workloads, then remove idle capacity, rightsize resource requests, use autoscaling and pick the right mix of spot and committed capacity. For AI workloads, share or slice GPUs, suspend idle agents and track cost per task. Count only savings that show up on the invoice.

