Kubernetes 1.37 introduces critical features for agent platforms, including a rootless kubelet mode and the removal of deprecated network backends like IPVS. This structural shift arrives at a pivotal moment as Google Cloud transitions several of its most significant internal technologies into the public domain through the Cloud Native Computing Foundation. By donating Agent Substrate, gVisor, and OpenRL to the CNCF Sandbox, Google is attempting to standardize how the industry handles the unique resource demands of artificial intelligence agents. The move, announced in early November 2026, signals a major departure from traditional container management, focusing instead on high-density, stateful sessions that can be suspended and resumed instantly. This initiative addresses the growing need for secure, isolated environments that do not bankrupt organizations through idle compute costs. As these projects enter neutral governance, platform engineers are evaluating whether this stack will define the default architecture for the next generation of agentic applications.
1. Agent Substrate 1.0 and GKE Managed Services
Google Cloud recently confirmed the general availability of Agent Substrate 1.0 on Google Kubernetes Engine, marking a significant milestone for enterprise-grade agent orchestration. While Agent Substrate on GKE provides a fully managed experience with integrated billing and support, the underlying Agent Substrate project has been released as open-source software to ensure portability across various cloud environments. The primary objective of this runtime is to facilitate the execution of millions of secure agent sandboxes simultaneously without the overhead typically associated with standard container deployments. By decoupling the agent’s state from the underlying compute resources, the platform allows developers to build applications that scale to massive user bases while maintaining strict isolation. This dual-track release strategy ensures that teams can leverage the convenience of a managed service while retaining the flexibility to deploy on any conformant Kubernetes cluster that meets the project’s technical prerequisites.
The technical foundation of Agent Substrate is built around two primary isolation layers: gVisor for high-density, kernel-level protection and Cloud Hypervisor microVMs for workloads requiring hardware-assisted virtualization. This flexibility allows platform teams to tailor their security posture based on the specific risks associated with the code executed by AI agents. For instance, a coding assistant that needs to execute untrusted scripts might use heavier microVM isolation, whereas simpler task-based agents could run within gVisor to maximize resource utilization on the host node. Google’s claims regarding the platform’s performance are particularly striking, suggesting the system can handle over 500 suspend-and-resume activations per second. Such throughput is essential for applications involving frequent human-in-the-loop interactions or long-running tasks that spend most of their time waiting for external API responses. By providing these capabilities through a standardized runtime, Google is positioning itself as the foundational layer for the burgeoning agent economy.
2. Inefficiency of the Pod Model for Idle Agents
The traditional Kubernetes Pod model was designed for long-running web services that maintain active connections and consistent CPU usage—a paradigm that is increasingly at odds with agentic workloads. In a typical deployment, an AI agent might spend upward of 95% of its lifecycle waiting for model inference results, external tool outputs, or human review. During these idle periods, a standard Pod continues to consume memory and CPU reservations, leading to significant financial waste at scale. If an organization chooses to scale these Pods to zero to save costs, it encounters the “cold start” problem, where the delay in spinning up a new container ruins the interactive experience for the user. This tension between cost efficiency and performance has created a bottleneck for teams trying to deploy thousands or millions of individual agents, as the resource overhead becomes unsustainable.
Beyond the immediate financial implications, the overhead of managing short-lived Pods puts an immense strain on the Kubernetes control plane. Scheduling, starting, and tearing down thousands of Pod objects in response to intermittent prompts can lead to increased latency in the API server and potential stability issues for the entire cluster. Agent Substrate addresses this by treating agent interactions as “sessions” rather than continuous services, allowing the system to park the agent’s state in storage when it is not actively processing a task. This approach mitigates the need for a dedicated, running Pod for every user session, effectively breaking the linear relationship between the number of active users and the amount of compute hardware required. By optimizing for these “bursty” workloads, platform teams can achieve significantly higher compute density, potentially reducing infrastructure requirements by an order of magnitude while maintaining the responsiveness that modern AI applications demand.
3. Architecture of Actors, Workers, and Warm Pools
The operational logic of Agent Substrate is defined by a sophisticated separation of state and execution, using a model of Actors, Workers, and warm pools to manage life cycle events. To implement this architecture, the system defines the Actor, which serves as a persistent representation of the agent’s specific state, including its unique file system, memory contents, and environment variables. This Actor is not tied to a specific machine; instead, it exists as a portable snapshot that can be moved across the cluster. When the system needs to execute a task, it uses a Worker—a pre-warmed Kubernetes Pod that remains on standby, ready to host any Actor at a moment’s notice. This pool of Workers ensures that container initialization overhead is handled once, rather than every time an agent needs to perform an action.
Once the infrastructure is in place, the system follows a precise sequence to handle incoming requests and manage resource allocation. First, the request is routed to a proxy that holds the call in memory if the specific Actor is currently suspended. The controller then identifies an available slot within the warm pool and allocates it to the Actor, effectively “docking” the agent’s state into a running Worker. The system reactivates the state by restoring the agent’s memory and disk from tiered storage, allowing the code to resume execution from the exact point where it was previously paused. Finally, once the agent completes its current turn, the system pauses the session, takes a new snapshot of the updated state, and saves it back to storage, clearing the Worker slot for the next incoming task. This granular control over execution ensures that compute resources are only consumed during active processing, significantly improving the overall efficiency of the agent platform.
4. Isolation Strategies: gVisor vs. MicroVMs
Choosing the right isolation technology is a critical decision for platform engineers, and Agent Substrate provides two distinct paths to balance performance and security. gVisor, a user-space kernel written in Go, offers a robust sandboxing mechanism by intercepting system calls and preventing untrusted code from interacting directly with the host kernel. This approach is highly efficient, allowing for extremely high density and rapid snapshotting, making it the preferred choice for multi-tenant environments where thousands of agents must coexist on the same node. Because gVisor reimplements the Linux kernel interface, it provides a strong security boundary without the resource overhead of a full virtual machine, though it may have limited compatibility with specialized kernel modules or hardware features.
In contrast, Cloud Hypervisor microVMs provide a more traditional hardware-virtualized boundary, which is often required for the most sensitive or complex workloads. A microVM includes its own Linux kernel and provides a stricter hardware-level separation between the agent and the underlying infrastructure. This makes microVMs the safer choice for security-conscious organizations handling regulated data or executing highly privileged code, as isolation is enforced at the hardware level rather than through software interception. While microVMs generally introduce more overhead and slower resume times than gVisor, they offer near-perfect compatibility with the standard Linux ecosystem. By supporting both technologies, Agent Substrate allows teams to choose the isolation level that matches their risk profile, ensuring that security requirements do not necessarily dictate the architecture of the entire agent platform.
5. Technical Suitability of gVisor for Snapshotting
Integrating gVisor into the Agent Substrate ecosystem is not only a security measure but also a way to leverage its unique ability to facilitate rapid state preservation and restoration. Because gVisor virtualizes its own memory and process tables independently of the host Linux kernel, it can freeze an entire execution environment with remarkable precision. This “checkpoint and restore” capability is fundamental to the Agent Substrate model, as it allows the system to write an agent’s current memory pages to storage and then reload them on a different physical node in less than 500 milliseconds. This process is significantly more difficult to achieve with standard containers, which are deeply intertwined with the host kernel’s state, making them prone to errors when migrated across different machines or kernel versions.
This suitability extends to how gVisor handles file system state and network connections during suspension. The platform ensures that the file system remains consistent between snapshots, allowing an agent to resume complex multi-step tasks—such as refactoring a code repository or performing a multi-page web crawl—without losing progress. The ability to restore a session on a “warm” worker node located anywhere in the cluster provides the orchestration layer with incredible flexibility in managing resource distribution. This architecture effectively transforms the agent’s runtime into a fluid, movable object that can be paused and resumed based on compute resource availability. For developers, the platform provides the illusion of a dedicated, always-on machine, while the infrastructure team benefits from the cost savings of a highly dynamic and efficient resource-sharing model.
6. Project Governance and CNCF Sandbox Status
The donation of Agent Substrate, gVisor, and OpenRL to the Cloud Native Computing Foundation represents a strategic pivot toward neutral governance and industry-wide collaboration. By entering the CNCF Sandbox, these projects are now subject to the Foundation’s standards for transparency, community contribution, and vendor neutrality. Sandbox status is the entry-level tier for CNCF projects, signaling that while the technology is innovative and shows great promise, it is still in the early stages of community-driven development. This transition is intended to encourage other cloud providers and technology companies to contribute to the codebase, preventing the runtime from becoming a proprietary “walled garden” that functions optimally only on a single vendor’s infrastructure. Neutral governance is a key requirement for many large enterprises that are wary of vendor lock-in and want to ensure the long-term viability of their foundational AI components.
As these projects move toward more mature levels, such as Incubation and eventually Graduation, the focus will shift toward building a robust ecosystem of maintainers from across the industry. Google’s decision to move gVisor into this governance model is particularly noteworthy, given that the tool has been a core component of its own internal security infrastructure for years. The CNCF’s oversight ensures that the project’s roadmap will be influenced by a diverse set of needs, from small startups to global telecommunications firms. For platform teams, this status provides a level of insurance; even if a primary vendor changes its strategy, the code and its development process remain under the stewardship of a nonprofit foundation. This open approach is designed to accelerate the adoption of agnostic standards, making it easier for developers to build applications that can run seamlessly on any cloud that supports the CNCF-managed runtime.
7. Development Milestones and Project Roles
The rapid evolution of this stack is evident in the timeline of releases and project donations throughout 2026. The sequence began in May with the announcement of Agent Sandbox, a specialized environment for executing untrusted agent logic on Kubernetes. By September, Agent Substrate was made available on GKE, providing the first glimpse into how Google intended to manage agent sessions at scale. This culminated in the November 1.0 general availability release and the subsequent donation to the CNCF. This six-month progression from an experimental execution environment to a full orchestration runtime reflects the intense pressure within the industry to provide viable infrastructure for AI agents. Each milestone was accompanied by technical documentation and guidance aimed at helping platform engineers understand the shift from container-centric to session-centric management.
Within this donated ecosystem, each project plays a distinct and essential role in the overall AI infrastructure stack. Agent Substrate acts as the primary orchestrator, managing the lifecycle of agent sessions, identities, and security policies. gVisor serves as the secure runtime that provides the necessary isolation and snapshotting capabilities for individual sandboxes. Finally, OpenRL provides a Kubernetes-native framework for reinforcement learning and post-training, which is critical for teams that are not only running agents but also fine-tuning the models that drive them. While these projects are often discussed together, it is important for developers to recognize that they solve different problems at different layers of the stack. OpenRL focuses on the training and optimization phase, while Agent Substrate and gVisor address the secure and efficient execution of the resulting agents in a production environment.
8. Comparison with OpenShell and Existing Agent Tools
The emergence of Agent Substrate has naturally led to comparisons with other prominent projects in the CNCF ecosystem, most notably NVIDIA’s OpenShell and the community-driven OpenKruise Agents. While these projects all operate within the realm of AI agents, they target different challenges, making them complementary rather than purely competitive. OpenShell is primarily focused on policy and governance, providing a framework to define what an agent is allowed to do and which external tools or APIs it can access. In contrast, Agent Substrate is concerned with the “plumbing” of agent execution—how to run them securely, how to scale them efficiently, and how to manage their state across a cluster. A complete agent platform would likely integrate both, using OpenShell to govern behavior and Agent Substrate to provide the high-density execution environment.
OpenKruise Agents, another significant project, provides its own approach to managing the lifecycle of sandboxes, often focusing on providing consistent interfaces for various runtime backends. The arrival of Agent Substrate adds a powerful new option for teams that require the specific snapshot-and-restore features enabled by gVisor. For platform builders, the current landscape offers a rich set of “building blocks” that can be assembled into custom solutions. The CNCF’s role in hosting these varied projects is to ensure they can eventually interoperate through standardized APIs and protocols. This emerging “agent stack” mirrors the early days of the container ecosystem, where different projects initially competed before settling into defined roles within a broader architectural framework. Teams choosing a runtime today must look beyond basic feature lists and consider how these projects fit into the long-term vision of a standardized, cloud-native agent infrastructure.
9. Pricing Structures and Technical Restrictions
Understanding the financial and technical constraints of Agent Substrate is vital for any organization planning a large-scale rollout. As of late 2026, there is no separate licensing fee for the Agent Substrate runtime on GKE; instead, costs are integrated into the standard billing for the underlying compute, storage, and network resources. This “bundled” pricing model means the primary cost driver is how efficiently the platform utilizes its warm pools and storage backends. Teams can save money by optimizing suspension timeouts and ensuring their Actors are stored in the most cost-effective storage tiers when not in use. However, it is important to note that the managed service requires specific GKE cluster configurations, which may carry baseline costs that must be factored into the overall budget.
Agent Substrate 1.0 has several notable limitations that may affect specific use cases. One of the most significant restrictions is the lack of support for GPU passthrough in agent sandboxes, meaning that agents requiring local hardware acceleration must run in traditional, non-suspended container environments. Additionally, when an agent is suspended, active network connections—such as open database sessions or Model Context Protocol (MCP) links—are typically severed and must be re-established upon resumption. This requires the agent’s code to be “resumption-aware,” with robust logic for reconnecting to external services. While these limitations may be addressed in future releases, they represent a hurdle for certain high-performance or real-time agents. Platform engineers must carefully evaluate these constraints against their application requirements to determine where the Substrate model provides the most value.
10. Kubernetes 1.37 and Future Market Impact
The release of Kubernetes 1.37 has provided the perfect substrate for these new agent technologies to flourish by introducing features that enhance both security and performance. The promotion of rootless kubelet mode to Beta is a significant advancement, as it allows for more secure local agent execution by minimizing the potential blast radius of a compromised sandbox. Furthermore, the establishment of the AI Conformance subproject within SIG Architecture indicates that the Kubernetes community is taking a more structured approach to how the orchestrator handles AI-specific workloads. These platform-level improvements ensure that the underlying infrastructure is robust enough to support the high-density and dynamic nature of the Agent Substrate runtime. The move to nftables and the planned removal of older network backends like IPVS also reflect a modernization of the networking stack that aligns with the needs of modern, highly scalable agent platforms.
The market impact of Google’s donation and the general availability (GA) of Substrate 1.0 is already being felt across the cloud-native landscape. By providing an open-source, foundation-backed alternative to proprietary agent sandboxing services, Google is putting pressure on specialized vendors to innovate or lower their prices. This shift is also changing how FinOps teams calculate the cost of AI applications, moving the focus from “cost per virtual machine” to “cost per active agent session.” As organizations become more sophisticated in their use of AI, the ability to run millions of agents economically will become a key competitive advantage. The move toward standardized runtimes will likely accelerate the development of agentic ecosystems, as developers can finally build with the confidence that their applications will run on any major cloud provider. This standardization is the final piece of the puzzle needed to turn AI agents from experimental prototypes into ubiquitous components of the modern enterprise software stack.
11. Operational Goals for Enterprise Platform Teams
To successfully implement this new architecture, platform teams must adopt a disciplined approach that begins with a thorough verification of their existing infrastructure. First, it is essential to ensure that all clusters are running Kubernetes 1.37 or later to take advantage of the latest security and networking enhancements. Second, teams must select an isolation mode—either gVisor or microVMs—based on a rigorous assessment of the security risks associated with their specific agent tasks. Third, it is critical to implement a robust management system for session timeouts, determining exactly when an agent should be snapshotted and suspended to maximize cost savings without compromising the user experience. These early operational steps lay the groundwork for a stable and scalable platform that can handle the unpredictable nature of agentic workloads.
Once the initial deployment is stable, the focus should shift to long-term reliability and cost optimization. Fourth, developers must evaluate connectivity patterns and ensure that agent code is designed to handle severed database and API connections gracefully during session resumption. Fifth, platform teams should conduct independent audits and benchmarks of resumption times and resource density to verify vendor claims within their own specific environments. Finally, it is imperative to review service-level agreements and support terms directly with the provider to ensure that the mission-critical needs of the organization are met. The industry reached a turning point in 2026, when the “session” replaced the “pod” as the primary unit of agent interaction. By following these steps, teams successfully transitioned their infrastructure to a model that was both more secure and more economically viable than the legacy container-centric approach.
12. Frequently Asked Questions
Is Agent Substrate 1.0 ready for production environments?
The general availability of Agent Substrate 1.0 on GKE indicates that the technology has reached a level of stability suitable for production use, supported by Google Cloud’s standard Service Level Agreements. However, its “Sandbox” status within the CNCF reminds users that the project is still in the early stages of its community-driven lifecycle. Organizations should approach production deployment by starting with non-critical workloads or limited pilot programs to ensure that the runtime’s unique snapshot-and-restore behavior aligns with their application logic. Testing for compatibility with existing network and storage infrastructure is highly recommended before migrating large-scale agentic systems to the new runtime.
How does the session-based model impact developer workflows?
The shift from Pods to sessions requires a change in how developers manage state and external connections within their agent code. Because an agent may be paused at any time and resumed on a different node, developers must treat the execution environment as ephemeral while relying on the platform to preserve the file system and memory. This means that any “out-of-band” state, such as open network sockets to external databases or live streaming connections, must be managed with robust reconnection logic. While this adds a layer of complexity to the initial development phase, it ultimately simplifies the scaling and deployment process by allowing the platform to handle the heavy lifting of resource optimization and state persistence.
