A developer's breakdown of everything that matters from the Google Cloud Next '26 keynote and what to build with it next.
This is a submission for the Google Cloud NEXT Writing Challenge
For the last two years, every AI keynote has felt like a magic show "look at this thing that can write a poem."
Google Cloud Next '26 was different.
The magic show is over.
The actual machinery is here.
Thomas Kurian and Sundar Pichai opened the keynote with a single, quietly disruptive idea: we're done with chatbots that talk. The new era is about agents that do: systems with persistent reasoning and autonomous execution that can hold context for days, plan multi-step workflows, and verify their own work.
2024 and 2025 asked, "Can we build an agent?", 2026 asks, "How do we manage thousands of them?"
For developers especially those of us building at the intersection of frontend, data, and distributed systems this is the most consequential Next in years. Here's what actually shipped, what it means, and where to start.
The Agentic Enterprise Blueprint
Kurian framed the entire conference around one concept: The Agentic Enterprise. The pitch is that the org chart of the future doesn't just have humans it has digital teammates working alongside them, and every employee becomes a builder who orchestrates a swarm of agents instead of executing tasks manually.
The strategy rests on two ideas:
Persistent reasoning: Unlike a chatbot that forgets you the moment you close the tab, agents maintain state across days. They can pause, wait for an external trigger, resume, and finish the job like a human colleague would.
Owning the full stack: Custom silicon (TPUs), the data layer (BigQuery), and the UX (Workspace) all built to work together. Kurian's not-so-subtle jab at competitors: they "hand you the pieces, not the platform."
Whether you buy that framing or not, the takeaway is clear — Google is betting that vertically integrated infrastructure wins the agent era. And the rest of the keynote was them showing receipts.
Gemini Enterprise Agent Platform (The Vertex AI Rebrand)
The biggest rebrand of the event: Vertex AI is now the Gemini Enterprise Agent Platform. It's no longer a model garden it's a unified environment for the entire agent lifecycle, from prototype to production to post-deployment monitoring.
The core features that make up the platform:
Agent Studio: A low-code, visual builder inside Workspace. Defines agent goals in natural language, wire up tools, and ship.
Agent Development Kit (ADK) v1.0: The pro-code framework for the rest of us. Supports Python, JavaScript, Java, and Go, and lets you build graph-based agent networks (think LangGraph, but native).
Agent Identity: Every agent gets a unique cryptographic ID. Every action it takes is auditable. This is huge for compliance finally, a real answer to "Which agent did that, and why?"
Agent Gateway: Air traffic control for your agent fleet. Enforces policy, manages traffic, and uses Model Armor to block prompt injection attacks at the edge.
A2A (Agent-to-Agent) Protocol: A standardized handshake that lets a Google-based agent securely delegate tasks to a Salesforce or SAP agent. Cross-vendor interoperability, finally.
Agent Runtime: A re-engineered execution environment built for long-running agents. Your agent can fire off a task, wait three days for an external API to respond, and pick up exactly where it left off.
Agent Simulation & Evaluation: Stress-test your agent against thousands of simulated user interactions before it ever sees production. Catches logic drift before your users do.
What's Actually Shipping
If Day 1 sold the strategy, Day 2 showed the developer loop underneath it. The framing: build an agent system that plans a marathon for 10,000 runners through the Las Vegas Strip, using three agents — a planner (generates routes), an evaluator (scores them against constraints), and a simulator (runs the route end-to-end). The entire codebase and every demo were open-sourced as a GitHub repo plus Codelabs. The platform was anchored around four pillars and each pillar got its own demo segment.
🛠️ Build
- ADK (Agent Development Kit): the code-first framework, supporting Python, JavaScript, Java, and Go, with a new graph-based runtime for defining how agents collaborate.
- Agent Studio: the low-code counterpart. Define agent goals in natural language, wire up tools, publish.
- Managed MCP: Google now hosts the Model Context Protocol layer, eliminating a week of self-hosting plumbing.
- Agent Registry: described as "the DNS of your internet of agents." Auto-indexes every agent deployed to Agent Runtime, making them discoverable and governable.
- Agent Marketplace: third-party agents from Atlassian, Box, Lovable, Oracle, ServiceNow, Workday, and more, deployable directly from Gemini Enterprise.
- Model Garden: explicitly supports Claude, Gemini 3.1 Pro, Gemini 3.1 Flash, and others. Pick your model, swap when needed.
📈 Scale
- Serverless Agent Runtime: handles long-running state across days. Agents pause, wait for an external trigger, and resume without losing context.
- A2A (Agent-to-Agent) Protocol: the cross-vendor handshake. Created by Google, donated to the Linux Foundation. A Google agent can hand work to a Salesforce or SAP agent without brittle API code.
- A2UI (Agent-to-User Interface): an open standard letting agents generate dynamic UI components instead of returning plain text. The marathon simulator's UI (Angular + 3D rendering of the Las Vegas Strip) was assembled live by the agent itself, not hardcoded.
The evaluation layer is now first-class. A separate model as a judge scores outputs across deterministic criteria (a marathon is exactly 26 miles 385 yards / 42.195 km) and non-deterministic ones (community impact, route quality). Agents auto-generate their evaluation UIs from the schema of their own outputs the path from "fragile, unpredictable agentic loops" to "a rigorously evaluated network of experts."
🔒 Govern
The framing here was sharp: stop telling developers to "shift left" (own everything earlier) and start letting them "shift down" push the responsibility into the platform layer.
- Agent Identity: every agent gets a unique, immutable cryptographic credential. Every action is auditable back to a specific agent instance.
- Agent Gateway: air traffic control for the agent fleet. Understands MCP and A2A protocols. Uses IAM policies to scope which sources can invoke agent actions.
- Agent Policies: configurable guardrails. An agent permitted to read from BigQuery but blocked from triggering spend over a threshold.
- Model Armor: inline protection against prompt injection, tool poisoning, and sensitive data leakage at the gateway layer.
⚙️ Optimize
The end-to-end debugging story for when an agent breaks in production:
- Agent Runtime trace view: surfaces exactly where the reasoning chain or tool call failed.
- Gemini Cloud Assist Investigation: takes a natural-language query and explores logs and events to surface the failing component down to a specific line.
- Antigravity IDE: powered by Gemini 3, connected via MCP. Proposes parameter-level remediations. In the demo: a missing token_threshold on the event-compaction config that was silently truncating the agent's working memory.
- Wiz Green Agent inside Claude Code with Opus: Wiz now scans both agent code and infrastructure, and the same remediation surface runs inside Anthropic's IDE on Anthropic's model. An explicit multi-vendor signal: security tooling travels with the developer, regardless of stack.
What it means for you
Day 1 sold the agentic enterprise. Day 2 laid out the loop you'll actually live in: build → scale → govern → optimize. Three things to actually act on:
- The evaluation layer is the part most teams will sleep on and regret. Judge models, deterministic + non-deterministic checks, auto-generated eval UIs: this is where agentic systems silently fail today, and it's now baked in.
- A2A and A2UI are open standards, not Google-only. The Linux Foundation handoff matters. Don't dismiss them as vendor lock-in.
- Antigravity is the bet to watch. It's Google's claim on what "agentic developer experience" means in 2026 and the multi-vendor Wiz/Claude Code integration shows the surface area is intentionally portable.
The AI Hypercomputer: 8th-Gen TPUs
To run millions of persistent agents in production, you need silicon designed for the workload. Google's answer is the 8th-generation TPU and crucially, it's a dual-chip strategy that splits training and inference into purpose-built hardware. This is Google explicitly attacking the "memory wall" that's been bottlenecking large models.
What it means for you: Cloud developers now have a dedicated inference engine in the TPU 8i. The economics of running a complex, multi-turn agent for every single user in your app just got real. The "one agent per user" pattern was a fantasy in 2024 at these unit costs, it becomes a default architecture.
Agentic Data Cloud: From Passive Storage to System of Action
"Reasoning without context is just a guess" that's how Karthik Narain, Google Cloud's Chief Product and Business Officer, framed the thesis behind the Agentic Data Cloud, which reimagines data as something agents act on, not just query.
Three pieces matter most:
Knowledge Catalog: Replaces traditional metadata catalogs. It auto-maps the business meaning of data across your entire estate (Google Docs, Slack, SQL warehouses, the lot). Your agents now understand that "ARR" in finance means the same thing as "Annual Recurring Revenue" in your CRM.
Memory Bank: Long-term memory for agents. Where chat sessions used to forget you in five minutes, Memory Bank persists user preferences and project history across months of interaction.
Managed MCP: You no longer host your own Model Context Protocol servers. Google now manages the connective tissue between Gemini and your databases, which kills a whole class of plumbing work.
Agentic Defense: The Wiz Integration Goes Live
With the $32 billion Wiz acquisition fully closed, Google rolled out a "Cyberforce" of defensive agents. The pitch: stop reacting to alerts, start hunting threats autonomously.
Threat Hunting Agent: Proactively scans for novel attack patterns that signature-based firewalls miss.
Detection Engineering Agent: Writes and deploys new security rules in real time as threats evolve. The rule that catches tomorrow's attack didn't exist yesterday.
Wiz "Red Agent": An autonomous penetration tester that constantly probes your cloud infrastructure for unlocked doors before real attackers find them.
The Agentic Taskforce: Companies Already Shipping
The keynote closed with proof points companies actually getting ROI from agents in production right now. The pattern across all of them: agents handling the long-tail repetitive work, humans focusing on judgment calls. A few standouts worth zooming in on:
KPMG's Tax Swarms are the clearest A2A protocol use case in the wild; their tax agent talks directly to a client's audit agent.
Virgin Voyages going from 6-hour rebookings to 11 minutes is the clearest "Agent Runtime + long-running state" example.
Goldman Sachs querying 10,000+ page filings in minutes is what the Knowledge Catalog actually unlocks at enterprise scale.
Walmart and Bosch prove agents work at the edge — store floors and factory floors, not just data centers.
So What Should You Actually Do With This?
If you take one thing from Next '26, take this: the agent era isn't a future bet, it's a current one. The infrastructure is shipping, the protocols are standardizing, and Fortune 500s are already in production.
Concretely, here's where to start depending on your stack:
Frontend devs: Play with Agent Studio. The low-code builder is the fastest way to feel what an agentic UX is even supposed to look like.
Backend / data folks: The Knowledge Catalog and Memory Bank are the most underrated announcements. Try wiring an agent to your own data with Managed MCP and skip a month of plumbing.
Infra / platform engineers: Watch the TPU 8i pricing closely. The economics of "an agent per user" change your architecture decisions for the next two years.
Security teams: Don't wait. Threat Hunting and Red Agent are the kind of tools your blue team will quietly start depending on by Q3.
The chatbot era taught us how to prompt. The agent era is going to teach us how to delegate. The developers who figure that out first are going to look like wizards by the end of 2026.
If you watched the keynote too, what stood out for you? Drop a comment especially if you've started prototyping with the ADK. I'm curious what's actually working vs. what's still demo-ware.