Google Agent Platform Deep Dive: Building Production-Grade AI Agents with ADK, MCP, and A2A

At the Google Cloud Next 2025 developer keynote, Google officially unveiled the complete technology stack for the Gemini Enterprise Agent Platform. Through a "marathon simulation planning" demo, they showcased how to build, deploy, debug, and govern production-grade AI Agents from scratch. This presentation was not just a product launch—it was a comprehensive preview of the Agent development paradigm for 2026.

Agent Platform Architecture Overview

A Complete Loop from Development to Operations

Google's Agent Platform provides an end-to-end Agent development and operations system. The core components include:

• Agent Development Kit (ADK): An Agent development framework that supports equipping Agents with Skills and Tools
• Scalable Serverless Agent Runtime: A scalable serverless runtime with Sessions management and Memory persistence
• Agent Gateway: An Agent gateway that enforces fine-grained security policies through unique Agent Identity
• Agent Registry: An Agent registry center—essentially DNS for the Agent world—supporting discovery and collaboration between Agents
• Agent Observability: An observability module providing runtime metrics monitoring and integrated evaluation

Notably, every Google Cloud service now supports MCP (Model Context Protocol) by default, enabling Agents to seamlessly communicate with any service in the Google Cloud ecosystem.

A Shared-Context Agent Ecosystem

Google is building applications on its own Agent Platform, enabling the entire Agent ecosystem to work collaboratively through shared context between Gemini Enterprise, Workspace, and third-party marketplace Agents. Enterprises no longer need to build separate data pipelines for each Agent—instead, platform-level context sharing enables true multi-Agent collaboration.

Building a Planner Agent from Scratch: ADK in Practice

Modular Design with Skills + Tools

The demo began with a marathon route planning Agent. Developer Mofi Rahman demonstrated how to rapidly prototype using Agent Designer, then progressively enhance the Agent's capabilities through code.

The Agent's core building blocks span three layers:

1. Instructions: Define the Agent's role and behavioral guidelines
2. Skills: Professional skill packs composed of YAML metadata and Markdown content, covering map skills, GIS skills, and race director skills
3. Tools: Connect to external services like Google Maps through Google Cloud MCP Server

The Skills design is quite elegant—descriptions in the metadata tell the Agent when to load a skill's full content, enabling progressive context understanding that effectively reduces token consumption and response time. The team also directly converted existing Google Doc process documentation into Agent-usable Skills via Gemini, significantly lowering the barrier to knowledge engineering.

The Power of Remote MCP Servers

Unlike local MCP Servers, Google Cloud provides fully managed remote MCP services. Developers don't need to be Google Maps experts—MCP for Google Maps provides out-of-the-box map tools for Agents, while Google handles security requirements and tool design. This "platform as capability" philosophy lets Agent developers focus on business logic rather than infrastructure.

Multi-Agent Collaboration: A2A Protocol and Agent Registry

From Monolith to Multi-Agent Systems

A single Planner Agent clearly isn't enough. The demo introduced three collaborating Agents:

• Planner Agent: Plans the marathon route
• Evaluator Sub-agent: Evaluates route quality using an independent model and limited context
• Simulator Agent: Executes simulations, generating behavior for thousands of runners

The Evaluator's design embodies an important principle: it uses an independent model and limited context to judge routes, focusing only on the route plan itself rather than the entire workflow. Evaluation criteria cover both non-deterministic metrics (like community impact) and deterministic metrics (like the route being precisely 26 miles and 385 yards).

How A2A Protocol Enables Plug-and-Play Agents

The A2A (Agent-to-Agent) protocol, created by Google and donated to the Linux Foundation, eliminates brittle API code between connected Agents through Agent Cards. Each Agent exposes an Agent Card as a capability manifest that other Agents can read to decide whether to collaborate.

The Agent Registry serves as the central directory for the Agent network—when an Agent is deployed to the Agent Runtime, it automatically registers. The connection between Planner and Simulator requires zero code and zero API contracts—truly achieving plug-and-play for Agents.

A2UI: Agents Dynamically Generating User Interfaces

A2UI (Agent to User Interface) is an open standard created by Google that lets Agents dynamically generate expressive UIs instead of outputting walls of text. Through one-shot examples, Gemini learns how to generate interface components, including rendering routes on maps and displaying evaluation results. This fundamentally changes the user experience paradigm for Agent applications.

Context Engineering: From Stateless to Stateful Agents

Three-Layer Architecture: Sessions, Memory, and RAG

Context engineering is one of the most critical aspects of Agent development. The demo showcased a three-layer context management architecture:

