Google I/O 2026: the second hyperscaler agentic-DevOps stack

The Second Public Hyperscaler Agentic-DevOps Receipt of 2026

On May 19, 2026, the Google I/O ’26 keynote and the I/O ’26 developer-track session for Google Cloud filled out what is now the second complete hyperscaler-side agentic-DevOps stack on the public market in 2026. The four components landed together: Antigravity 2.0 as the standalone agent-first coding and orchestration surface (with CLI, SDK, managed execution, and enterprise-support tier), Managed Agents API as the hosted agent runtime for technical teams that want the agent without the IDE surface, Agent Development Kit (ADK) 2.0 as the code-first multi-agent framework with a unified graph-based engine, and Agent Studio as the low-code business-team entry point. The four pieces share a common foundation for execution, governance, interoperability, and enterprise deployment under the Gemini Enterprise Agent Platform, which itself went GA at Google Cloud Next ’26 on April 22, 2026 as the rebrand of Vertex AI.

The May 19 release comes six weeks after the AWS DevOps Agent GA (March 31, 2026) covered in batch 28 of this catalog, and reinforces a pattern the agentic-DevOps category should now treat as the operating assumption: the hyperscalers are shipping coordinated agentic-DevOps stacks on a GA cadence, with named reference customers, billed through their own cloud spend, and locked to their own native service surface. Microsoft Copilot for Azure ships continuous expansion against the same shape on the Azure side. The agentic-DevOps category is no longer a startup-only category. It is now a contested GA-track category that the three largest cloud providers in the world are investing in directly.

The structural lesson from batch 28’s coverage of the AWS DevOps Agent GA stands: hyperscaler-side stacks are the validation of the category, not the closing of it. The shape that generalizes for the enterprise that runs on more than one cloud is structurally different from the hyperscaler-shipped agentic stack, and the difference is becoming more important — not less — as the hyperscalers ship more agent surface.

What the Google I/O ‘26 Stack Actually Ships (and What It Doesn’t)

Reading the four pieces of the May 19 Google Cloud stack against the active-operational-layer architecture surfaces three structural notes platform teams should carry into their 2026 evaluation.

Antigravity 2.0 is the coding and orchestration surface, not the operational substrate. Antigravity 2.0 is the IDE-and-CLI surface where developers write, run, and govern agents on Google Cloud. It is the agent-development surface. It is not the operational fabric that runs the production cloud — that fabric lives in the Managed Agents API runtime, the ADK 2.0 execution graph, and the Gemini Enterprise Agent Platform governance plane. The distinction matters: Antigravity 2.0 is the GCP-side answer to a development-time question (how does the platform engineer build the agent), and the operational substrate is the answer to a run-time question (how does the agent execute, what scope does it have, what audit trail does it produce). The two are coupled inside the Google Cloud surface and are decoupled by the active-operational-layer category.

The Managed Agents API runtime is GCP-billing-line-item. Like the AWS DevOps Agent on AWS, Google’s Managed Agents API is billed through the customer’s Google Cloud spend. The model-call cost lives inside the Gemini Enterprise inference billing. The orchestration cost lives inside the Agent Platform billing. The operational reading is that this is fine when GCP is the only cloud and is a multi-cloud accounting problem otherwise. Cross-cloud enterprises end up with agent spend on three or more bills, three or more model-provider commitments, and three or more sets of orchestration-pricing knobs to negotiate. The procurement, finance, and audit surfaces all multiply with the cloud footprint.

The agent surface is GCP-native. ADK 2.0’s graph-based engine, the Managed Agents API runtime, and Agent Studio are all built against Google Cloud’s native service catalog (Cloud Run, Cloud Functions, GKE, Vertex AI inference, Cloud Logging, BigQuery, Spanner, Cloud Storage, IAM). Cross-cloud incidents — the customer running GKE in GCP alongside EKS in AWS and AKS in Azure — are out of scope for the agent’s correlation graph by default. A platform team operating on more than one cloud has the agentic-DevOps story for the GCP-only fraction of their footprint and a “different agent on a different cloud with a different audit trail and a different model-cost model” story for the rest.

