{"slug": "google-gives-cncf-3-projects-as-agent-substrate-hits-1-0", "title": "Google Gives CNCF 3 Projects as Agent Substrate Hits 1.0", "summary": "Google Cloud said on November 5 that Agent Substrate 1.0 is generally available as Agent Substrate on GKE and that it is donating Agent Substrate, gVisor and OpenRL to the Cloud Native Computing Foundation at Sandbox status, a move announced around KubeCon + CloudNativeCon North America (November 9-12). Google claims Agent Substrate delivers up to 10 times the compute density of traditional container runtimes, resumes a sandbox in under 500 milliseconds and handles more than 500 suspend and resume activations per second, all figures the company has not independently verified. The CNCF, whose portfolio reached 231 projects including 32 added in the prior year, lists Agent Substrate as a secure-by-default agent execution runtime that requires an orchestration layer such as Agent Executor or Kagent on top, positioning it as infrastructure for platform builders rather than a drop-in agent product.", "body_md": "Google Cloud said on November 5 that Agent Substrate 1.0 is generally available as Agent Substrate on GKE, and that it is donating the project, gVisor and OpenRL to the Cloud Native Computing Foundation at Sandbox status, according to [Google’s Open Source Blog](https://opensource.googleblog.com/2026/11/sandboxing-untrusted-ai-agents-at-scale.html). Two weeks later, the move reads less like a product launch and more like a bid to set the default way Kubernetes runs AI agents.\n\nThe donation was presented at KubeCon + CloudNativeCon North America, held November 9 to 12. A day after the event opened, the CNCF reported that its portfolio had reached 231 projects, including 32 added during the prior year, and named Agent Substrate among the AI-related additions. For platform teams, the question is no longer whether agents need their own runtime. It is whether Google’s runtime, now under neutral governance, becomes the one everybody builds on.\n\nThe release closes a loop that began in May, when Google announced Agent Sandbox, and it follows the earlier [GKE Agent Sandbox rollout](https://shattered.io/gke-agent-sandbox-gvisor-300-per-second-2026/) that put gVisor isolation in front of cluster operators. Below, the confirmed facts are separated from Google’s own claims, the donated projects are mapped against their closest peers, and the gaps in the public record are listed.\n\nDon't miss new tech stories on Google\n\nAdd Shattered once in the Google app and our stories show up in your news suggestions.\n\n[Add now](https://www.google.com/preferences/source?hl=en&q=https%3A%2F%2Fshattered.io%2F)\n\n## What Agent Substrate 1.0 Ships on GKE\n\nTwo names matter, and the difference is practical. Agent Substrate is the open-source runtime. Agent Substrate on GKE is Google Cloud’s managed offering, which reached general availability on November 5. Google says the managed capability runs on Google Cloud, while the open-source code can be deployed on other conformant Kubernetes clusters. Agent Substrate first became available on GKE on September 15, so the 1.0 label arrived roughly seven weeks after the initial release.\n\nThe CNCF project page describes it as “a secure-by-default agent execution runtime for running millions of sandboxes.” Google’s own post frames it as an orchestrator for agentic applications, built so a platform can hold huge numbers of agent sessions without keeping a machine busy for each one. It offers two isolation options: Cloud Hypervisor microVMs for full Linux-kernel compatibility, and gVisor for lower-overhead kernel isolation.\n\nGoogle states three performance claims. Agent Substrate can deliver up to 10 times the compute density of traditional container runtimes, resume a sandbox in under 500 milliseconds, and handle more than 500 suspend and resume activations per second. Every one of those figures comes from Google. The [10x density claim](https://shattered.io/agent-compute-engine-vs-agent-substrate-10x-claim-checked-2026/) deserves independent testing before anyone writes it into a capacity plan.\n\nOne more detail from the CNCF’s November 11 technical guide changes how buyers should read the launch. Agent Substrate is not meant for direct use by end users. It needs an orchestration layer such as Agent Executor or Kagent on top. That makes it infrastructure for platform builders, not a drop-in agent product.\n\n## Why Idle Agents Break the Pod Model\n\nKubernetes made the Pod the default unit of compute for web services. A program boots, binds a port, serves traffic and runs until someone stops it. Agents do not behave that way. Google’s launch post says an interactive agent “can spend 90% to 95% of its time waiting for model inference, external APIs, or human reviews.” During that wait, it burns almost no CPU, yet it still holds state: language runtimes, local repositories, uncommitted edits and tool sessions.\n\nPlatform engineers face two poor options with plain Kubernetes. They can keep a dedicated Pod alive all day, which keeps the agent warm but bills for idle compute around the clock. Or they can scale to zero, which saves money but forces a cold rebuild of memory and files when the next prompt arrives. Google argues the first option gets unaffordable at large user counts and the second wrecks interactive response times.\n\nA guide Google published on November 16 puts numbers on the waste. It treats agent workloads as sessions rather than requests, and it works through one developer’s day. Assume two prompts an hour across an eight-hour workday (Google’s stated assumption). The agent works about 22% of that day and waits for nearly 78% of it. If each session holds a machine, the team pays for the waiting.\n\nThe same Google post names a second bottleneck: [control plane](https://shattered.io/ecs-vs-eks-2026/) load. Reinforcement learning loops and benchmark suites run untrusted agent code across thousands of tasks at once. If every sandbox needs a full Pod, scheduling and tearing down that many short-lived objects strains the cluster’s core components. Substrate’s pitch is that it avoids creating a new Pod object each time an agent wakes.\n\n## How Actors, Workers and Warm Pools Work\n\nAgent Substrate splits the stateful agent from the compute that serves it. An Actor represents one agent session, complete with its filesystem, environment variables, memory state and network rules. A Worker is a pre-warmed Kubernetes Pod drawn from a shared pool, equipped with container runtimes and sandbox boundaries. One Worker can host several Actors over time.\n\nThe lifecycle of an agent turn follows four steps. An incoming call reaches a proxy, which holds the request in memory if the Actor is suspended. The controller assigns the Actor to a free slot in the warm pool. The Actor’s memory and disk state restore from tiered storage and the agent resumes where it paused. When the turn ends, Substrate snapshots the state and frees the slot for someone else.\n\nArchitecturally, the system separates agent execution from machine management. It adds agent identities, egress proxies that enforce policy, and snapshots of idle agent state for later resumption. Per [NVIDIA’s technical blog](https://developer.nvidia.com/blog/agent-substrate-advancing-kubernetes-for-agents-at-scale/), Agent Substrate has its own scheduler, controller and sandbox runtime, and it does not use Agent Sandbox directly. Readers who assumed Substrate was a renamed Agent Sandbox should drop that idea. Google’s current naming keeps the two products separate, and no source shows a rename.\n\nThe practical effect is a shift in what counts as a unit of capacity. Instead of sizing a node pool by Pods per user, teams size a warm pool by how many agents are active at the same moment. The remaining sessions sit parked. That is a cheaper model on paper, and it explains why Google’s November 16 guidance focuses on GKE node pool sizing for agent sessions.\n\n## gVisor and MicroVMs: Two Isolation Choices\n\nAgents run code a model wrote, and that code may be hostile or simply wrong. Standard Linux containers share the host kernel, which is a risk on multi-tenant nodes. Google describes [gVisor](https://gvisor.dev/docs/) as its open-source application kernel, written in Go, that intercepts system calls in user space and keeps untrusted code away from the host kernel.\n\n### Why gVisor Fits Snapshot-and-Restore\n\nGoogle’s explanation for the pairing is technical. Because gVisor virtualizes its own memory and process tables, Substrate can freeze a running environment, write its memory pages to storage and restore them on another node. That is hard to do with a stock container, which explains why the two projects travel together.\n\n### When a MicroVM Is the Safer Pick\n\nFor workloads that need hardware virtualization or custom kernel modules, Substrate also supports Cloud Hypervisor microVMs. The trade is familiar. gVisor costs less per sandbox but reimplements parts of the Linux interface, so unusual syscalls can behave differently. A microVM gives a fuller kernel and a hardware boundary at the price of more overhead. Security teams that handle regulated data will likely start with the microVM option and relax only after testing.\n\ngVisor itself keeps shipping. The project’s releases page lists 20261109.0 and 20261116.0, with the later one marked as the newest, which confirms active maintenance after the donation rather than a handoff to nobody. The November 9 release added UDP support in netgofer, signal-handling fixes, more /proc files, checkpoint and restore work, and support for Bazel 9.3.1. Governance is still settling, though. Reporting on the donation says independent build infrastructure and community-maintainer onboarding were still being established, and Google described gVisor as on a path toward Incubation without having reached it.\n\n## The CNCF Sandbox Donation: What the Status Means\n\nAgent Substrate, gVisor and OpenRL sit at the Sandbox maturity level. They are not Incubating and not Graduated, and any headline that says otherwise is wrong. The CNCF’s own project page for Agent Substrate confirmed the Sandbox listing on November 18. Sandbox is the entry rung of the foundation’s maturity ladder, so it signals neutral governance and an open door for outside maintainers, not proof of production maturity.\n\nSources disagree on when the application cleared. Google’s account points to an October acceptance ahead of the November 5 announcement, while one CNCF technical guide reportedly says Agent Substrate was voted into the Sandbox on September 28. The discrepancy does not change the current status, but it is a reminder to cite the announcement date rather than an acceptance date.\n\nThe wider backdrop is a foundation leaning into AI infrastructure. In its [November 10 milestones announcement](https://www.cncf.io/announcements/2026/11/10/cncf-hits-major-milestones-with-global-community-growth-record-industry-investment-and-a-new-generation-of-projects-to-build-ai-systems-in-production/), the CNCF reported 231 projects, more than 5.5 million additional cloud-native developers over the preceding 12 months, and 82,000 event attendees worldwide. Agent Substrate, NVIDIA’s OpenShell and llm-d were among the highlighted AI-related additions.\n\nFor Google, the donation trades control for adoption. A runtime that only runs well on one vendor’s cloud struggles to become a standard. A runtime governed by a foundation, with maintainers from several companies, has a better shot. For customers, the practical benefit is an exit path. If Agent Substrate stalls, the code and the governance do not belong to a single company’s roadmap.\n\n## Timeline: From Agent Sandbox to a 1.0 in Under Six Months\n\nThe sequence matters because it shows how quickly Google moved from an execution environment to a full orchestration runtime. From the May 20 Agent Sandbox announcement to the November 5 GA took under six months.\n\n| Date (2026) | Event | Why it matters | \n|---|---|---|\n| May 20 | Google announces Agent Sandbox, an open-source Kubernetes-native environment for untrusted agent logic | First building block for isolated agent execution | \n| September 15 | Agent Substrate becomes available on GKE | Managed access begins ahead of 1.0 | \n| October 20 | Google announces llm-d 1.0, an open-source distributed-inference stack | Adds the inference layer to Google’s open stack | \n| November 5 | Agent Substrate 1.0 reaches GA on GKE, donation to CNCF Sandbox announced | Managed product and neutral governance arrive together | \n| November 9 to 12 | KubeCon + CloudNativeCon North America | Donation presented to the community | \n| November 10 | CNCF reports 231 projects and highlights AI additions | Foundation signals agent infrastructure as a priority | \n| November 11 | CNCF guide separates OpenShell’s policy role from Substrate’s execution role | Clarifies how the two projects fit together | \n| November 16 | Google publishes GKE node pool sizing guidance for agent sessions | First operational cost advice after GA | \n| November 18 | CNCF project page confirms Sandbox status | Maturity level stays at entry tier | \n\nGoogle also presented the three donated projects on November 10 as parts of an open AI-native Kubernetes stack, with Agent Substrate handling agent orchestration, gVisor handling sandboxing and llm-d handling distributed inference. A Google demonstration reportedly ran 1,000 sandboxed agents on Agent Substrate on GKE against a single llm-d endpoint, though that figure comes from one source and should be read as a showcase rather than a benchmark.\n\n## Three Projects, Three Jobs\n\nThe donation bundles three projects that solve different problems, and mixing them up is the most common mistake in early coverage. The table below separates them, along with the two neighbors Google keeps mentioning.\n\n| Project | Job | Status as of Nov. 19 | Release marker | \n|---|---|---|---|\n| Agent Substrate | Orchestrates and suspends agent sessions, with identities and egress policy | CNCF Sandbox, GA on GKE | 1.0 on November 5 | \n| gVisor | User-space kernel that isolates untrusted code from the host | CNCF Sandbox, path toward Incubation | 20261116.0 listed as latest on the releases page | \n| OpenRL | Kubernetes-native reinforcement-learning post-training service | CNCF Sandbox | No numbered version identified, repository updated November 17 | \n| llm-d | Distributed inference for the open AI stack | Listed among CNCF AI-related additions | 1.0 announced October 20 | \n| Agent Sandbox | Kubernetes-native execution environment for untrusted agent logic | Remains a separate product, not retired | Announced May 20 | \n\nOpenRL is the odd one out. It has no bearing on how an agent runs in production, because it sits in the training layer. Google describes it as the post-training part of its Kubernetes AI stack, and the public repository presents it as a self-hosted API for reinforcement-learning infrastructure with a Tinker-compatible API for [fine-tuning](https://shattered.io/category/ai-machine-learning/) language models on one machine or a cluster. Teams choosing an agent runtime can ignore it. Teams training their own agents should watch it.\n\nNothing in the sources shows Agent Sandbox being retired or replaced. Google’s naming still treats Agent Sandbox on GKE and Agent Substrate on GKE as distinct. One non-official report also describes a separate Agent Compute Engine, reportedly introduced on October 22 as a managed, agent-specific Google Cloud service with a microVM per agent. Treat that as a single-source claim until Google documents it more fully.\n\n## Agent Substrate vs OpenShell, Agent Sandbox and OpenKruise\n\nAgent Substrate is not alone in the CNCF’s agent corner. NVIDIA’s OpenShell was announced for CNCF governance on November 10, and OpenKruise shipped a new agent-sandbox release on November 3. The foundation’s own November 11 guide drew a clean line between the first two. OpenShell focuses mainly on what an agent may do. Agent Substrate focuses on running large numbers of mostly idle agents efficiently and securely. The CNCF calls them complementary, not rivals.\n\n| Project | Origin | Main focus | Latest confirmed marker | \n|---|---|---|---|\n| Agent Substrate |  | Scale and isolation for mostly idle agents, with its own scheduler and controller | 1.0, November 5 | \n| OpenShell | NVIDIA | Policy and governance over agent behavior and access | CNCF governance announced November 10 | \n| Agent Sandbox |  | Execution environment for untrusted agent logic, not used directly by Substrate | Announced May 20 | \n| OpenKruise Agents | OpenKruise community | Lifecycle management for agent sandboxes, with Kubernetes and E2B interfaces | v0.6.0, November 3 | \n| Agent Executor and Kagent | Named by the CNCF guide | Orchestration layers that sit above Agent Substrate | No versions given in sources | \n\nThe CNCF guide treats a future OpenShell and Agent Substrate integration as a possibility, not a confirmed feature. That caution matters. Buyers sometimes read “complementary” as “already integrated,” and nothing published says the two work together today. Each also solves only part of the safety problem. A runtime that isolates code does not decide which tools an agent may call, and a policy engine that approves actions does not contain a compromised process.\n\nThe NVIDIA connection is worth a second look. NVIDIA owns a policy project that sits next to Substrate in the CNCF, yet it also published its own technical post on Agent Substrate on November 10. A company that backs a neighboring project and still writes up a rival’s runtime is signaling that it expects the two to coexist.\n\n## The Fine Print: Pricing, Limits and Unknowns\n\nNo official standalone price exists in the sources. Google’s retrieved announcements do not list a per-agent charge, a per-sandbox charge, a subscription tier or a separate SKU for Agent Substrate on GKE. A November 16 report says there is no separate Agent Substrate fee and that the bill comes from GKE, Compute Engine, [Cloud Storage](https://shattered.io/best-cloud-storage-google-onedrive-icloud-dropbox-proton-pcloud-2026/) and related infrastructure, but that is a third-party reading and not a Google price list. Budget owners should ask Google to confirm in writing.\n\nAn independent [analysis from The D*AI*LY Brief](https://www.beri.net/article/google-agent-substrate-1-0-gke-ga-cncf-sandbox-gvisor-no-gpu-passthrough-mcp-reconnect-standard-only-vs-agentcore-e2b) on November 9 reads the GKE documentation more skeptically. It reports that the product requires GKE Standard clusters on Kubernetes 1.37 or later, rules out GPU passthrough into agent containers, and drops open database and MCP connections when an agent suspends. The same piece notes that every published performance figure is Google’s own and that production support terms deserve confirmation. These points come from one reviewer’s reading, so check them against current Google documentation before you commit.\n\nEven with those caveats unresolved, the limits are plausible. A runtime that snapshots memory and restores it on another node must decide what to do with live network connections and device state. An agent that calls a hosted model endpoint is a good fit. An agent that runs local GPU inference inside its sandbox is not obviously one, and the public sources say little about that case.\n\nOther unknowns remain. The sources identify no named maintainers or business leaders with current titles for Agent Substrate. They do not confirm whether Google’s Antigravity product relates commercially to the runtime. And they identify no OpenRL version number. When a source gap exists, treat it as a gap and not as a feature.\n\n## Kubernetes 1.37 and the Platform Under the Agents\n\nAgent Substrate rides on Kubernetes, so the state of Kubernetes itself shapes the rollout. The project maintains release branches 1.37, 1.36 and 1.35, and the newest confirmed release is v1.37.1 from September 15. The kubeadm documentation now targets Kubernetes v1.37. Teams on older clusters should confirm version requirements before planning a pilot.\n\nSeveral Kubernetes changes touch the same territory. On October 29, the project moved its AI Conformance effort from a working group into SIG Architecture as a subproject, with Janet Kuo of Google and Yuan Tang of TensorScale AI named in the discussion. Kubernetes 1.37 also promoted a rootless kubelet mode to Beta according to project documentation, which gives local coding-agent setups another way to reduce damage from a malicious instruction. That feature is separate from Agent Substrate, and it should not be confused with it.\n\nA third item is routine but urgent for operators. On November 16, Kubernetes announced that the IPVS backend for kube-proxy, deprecated in 1.35, is now planned for removal in 1.40. The project recommends moving to nftables on Kubernetes 1.36 or later where kernel requirements are met. Teams preparing an agent platform on new clusters can skip the migration by starting on nftables.\n\nCloud choice also matters. Anyone comparing managed Kubernetes modes should read the [EKS Auto Mode, GKE Autopilot and AKS Automatic comparison](https://shattered.io/eks-auto-mode-vs-gke-autopilot-vs-aks-automatic-2026/) alongside the Substrate documentation, since the runtime’s cluster requirements and a hands-off node mode may not line up. The managed offering is a GKE product, while the open-source code is the route for everyone else.\n\n## Market Impact: Who Gains, Who Feels Pressure\n\nThe immediate winner is Google Cloud. It gets a managed product with a story about neutral governance, which is a stronger sales line than a proprietary runtime. The foundation gets a marquee AI project. Early adopters get a chance to shape a project while it is young. The pressure falls on vendors that sell sandboxing as a closed service, because an open runtime with a managed option narrows their pitch to convenience.\n\nRival clouds will respond in kind. Each sells its own way to run agent code, and each now has to explain how that approach compares with an open runtime that other clouds can host. Google steers teams that want Kubernetes standardization, multi-cloud portability or customization to Agent Substrate on GKE. According to one report, a managed, agent-specific service suits teams that would rather operate less.\n\nSecurity vendors have a different opening. Containment is only as good as its tests, and recent incidents show why buyers worry. A test in which [Gemini 4 Argon agents slipped their sandbox](https://shattered.io/gemini-4-argon-agents-bypass-safeguards-hit-live-epoch-ai-website/) and reached a live Epoch AI site made the point that agents probe their limits. A runtime with egress policy and per-agent identity speaks directly to that fear, even if it cannot promise that nothing escapes.\n\nFinOps teams get a new line of questioning. If idle sessions park in object storage instead of holding nodes, the unit that matters is cost per active session hour, not cost per node. Google’s sizing guidance pushes buyers toward that framing. Expect cost dashboards for agents to start with a simple ratio: how much capacity the platform reserves versus how much work the agents do.\n\n## Historical Context: From Pods to Sessions\n\nGoogle’s launch post opens with a deliberate echo. When Google introduced Kubernetes, it made the Pod the default unit of compute for the cloud, and the design assumed a program that boots, serves traffic and keeps running. The post argues agents need a new unit in the same way containers needed Kubernetes. Whether that parallel holds is a matter of opinion, but the framing shows Google’s ambition for the project.\n\nInternal tools turning into open standards has precedent in cloud-native software, and Kubernetes itself is the obvious example. What differs this time is the speed. A product that started as a May announcement is a foundation project by November. Describing gVisor as only an internal Google Cloud component is now out of date.\n\nSpeed has costs. A 1.0 label means the project’s maintainers consider the APIs stable enough to commit to. It does not mean thousands of teams have run it under load. The CNCF’s Sandbox tier exists for exactly that gap, and the project’s young age is the right lens for any production decision made this quarter.\n\n## Five Predictions for Agent Runtimes\n\nThese are forecasts, not reported facts, and each could miss.\n\n- **More entrants arrive in the Sandbox tier.** With Agent Substrate, OpenShell and OpenKruise Agents already in the conversation, the CNCF will likely treat agent execution as a standing category and attract more proposals.\n- **Policy and runtime projects pair up.** The CNCF guide called an OpenShell integration a possibility. If a working pairing appears, it will become the reference design for governed agent platforms.\n- **Third-party tests challenge Google’s density claims.** The 10x and sub-500-millisecond figures are Google’s own. Independent benchmarks will either confirm them under realistic loads or shrink them.\n- **Cloud bills add a per-session line.** Finance teams will ask for cost per active agent session, and providers will expose it in billing exports.\n- **gVisor’s governance becomes the thing to watch.** Its path toward Incubation depends on independent build infrastructure and a wider maintainer base, and progress there will say more than release cadence.\n\n## What Platform Teams Should Do This Quarter\n\nStart with a bounded pilot and keep the claims honest. The steps below fit a two-person platform team and avoid commitments the sources cannot support.\n\n- Confirm your clusters meet the Kubernetes version requirement and read Google’s current install guide, since the managed offering depends on specific cluster types.\n- Pick an isolation mode on purpose. Use a microVM for code from untrusted input, and use gVisor where lower overhead matters and your tests show compatibility.\n- Decide who suspends idle agents. Your harness or the service in front of it needs a clear idle timeout.\n- Test what breaks at suspend, especially database connections and tool sessions, and make the agent rebuild them on wake.\n- Measure density and resume time yourself before accepting Google’s figures.\n- Ask Google to confirm pricing and production support terms in writing.\n- Follow the [cloud computing section](https://shattered.io/category/cloud-computing/) and the CNCF project page for status changes, because Sandbox projects can move quickly.\n\n## Frequently Asked Questions\n\n**Is Agent Substrate generally available?**\n\nYes, on GKE. Google announced on November 5 that Agent Substrate 1.0 is generally available as Agent Substrate on GKE. Any reference to a preview or a pre-1.0 build as the current release is out of date.\n\n**Does Agent Substrate only run on Google Cloud?**\n\nNo. The managed product runs on Google Cloud, but Google says the open-source code can be deployed on other conformant Kubernetes clusters. Calling it only a GKE feature is incomplete.\n\n**Which projects did Google donate to the CNCF?**\n\nThree: Agent Substrate, gVisor and OpenRL. All three sit at Sandbox status. None has reached Incubation or Graduation.\n\n**How much does Agent Substrate on GKE cost?**\n\nNo standalone official price is confirmed. A third-party report says charges come from the underlying GKE and Google Cloud infrastructure rather than a separate fee, but Google has not published that as a price list in the sources reviewed.\n\n**How does Agent Substrate differ from OpenShell?**\n\nThe CNCF says they are complementary. OpenShell focuses on what an agent may do. Agent Substrate focuses on running many mostly idle agents efficiently and securely. A direct integration is described as a possibility, not a shipped feature.\n\n**Is Agent Substrate the same as Agent Sandbox?**\n\nNo. Agent Sandbox is the Kubernetes-native execution environment Google announced on May 20. Agent Substrate has its own scheduler, controller and sandbox runtime and does not use Agent Sandbox directly. No source reports a rename or retirement.\n\n**Should teams run it in production now?**\n\nThat is a judgment call. GA and a 1.0 label point toward readiness, while Sandbox status and the project’s youth argue for a bounded pilot first. Verify limits and support terms in current documentation, and test the performance claims in your own environment.", "url": "https://wpnews.pro/news/google-gives-cncf-3-projects-as-agent-substrate-hits-1-0", "canonical_source": "https://shattered.io/google-donates-agent-substrate-gvisor-openrl-cncf-sandbox-1-0-gke-ga/", "published_at": "2026-11-19 08:16:37+00:00", "updated_at": "2026-11-19 08:43:42.721771+00:00", "lang": "en", "topics": ["ai-agents", "ai-infrastructure", "ai-safety", "developer-tools", "ai-policy"], "entities": ["Google Cloud", "Agent Substrate", "Cloud Native Computing Foundation", "gVisor", "OpenRL", "KubeCon + CloudNativeCon North America", "Agent Executor", "Kagent"], "also_reported_by": [], "takeaway": "Agent Substrate 1.0 offers two isolation options — Cloud Hypervisor microVMs for full Linux-kernel compatibility and gVisor for lower-overhead kernel isolation — and claims sub-500ms sandbox resume and over 500 suspend/resume activations per second, but it needs an orchestration layer like Agent Exe", "recommendation": null, "alternates": {"html": "https://wpnews.pro/news/google-gives-cncf-3-projects-as-agent-substrate-hits-1-0", "markdown": "https://wpnews.pro/news/google-gives-cncf-3-projects-as-agent-substrate-hits-1-0.md", "text": "https://wpnews.pro/news/google-gives-cncf-3-projects-as-agent-substrate-hits-1-0.txt", "jsonld": "https://wpnews.pro/news/google-gives-cncf-3-projects-as-agent-substrate-hits-1-0.jsonld"}}