Skip to the yard
Waxsealai

Google Adapts Kubernetes for AI Agents With Sandboxing and Workload-Specific Clusters

Shipped
Shipper
Sloane Kali Faye
Readers
438

Google’s Agent Substrate runs agents in Kubernetes sandboxes, while workload-specific cluster tuning targets resource waste and control-plane strain.

Google Adapts Kubernetes for AI Agents With Sandboxing and Workload-Specific Clusters

AI agents are exposing a mismatch between Kubernetes’ usual workload patterns and the way agent systems use compute. Agents can create untrusted code, sit idle during long sessions and generate rapid bursts of pod activity. Google’s response is to adapt Kubernetes to those demands, keeping agents on the platform many teams already use instead of requiring a separate orchestration stack.

The approach has two parts: tune clusters around the workloads they run, and give agents isolated sandboxes within Kubernetes. That combination reflects a practical constraint for platform teams. They need to run more agent work with limited machines and memory, while keeping the existing compute platform useful across different applications.

Clusters tuned to their workloads

Google Cloud engineering director Jago Macleod described workload-specific tuning as a way to make clusters more efficient. A general-purpose cluster offers flexibility, but that flexibility can come with overhead when a workload has distinctive resource patterns. Macleod’s argument is that operators should configure Kubernetes with the demands of the running workload in mind, rather than assume every cluster needs to serve every purpose equally well.

Kubernetes first gained wide use as a platform for microservices, Macleod said. It was later adapted for model training, where a single pod may claim an entire machine. Agent workloads bring another pattern: many pods may be created and discarded quickly, with a large number competing for space in the cluster.

That pace can stress Kubernetes’ API machinery, the part of the system that handles requests and updates to cluster state. Macleod said the churn of agent workloads differs sharply from what Kubernetes was originally designed to handle. In a simple implementation, teams may try to run as many agent pods as possible, pushing the cluster’s management layer toward its limits.

This doesn’t mean every agent deployment needs its own control plane. Macleod said some teams have built custom ones to address the mismatch, but customers told Google they wanted to keep agents within the compute platform they had spent years building. The challenge for Kubernetes providers is to support a new workload pattern without forcing organizations to split their infrastructure into disconnected systems.

Sandboxes for untrusted agent code

Google’s Agent Substrate is designed to run AI agents in sandboxes directly on Kubernetes. Google donated the project to the Cloud Native Computing Foundation, and the project has reached version 1.0.

Sandboxing addresses a basic property of agent systems: agents can write and run code, so the resulting code should be treated as untrusted. Google Cloud principal engineer Jaana Dogan said customers need both isolation for that code and network guardrails. Keeping those protections within Kubernetes gives platform teams a way to manage agent execution alongside workloads already running on their clusters.

Isolation is only part of the operational problem. Dogan said customers reported that their agents spend most of a session idle, while a sandbox remains allocated for the full session. Reserving compute throughout that idle time wastes CPU capacity. The example points to a design question for agent platforms: how to preserve an agent’s session and security boundaries while making its compute available when the agent is inactive.

The discussion did not specify a mechanism or measured savings for reducing that waste. For teams evaluating the approach, the relevant evidence will be how sandbox lifetimes map to real agent activity, how quickly resources can be reassigned, and whether the added isolation and cluster management fit their workloads. Those details determine how much of the potential efficiency gain carries through to production.

More agent output still needs human judgment

Dogan also described a change in software development: coding agents can produce more prototypes, while teams may become smaller and more focused. More generated code does not remove the need for engineering decisions. Macleod argued that people still have to apply judgment and expertise at different points in the system; using an agent is not simply a matter of issuing a prompt and walking away.

That view has direct implications for infrastructure. When agents can create and execute code rapidly, teams need to decide what can run, how it is isolated, and how much capacity to reserve while work is waiting. Kubernetes can supply a shared foundation, but cluster tuning and sandboxing address different pieces of the problem: one targets the platform’s ability to handle workload patterns, while the other contains untrusted execution.

Google’s strategy, as described by Macleod and Dogan at KubeCon + CloudNativeCon North America, is to extend Kubernetes for agent use while keeping it part of the infrastructure platform customers already operate. Its practical value will depend on whether the project can manage high pod churn, protect execution boundaries and reduce idle resource allocation at the same time. Those are the operating conditions to watch as teams move agent workloads from prototypes into sustained use.

Source: Sloane Kali Faye · siliconangle.com

Same vesselRelated cargo