1. Sessions: Integrate Agent Platform Sessions with fewer than 20 lines of code, letting Agents maintain state across multi-turn interactions
2. Memory Bank: An enterprise-grade, fully managed memory service that automatically creates memories based on Agent usage patterns, supporting long-term memory storage
3. RAG with AlloyDB: Bring unstructured data (like Las Vegas local regulations) into Agent context through Document AI semantic chunking, AlloyDB auto-embeddings, and vector search

A noteworthy detail: AlloyDB's auto-embeddings feature automatically generates embedding vectors based on a specified model—developers don't need to handle this manually. The regulation discovered through semantic search—"you cannot ride a camel on public roads"—vividly demonstrates how RAG brings real-world domain knowledge to Agents.

Agent Observability and End-to-End Debugging

A Complete Debugging Workflow from Alert to Fix

When the Simulator Agent crashed during the demo, Megan O'Keefe demonstrated a complete debugging workflow:

1. Alert triggered: High-latency alert for the Simulator Agent received in Gmail
2. Trace analysis: View underlying tool calls and reasoning flow through Agent Runtime Trace View
3. CloudAssist investigation: One-click launch of Gemini CloudAssist investigation, automatically collecting logs and analyzing infrastructure
4. IDE integration: Continue the CloudAssist investigation in Anti-Gravity IDE via MCP
5. Root cause identification: Discovered that improper Event Compaction configuration caused exceeding Gemini API's 1 million token context limit
6. Code fix: The Agent not only found the root cause but also suggested a code fix adding a token threshold parameter

This case reveals an important insight: Agents are still software, and safe operations require transparent metrics, proper debugging tools, and attention to scale—not just infrastructure scale, but token scale.

Architecture Evolution and Vibe Clouding

Driving Infrastructure Changes with Natural Language

Bobby Allen demonstrated a compelling concept—"Vibe Clouding": driving infrastructure changes with natural language. With a single prompt, he had Gemini CloudAssist convert a Cloud Run service to a GKE deployment while deploying the Gemma 4 model in the same cluster.

When scaling to thousands of runners caused performance issues, CloudAssist proactively identified the storage bottleneck (GCS Fuse being unsuitable for rapid scaling scenarios) and recommended switching to Lustre storage. The upgraded simulator could display each runner's "thought bubble"—generated in real-time by the Gemma 4 model running in the cluster.

The core message of this demo: Agents shouldn't just answer questions—they should collaborate with you to take action within the guardrails you set. This is what Google calls the "autonomous cloud" vision.

Security Governance: Agent Identity and Agent Gateway

From Service Accounts to Agent Identity

The demo exposed a security issue: the Planner Agent shouldn't be able to modify budget data. The solution is the Agent Platform's governance system:

• Agent Identity: Provides each Agent instance with a unique, immutable credential—like a biometric scanner for every door, rather than a shared universal hotel key
• Agent Gateway: Acts as a proxy between Agents, enforcing IAM policies
• Egress Policies: Control Agent outbound access to external resources (tools, models, other Agents)

By adding a read-only policy for the Planner Agent's Finance MCP Server in the Agent Gateway, role-based access control was achieved in just a few steps.

Wiz Security Scanning Integration

The Wiz integration demonstrates the "Shift Down" philosophy—shifting security responsibility down to the platform layer. Wiz's Red Agent acts as a penetration tester probing for vulnerabilities from the outside, while the Green Agent suggests root cause remediation. In the demo, Wiz discovered a complete attack path from the internet to sensitive data, including an authentication bypass vulnerability, and provided three priority remediation recommendations: downgrade IAM permissions, patch the authentication vulnerability, and enforce AI guardrails.

Key Takeaways for Developers

This presentation conveyed several important signals:

Agent development is moving from experimentation to production. Google isn't offering toy-grade tools—it's a complete production-grade platform with runtime, observability, and security governance.

MCP is becoming the universal language of the Agent ecosystem. Google Cloud services supporting MCP by default means this protocol has moved from proof-of-concept to industrialization.

Context engineering is replacing prompt engineering as the core challenge. How you manage the coordination of Sessions, Memory, and external data sources determines an Agent's actual performance.

All code demonstrated is open-sourced, and developers can directly clone the repository to reproduce the entire marathon simulation application. Google also provides developer solution guides and Cloud Credits to lower the barrier to entry.

In the Agent era, the developer's role is evolving from "person who writes code" to "person who designs and governs Agent systems." Google's Agent Platform provides a clear technical roadmap for this transformation—and this presentation is the best guided tour of that roadmap.