The point here is not that Google made the wrong product choices. Google made the right product choices for Google Cloud’s customers. The point is that the same design choices make the May 19 stack the GCP-shaped answer to a question that, for many mid-market and enterprise platform teams, is a multi-cloud question — exactly as the AWS DevOps Agent GA is the AWS-shaped answer to the same multi-cloud question.

The 2026 Multi-Cloud Agentic-DevOps Reality

The platform-team operational reality is now this. The mid-market and enterprise platform team running on more than one hyperscaler has two structurally-distinct agentic-DevOps stacks shipped at GA in the last six weeks (AWS DevOps Agent, Google’s I/O ’26 stack), with Microsoft Copilot for Azure shipping continuous capability expansion on the Azure side, and the open-source / startup agentic-DevOps category continuing to ship on top of model-provider APIs. The customer has four (or more) places where an “AI DevOps agent” could be doing work, each with a different scope, a different billing channel, a different identity model, a different audit-trail surface, a different remediation primitive, a different approval model, and a different operational vocabulary.

The naive read of that situation is “the customer picks the agent for the cloud it lives on.” That works for the single-hyperscaler customer. It does not work for the multi-cloud customer, because the operational reality of the multi-cloud customer is that incidents, configuration changes, cost regressions, security drift, and compliance posture cross hyperscaler boundaries continuously. A platform team that has a federation of single-cloud agents — one on AWS, one on GCP, one on Azure, one on the on-prem fleet — has a federation, not a team. The agents do not share context. The audit trails do not reconcile. The remediation primitives do not chain. The on-call engineer is the integration layer.

The shape that generalizes for the multi-cloud enterprise is structurally distinct from the hyperscaler-shipped agentic stack. It has three properties no hyperscaler stack carries by design:

1. Multi-cloud inventory as the unit of analysis, not the single hyperscaler’s surface. The agent team correlates an EKS misconfiguration in AWS against a GCP IAM policy change against an Azure-side managed-service CVE in a single investigation. The inventory is cross-cloud. The audit trail is cross-cloud. The remediation primitive is cross-cloud — a remediation PR against the configuration-as-code repository that drives every cloud.

2. BYOK on model keys, decoupled from the cloud spend. The customer brings their own Anthropic / OpenAI / vendor keys and pays inference costs directly to the model provider. The orchestration layer charges for the per-action orchestration work, not for the LLM call wrapping. The customer can swap the model when a cheaper / better model ships without re-procuring the agent, without re-negotiating with three hyperscalers, and without losing audit-trail continuity.

3. Capability-tier governance per agent action, expressed identically across clouds. Observe-tier actions (read-only audits, cost analysis, security scans, drift detection, inventory) run automatically and are fully audited. Operate-tier actions (deployments, tagging, resource changes, policy application, remediation PRs) auto-execute for reversible / scoped changes and gate on approval for anything irreversible or out-of-policy. Administer-tier actions (organization-level changes, billing, IAM, role management, approval policy itself) always require explicit approval, with separation-of-duties enforced. The same capability-tier model maps onto every cloud, so the customer’s approval policy is the customer’s approval policy, not three different approval policies the customer has to keep aligned across three hyperscaler surfaces.

A single-hyperscaler agent does not need cross-cloud, does not need BYOK (the model cost lives inside the cloud spend), and can run with the cloud-provider’s own native approval gate. A multi-cloud team needs all three. The question for the multi-cloud platform team is not “AWS DevOps Agent or Google Managed Agents API or Microsoft Copilot for Azure?” For each cloud-locked workload, the answer is yes — use the hyperscaler-native agent for the parts of the footprint where the hyperscaler-native agent is the highest-leverage choice. The question is “what is the shape for the rest of the footprint, and how does the audit trail reconcile across the cross-cloud team?” The answer is the active operational layer.

See the IAN team run on your cloud. We connect to your AWS account via a scoped read-only role, run the Observe-tier agents, and leave you with a concrete audit report — cost waste, security exposure, compliance gaps, and a labor-offset estimate. You keep the findings regardless of next steps. Get a free infrastructure audit →

What the Google I/O ’26 Stack Means for the Active Operational Layer Category

