This is a submission for the Google Cloud NEXT Writing Challenge
My Take
Everyone left Cloud NEXT '26 talking about TPU 8t, Gemini 3.1 Pro, or the Apple-Siri partnership. Those are headline-grabbers, sure. But the announcement that will quietly reshape how we architect software got maybe 10% of the attention it deserved:
Google shipped a complete, production-grade stack for multi-agent systems — from protocol (A2A v1.0) to framework (ADK v1.0) to runtime (Gemini Enterprise Agent Platform) to orchestration primitives (SequentialAgent, ParallelAgent, LoopAgent).
This isn't a research preview. 150 organizations are running A2A in production. ADK has stable releases in four languages. The "era of the pilot is over," as Thomas Kurian put it on stage — and for once, the infrastructure actually backs up the keynote rhetoric.
Here's why this matters more than any model upgrade, and what it concretely looks like to build with it.
The Problem Multi-Agent Systems Actually Solve
Let me frame this with a real scenario. Say you're building an incident triage pipeline — turning raw customer support tickets into actionable engineering tasks. Here's what the single-agent approach looks like vs. multi-agent:
| Dimension | Single-Agent (One Prompt) | Multi-Agent (ADK-based) |
|---|---|---|
| Architecture | One giant prompt with few-shot examples | 5 specialized agents in a SequentialAgent pipeline |
| Failure mode | Entire output is garbage if one step fails | Only the failing agent needs a fix; others keep working |
| Debugging | Re-read 2,000-token prompt, guess what went wrong | Agent interaction traces show exactly where the pipeline broke |
| Scaling | Scale the whole thing or nothing | Scale the clustering agent independently during incident spikes |
| Testing | End-to-end only; no unit tests for substeps | Each agent has its own eval suite with trajectory checks |
| Latency | Sequential by nature; everything waits on one call | ParallelAgent fetches data concurrently; LoopAgent iterates until quality passes |
The agents in this pipeline would be:
- Classifier Agent — categorizes tickets, tags severity (P0–P3)
- Clustering Agent — groups similar issues using embeddings, surfaces patterns
- Root Cause Analyzer — maps issue clusters to specific services/code paths
- Action Generator — drafts Jira tickets, PR descriptions, runbook links
- Reporter Agent — produces a clean incident summary for the on-call channel
Each agent is simpler to prompt, simpler to test, and simpler to replace. The system is what's intelligent — not any individual component.
What Google Actually Shipped: The Full Stack
Here's the part most coverage glossed over. Google didn't announce a feature. They shipped an integrated stack with four layers, each solving a distinct problem:
Layer 1: A2A Protocol (Agent-to-Agent Communication)
What it is: An open protocol (now at v1.0, governed by the Linux Foundation) that lets agents discover and communicate with each other across vendors and platforms.
Why it matters: Before A2A, if your Salesforce agent needed data from a ServiceNow agent, you wrote custom glue code. Now, agents publish Agent Cards (think: OpenAPI specs for agents) with cryptographic signatures, and any A2A-compliant agent can discover and call them.
Key v1.0 features:
- Signed Agent Cards for domain verification (prevents card forgery)
- Multi-tenancy (one endpoint, many agents — critical for SaaS)
- Multi-protocol bindings (JSON-RPC and gRPC)
- SDKs in Python, JavaScript, Java, Go, and .NET
Production adoption: 150 organizations running it in production, including deployments on Azure AI Foundry and Amazon Bedrock AgentCore. This isn't a Google-only play.
A2A handles agent↔agent communication. Anthropic's MCP handles agent↔tool communication. They're complementary, not competing — and Google adopted MCP across its own services in December 2025.
Layer 2: ADK (Agent Development Kit)
What it is: An open-source framework (v1.0 stable, Apache 2.0) for building multi-agent applications. Available in Python, TypeScript, Go, and Java.
The key abstraction — three agent types:
| Agent Type | Role | Example |
|---|---|---|
| LLM Agents | Reasoning, planning, decisions | "Analyze this ticket and classify severity" |
| Workflow Agents | Deterministic orchestration | SequentialAgent, ParallelAgent, LoopAgent |
| Custom Agents | Arbitrary logic via BaseAgent | Rate limiting, auth checks, custom routing |
What makes this different from LangChain/CrewAI: ADK's workflow agents are deterministic. They don't use an LLM to decide execution order — they follow predefined patterns (sequential, parallel, loop). The LLM agents handle reasoning; the workflow agents handle control flow. This separation is what makes the system predictable enough for production.
Layer 3: Gemini Enterprise Agent Platform (Runtime)
What it is: The renamed/consolidated Vertex AI — now a full-stack platform for deploying, governing, and scaling agents. Includes agent registries, skill registries, tool registries, and universal context management.
Deployment options:
- Agent Engine (fully managed, one-command deploy)
- Cloud Run (containerized, serverless)
- GKE (full Kubernetes control — 300 sandboxes/second, sub-second cold starts)
Layer 4: Observability & Governance
Agent interaction traces (not just stack traces), Model Armor for prompt injection protection, IAM-based access control, and audit logging. This is the "Kubernetes for intelligence" layer — the orchestration infrastructure that makes multi-agent systems operable.
The Architectural Shift Developers Should Care About
Here's the mental model change. We've gone through several "unit of software design" transitions:
| Era | Unit | Coordination | Failure Mode |
|---|---|---|---|
| Monolith | Function | Procedure calls | Whole app crashes |
| Microservices | Service | APIs + message queues | Circuit breakers, retries |
| Agentic | Agent | A2A + MCP | Agent interaction traces, fallback agents |
This isn't a forced analogy. Look at the primitives Google shipped:
- Agent Cards are the agentic equivalent of service discovery
- A2A is the equivalent of inter-service communication protocols
- ADK workflow agents are the equivalent of orchestration layers (think: Temporal, but for AI)
- Agent Engine is the equivalent of managed Kubernetes
The teams that internalized microservices early (Netflix, Uber, Airbnb) had a massive architectural advantage for a decade. The same dynamic is starting now with agent architectures.
What I Think Is Underrated (My Actual Opinion)
The LoopAgent pattern. Most multi-agent demos show linear pipelines: Agent A → Agent B → Agent C → done. That's just a fancy chain-of-prompts.
The LoopAgent is where things get genuinely interesting. In ADK, you can build a writer's room pattern: a Researcher agent generates content, a Critic agent evaluates it, and the LoopAgent keeps cycling until the Critic passes the output. This is iterative refinement without human intervention — and it's deterministic at the orchestration level while being creative at the agent level.
From the ADK Codelab: a movie pitch generator uses exactly this pattern — a researcher, screenwriter, and critic agent collaborate in a loop until quality criteria are met. This is the kind of architecture that produces reliable output from unreliable components, which is the whole game in production AI.
The second underrated thing: A2A's cross-vendor interoperability. The demo showed a Salesforce Agentforce agent handing off to a Google Vertex agent, which queries a ServiceNow agent for IT asset data — all through A2A, with none of the three systems needing to understand each other's internals. If this pattern holds, we're looking at an agent ecosystem that works like the web: open, interoperable, decentralized.
Where This Actually Leads
Most companies are still building:
- Chatbots (single-turn Q&A)
- Copilots (human-in-the-loop for every action)
- "AI wrappers" (thin UIs over API calls)
The multi-agent stack Google shipped enables something fundamentally different: autonomous workflows that compose, self-evaluate, and coordinate across organizational boundaries.
Real examples already in production:
- Citigroup's Citi Sky — a Gemini-powered wealth advisor
- Macy's Ask Macy's — a customer-facing retail agent
- Merck — a billion-dollar Google Cloud agentic AI deal
- Google's own SOC — triage agents processing 5M+ alerts, reducing 30-minute manual analysis to 60 seconds
This isn't "AI as a feature." It's AI as infrastructure. And the teams that start designing agent architectures now — with proper orchestration, observability, and composability — will have the same structural advantage that early microservices adopters had in 2014.
TL;DR
- Cloud NEXT '26's most important announcement wasn't a model — it was a complete multi-agent infrastructure stack: A2A protocol + ADK framework + Agent Platform runtime + governance layer
- A2A v1.0 is in production at 150+ organizations, governed by the Linux Foundation, with SDKs in 5 languages
- ADK separates reasoning (LLM agents) from orchestration (workflow agents) — this is the key insight that makes multi-agent systems production-viable
- The LoopAgent pattern (iterative agent refinement) is the most underrated primitive in the stack
- We're at the "microservices moment" for AI architecture — the teams that grok this early will build the next generation of software
Useful Links
| Resource | URL |
|---|---|
| A2A Protocol Docs | a2a-protocol.org |
| ADK Documentation | google.github.io/adk-docs |
| ADK Multi-Agent Codelab | codelabs.developers.google.com |
| A2A Developer Blog Post | developers.googleblog.com |
| ADK Multi-Agent Blog | cloud.google.com |
| Cloud NEXT '26 Announcements | blog.google |
Top comments (0)