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:

The agents in this pipeline would be:

1. Classifier Agent — categorizes tickets, tags severity (P0–P3)
2. Clustering Agent — groups similar issues using embeddings, surfaces patterns
3. Root Cause Analyzer — maps issue clusters to specific services/code paths
4. Action Generator — drafts Jira tickets, PR descriptions, runbook links
5. 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:

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:

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