For platform teams thinking about how to evaluate the agentic-DevOps category in the second half of 2026, the Google I/O ’26 stack shifts four operational questions.

• The agentic-DevOps category is now a contested GA category, not a research category. Two of the three largest cloud providers shipped agentic-DevOps stacks at GA in the last six weeks. The third (Microsoft) has been shipping Copilot for Azure expansion on a quarterly cadence. The category has crossed from “interesting startup space” to “competed-for enterprise budget” in the span of a single quarter. Platform teams evaluating an agentic-DevOps deployment should now expect to compare multiple GA-grade options against their own operational baseline, not vet a single research-stage offering.
• The multi-cloud-coordination problem is the differentiator. Single-cloud agentic-DevOps is a solved problem at GA grade — the customer picks the hyperscaler-native agent for the cloud it lives on. The remaining structural problem is the multi-cloud-coordination problem: how do the agents share context, reconcile audit trails, chain remediation, and present a single approval surface across clouds? Platform teams evaluating the agentic-DevOps category should treat the multi-cloud-coordination capability as the load-bearing differentiator, not as a nice-to-have.
• BYOK is the procurement unlock. With four (or more) potential agentic-DevOps surfaces in play, the customer’s model-spend negotiation is now the procurement bottleneck. BYOK pricing — customer brings the model keys, agent layer charges for orchestration — removes the bottleneck. The customer can negotiate the model spend once, with the model provider, and amortize it across every agent surface. Platform teams that have not yet structured their model-spend negotiation around BYOK should expect the procurement cycle to dominate the deployment timeline of any wrapping-LLM-call-and-charging-markup agent.
• The audit trail is the cross-cloud reconciliation artifact. Each hyperscaler-native agent ships its own audit-trail surface (CloudTrail on AWS, Cloud Audit Logs on GCP, Azure Activity Logs on Azure). The cross-cloud team needs a unified audit-trail substrate that captures every agent action across every cloud, with the agent identity, the input, the output, the tier, the approver, and the wall-clock time. Without that substrate, the cross-cloud team has a federation of single-cloud agents, not a coordinated team. Platform teams evaluating the agentic-DevOps category should ask the unified-audit-trail question on the first call.

The four shifts together are the difference between an agentic-DevOps category that is “three hyperscaler stacks plus some startups in the gaps” and an agentic-DevOps category that is “the active operational layer that runs cloud infrastructure across hyperscalers, with humans in the loop only where judgment matters.”

The Active Operational Layer Crosses Three Agent Pillars Per Investigation

Most discussions of agentic-DevOps frame the work as a single-agent task. The 2026 operational reality is that the work crosses three agent pillars per investigation — at minimum.

• Incident / SRE agent. Detects the anomaly, frames the investigation, traces the cross-cloud correlation graph, surfaces the root-cause candidate, proposes the remediation. This is the agent that maps most directly onto the AWS DevOps Agent and Google’s Managed Agents API on the hyperscaler-native side.
• Resource-operations agent. Maintains the live inventory of every cloud resource across every connected account — instances, clusters, managed-service surfaces, IAM bindings, network topology, tag hygiene, lifecycle state. The inventory is the input the SRE agent reads to compute the correlation graph.
• Deployment agent. Owns the release log, the rollback primitive, the health-check surface, and the deployment-window planner. The SRE agent reads the deployment agent’s release log as the first hypothesis surface for any latency or error-rate change.

The three work as a coordinated team. An SRE agent that surfaces the anomaly without the resource-operations agent’s inventory has no correlation graph to traverse. A resource-operations agent that maintains inventory without the SRE agent’s anomaly stream has no operational signal. A deployment agent without the SRE agent’s anomaly correlation has no signal that a release should be rolled back. The 2026 platform-engineering shape is the three pillars working together on the same operational fabric, across every cloud.

How IAN Helps: The Multi-Cloud Coordinated Team on the Active Operational Layer

IAN is the AI DevOps team for cloud infrastructure, delivered as a coordinated team of specialized agents on the active operational layer. The Google I/O ’26 stack is the second hyperscaler validation of the category IAN has been building toward since the start of 2026, on the architectural shape that generalizes across the multi-cloud enterprise footprint.

• Five specialized agents per environment. Cost agent for spend, regressions, rightsizing, and waste cleanup. Security agent for configuration audits, drift detection, and exposure surfacing. Incident / SRE agent for anomaly detection, investigation, and proposed or executed remediation. Deployment agent for release orchestration, health checks, and rollback paths. Resource-operations agent for tagging, quotas, lifecycle, and inventory hygiene.
• Multi-cloud by default. Live on AWS today with the operational pattern. GCP, Azure, Kubernetes, and on-prem adapters on the roadmap. The cross-cloud inventory is the same inventory the agents read regardless of which hyperscaler the workload lives on.
• BYOK on model keys. Customers bring their own Anthropic / OpenAI keys. The agent layer does not see incident investigation or remediation orchestration as an LLM-call-markup opportunity. Pricing is usage-based on orchestration actions, with a monthly minimum.
• Capability-tier governance. Observe-tier scans run automatically. Operate-tier remediations gate on pre-authorized scope. Administer-tier changes require explicit human approval with separation-of-duties. The capability-tier model is the runtime expression of “AI agents are first-class citizens” — the same framing the May 2026 DevOpsCon London / Platform Engineering Week conference program put on the public record.
• Shared orchestration through Hermes. The five agents read from a shared context substrate. When the SRE agent investigates a latency spike, it has the cost-agent’s recent rightsizing history, the resource-agent’s tag changes, the security-agent’s recent finding stream, and the deployment-agent’s release log — all in the investigation context, without a separate integration. Cross-cloud, cross-pillar, single context.
• Immutable audit trail. Every agent action, every approval, every exception, every cross-pillar context fetch lands in the customer’s per-tenant audit-trail store. The audit trail is the reconciliation artifact across every cloud and every pillar.
• MCP-first interface. The agent team is reachable from Claude, Claude Code, Cursor, and any MCP-compatible client. Engineers do not learn a new UI; they speak to the team from the conversational AI clients they already use.

The Google I/O ’26 stack and the AWS DevOps Agent GA are the validation that the hyperscalers see the category as worth a flagship product. IAN is the validation that the multi-cloud, BYOK, capability-tier-governed shape is the shape that generalizes across the enterprise footprint the hyperscalers cannot, by design, cover end-to-end.

The Three-Phase Rollout

Phase 1 — Observe the operational posture across the multi-cloud footprint. Run the cost, security, and resource-operations agents in Observe mode against the connected AWS / GCP / Azure / Kubernetes / on-prem accounts. Produce the per-pillar finding stream, the cross-cloud inventory baseline, the per-cloud cost and security posture, and the per-agent confidence calibration. The SRE agent shadow-runs the customer’s last 30-60 days of cross-cloud incidents and produces a per-incident-class accuracy distribution against the pre-agent baseline. Two-to-four weeks.

Phase 2 — Codify the per-tier scope and promote to Operate-tier. Pre-authorize the Operate-tier scope for the cost agent (rightsizing, waste cleanup), the security agent (auto-generated remediation PRs, scoped drift correction), the SRE agent (per-incident-class auto-remediation with per-class accuracy gates), the resource-operations agent (tagging, lifecycle moves, quota application), and the deployment agent (release orchestration, rollback path). Codify the Administer-tier approval policy with explicit justification and separation-of-duties. Two-to-three months.

Phase 3 — Cross the agent loop across clouds. The SRE agent’s investigation context includes every other agent’s recent activity, across every connected cloud. The cost agent’s rightsizing history feeds the SRE agent’s anomaly baseline. The security agent’s drift correction history feeds the compliance audit-trail reconciliation. The team coordinates as a team, across clouds. The cross-cloud, cross-pillar context is the active operational layer.

Google I/O ’26 shipped the second hyperscaler agentic-DevOps stack of 2026. The structural lesson is that the agentic-DevOps category is now a contested GA category, and the shape that generalizes across the multi-cloud enterprise is the coordinated team of specialized agents on the active operational layer — multi-cloud inventory, BYOK pricing, capability-tier governance, unified audit trail. That is the shape IAN delivers.

Get a free infrastructure audit → | See pricing →