Google's Agentic AI Stack: Gemini, ADK, A2A With Google Cloud

Ai4

AI-assisted summary of Google's Agentic AI Stack: Gemini, ADK, A2A With Google Cloud — original source. Check the original for full context.

Source published: 2025-08-28

Detailed notes

## Background Published on YouTube by the Ai4 channel on August 28, 2025, this presentation features Dave Elliott, Head of Developer Advocacy for AI at Google Cloud. According to the description, the session explores the core components of an agentic stack—orchestration, models, and tools—and unveils Google Cloud's architecture, including the Agent Development Kit (ADK), Model Context Protocol (MCP), and Agent2Agent (A2A) protocol.

## TL;DR Dave Elliott details the architectural evolution of generative AI from basic prompts to collaborative multi-agent swarms, outlining the key roadblocks in moving agents into enterprise production. He unveils Google Cloud's four-pillar agentic stack, comprising the open-source Agent Development Kit (ADK), Model Context Protocol (MCP) integration, the managed Vertex AI Agent Engine runtime, and the Linux Foundation-governed Agent2Agent (A2A) protocol. The session highlights ADK's code-first, model-agnostic design, flexible containerized deployment options across Cloud Run and Kubernetes, and native multimodal streaming capabilities. Elliott concludes with concrete getting-started steps via the `google-adk` and `a2a-sdk` Python packages alongside runnable sample repositories.

## Atmosphere & style The presentation carries a brisk, engaging, and pragmatic conference energy, opening with self-deprecating humor about being the only speaker standing between the audience and the evening cocktail hour. Elliott maintains a swift, articulate pace, grounding ambitious AI concepts in practical software engineering terminology, clean architectural diagrams, and direct developer workflows rather than vague industry hype. The mood is approachable and encouraging, wrapping up on an inviting, community-oriented note that urges attendees to experiment with the open-source toolkits and visit the conference booth.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=72zGRb3CpFw&t=4s) AI agents represent the primary vehicle through which enterprises and developers will unlock the tangible value and promise of large language models. - [00:04](https://www.youtube.com/watch?v=72zGRb3CpFw&t=4s) Early enterprise agent adoption stalled due to ecosystem fragmentation, rapidly shifting models, lack of MLOps lifecycle management, and missing governance. - [02:52](https://www.youtube.com/watch?v=72zGRb3CpFw&t=172s) Generative AI has evolved across five stages: raw prompt-response, RAG grounding, function calling, reasoning loops with tools, and decentralized multi-agent collaboration. - [02:52](https://www.youtube.com/watch?v=72zGRb3CpFw&t=172s) Every agentic architecture fundamentally relies on a core triad: orchestration (workflow control), models (reasoning), and tools/APIs (data and actions). - [05:20](https://www.youtube.com/watch?v=72zGRb3CpFw&t=320s) Google Cloud's agentic stack consists of four components (ADK, MCP, Vertex AI Agent Engine, and A2A), three of which are open source or open protocols to prevent vendor lock-in. - [07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) The Agent Development Kit (ADK) is an open-source, code-first client framework built specifically by software developers for software developers without restrictive black-box abstractions. - [07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) ADK is designed to be model-agnostic and deployment-agnostic, supporting non-Google models and running across Vertex AI, Cloud Run, GKE, or self-hosted on-prem environments. - [07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) Key ADK capabilities include native multimodal bidirectional streaming, integrated evaluation suites, and support for both deterministic workflows and dynamic reasoning loops. - [09:47](https://www.youtube.com/watch?v=72zGRb3CpFw&t=587s) The Model Context Protocol (MCP) functions complementarily with ADK, enabling agents to seamlessly consume external MCP servers as tools or expose internal ADK tools via MCP. - [11:34](https://www.youtube.com/watch?v=72zGRb3CpFw&t=694s) Vertex AI Agent Engine acts as the managed enterprise runtime, handling operational burdens like short- and long-term memory management, tracing, security, and sandboxed execution. - [12:19](https://www.youtube.com/watch?v=72zGRb3CpFw&t=739s) The Agent2Agent (A2A) protocol, contributed to the Linux Foundation, standardizes multi-agent collaboration through Agent Cards, task dispatching, and asynchronous push notifications. - [14:06](https://www.youtube.com/watch?v=72zGRb3CpFw&t=846s) Developers can begin building and experimenting with the ecosystem immediately using the `google-adk` and `a2a-sdk` Python packages alongside official reference implementations.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=72zGRb3CpFw&t=4s) Unlocking LLM Value and the Challenges of the Agentic Landscape

Opening with a lighthearted joke about being the only barrier between the audience and the conference happy hour ("I'm the last one standing between you and the cocktail hour. Uh, so I plan to take three hours. No. Okay."), Dave Elliott introduces himself as a 13-year Google veteran leading the developer evangelism and engineering team. With roughly eighteen minutes on the clock, his goal is not to deliver an exhaustive deep dive, but rather to outline Google's Agentic AI stack, provide foundational resources, and invite developers to visit Booth 500 downstairs for hands-on Q&A and swag.

Elliott argues that agents represent the primary vehicle through which both individuals and enterprises will ultimately realize the true value and promise of large language models. While the industry is saturated with hype surrounding agents, extracting tangible enterprise value has historically proven difficult. In previous years, developer attempts to operationalize agents hit several critical roadblocks:

```mermaid flowchart TD accTitle: Core Challenges in Agent Development subgraph Fragmentation["Ecosystem Fragmentation"] A["Rapidly changing models (Daily / weekly releases)"] B["Fragmented open-source tools & vendors"] C["High integration friction"] end subgraph EnterpriseGaps["Production Bottlenecks"] D["Lack of MLOps & lifecycle management"] E["Missing enterprise governance & trust"] end Fragmentation --> EnterpriseGaps ```

To transition agents from brittle proof-of-concepts into reliable enterprise software, the ecosystem requires three foundational pillars: - **Developer Toolkits:** Frameworks and libraries that accelerate development speed and eliminate boilerplate. - **Open Protocols:** Standardized communication mechanisms allowing disparate models, tools, and agents to converse seamlessly. - **Enterprise Agentic Platforms:** Scalable infrastructure providing operational tooling, monitoring, governance, and model trust.

---

[02:52](https://www.youtube.com/watch?v=72zGRb3CpFw&t=172s) The Evolution of AI: From Raw Prompts to Multi-Agent Swarms

Tracing the rapid architectural evolution of generative AI over recent years, Elliott breaks down the journey across five distinct paradigms. AI development began with simple prompt-and-response interactions, which suffered heavily from hallucinations, stale knowledge cutoffs, and poor accuracy. The first major leap arrived roughly eighteen months prior with Retrieval-Augmented Generation (RAG), grounding model completions in external vector databases and enterprise documents. The industry then advanced to function calling, enabling models to break out of closed loops to query live search engines, invoke tools, and hit external web APIs.

```mermaid flowchart LR accTitle: Five Phases of Generative AI Evolution P1["1. Raw Prompts (Hallucinations & static data)"] --> P2["2. RAG (Grounded in vector DBs)"] P2 --> P3["3. Function Calling (External APIs & Google Search)"] P3 --> P4["4. Reasoning Loops & Many Tools (Model-driven orchestration)"] P4 --> P5["5. Multi-Agent Systems (Collaborative swarms via A2A)"] ```

Looking at 2025 and 2026, state-of-the-art agent architectures are defined by reasoning loops coordinating across wide tool suites, transitioning into true multi-agent collaboration. In this target state, specialized agents do not merely communicate sequentially—they actively collaborate to tackle complex objectives. Elliott highlights his long-term vision of having "thousands or even millions of agents sort of swarming to try to solve problems," an ambition that depends entirely on open industry protocols.

At its core, any agentic system distills into three foundational architectural building blocks:

```mermaid flowchart TD accTitle: Core Triad of Agentic Architecture subgraph AgentCore["Agent Architecture Triad"] O["Orchestration (Workflows & control flow)"] M["Models (Decision-making & reasoning)"] T["Tools & APIs (Grounding, actions & data)"] end M <--> O O <--> T ```

---

[05:20](https://www.youtube.com/watch?v=72zGRb3CpFw&t=320s) Google Cloud's Four Pillars for Agentic AI

Unveiling Google's agentic stack, Elliott details four core components designed to address the developer toolkit, data interoperability, managed operations, and multi-agent protocols. Crucially, three of the four components in the stack are open source or open protocols, reflecting Google's commitment to avoiding vendor lock-in.

```mermaid flowchart TD accTitle: Google Cloud Agentic AI Stack subgraph OpenLayer["Open Source & Open Protocols"] ADK["Agent Development Kit (ADK) • Code-first client framework • Open source (announced April)"] MCP["Model Context Protocol (MCP) • Standardized data & context protocol"] A2A["Agent2Agent (A2A) • Multi-agent collaboration protocol"] end subgraph ManagedLayer["Managed Enterprise Infrastructure"] AE["Vertex AI Agent Engine • Managed runtime & scaling • Security, ops & governance (Paid)"] end ADK <--> MCP ADK <--> AE ADK <--> A2A ```

- **Agent Development Kit (ADK):** The open-source centerpiece of Google's agent tooling, announced in April. Engineered specifically "by software developers for software developers" rather than being shaped purely by machine learning research or academic theory. - **Model Context Protocol (MCP):** The emerging industry standard protocol for feeding real-time context and structured external data directly into agents. - **Vertex AI Agent Engine:** The fully managed runtime and enterprise orchestration layer. As Google Cloud's paid enterprise tier, it supplies the MLOps, infrastructure scaling, automated management, and security governance required for mission-critical enterprise production. - **Agent2Agent (A2A) Protocol:** An open standard facilitating high-fidelity communication, coordination, and collaborative multi-agent problem-solving.

---

[07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) The Agent Development Kit (ADK): Core Tenets and Capabilities

Positioned as the "crown jewels" and the star of the stack, the Agent Development Kit (ADK) is an open-source, client-side framework focused on code-first development without restrictive "black box" abstractions. Elliott emphasizes three architectural principles that govern ADK:

1. **Model Agnostic:** While optimized to leverage Google's Gemini models ("Gemini rocks. Gemini always does really well"), ADK explicitly supports third-party and open-weight models across the board. 2. **Deployment Agnostic:** Agents built with ADK can run on Vertex AI Agent Engine, serverless container environments like Cloud Run, container clusters on Google Kubernetes Engine (GKE), or completely on-premises on self-hosted customer infrastructure. 3. **Built for Interoperability:** Designed from the start around open protocols so individual agents can easily integrate into broader multi-agent ecosystems.

Beyond these high-level principles, Elliott highlights the core technical capabilities that make ADK distinct: - **Flexible Workflow Orchestration:** Developers can configure dynamic, reasoning-driven orchestration where the LLM decides runtime tool execution paths, or construct strictly deterministic, hardcoded workflows required for enterprise compliance and repeatability. - **Developer-Centric IDE Experience:** Direct, transparent code interfaces with no opaque abstractions, letting engineers work with standard code tooling. - **Native Multimodal Bidirectional Streaming:** Full support for real-time, low-latency streaming of video, image, and text inputs and outputs across Gemini, Vertex AI, and ADK. - **Built-in Evaluations (Evals):** Integrated testing and benchmarking suites to monitor, evaluate, and assure model accuracy and agent execution quality before deployment. - **Deployment-Ready Architecture:** Clean transitions from local developer prototyping directly into production environments.

[09:47](https://www.youtube.com/watch?v=72zGRb3CpFw&t=587s) Deployment Pathways and Integrating the Model Context Protocol (MCP)

A major sentiment across Reddit and online developer communities regarding Google's Agent Development Kit (ADK) is appreciation that production deployment was never treated as an afterthought. Developing an agent is only the first hurdle; developers must subsequently package and host it on an accessible endpoint. With ADK, the agent can be packaged cleanly into a container and deployed directly to Vertex AI Agent Engine or Cloud Run, or developers can self-manage the deployment on standard Docker hosts, Google Kubernetes Engine (GKE), or local on-premises infrastructure. This flexible deployment model represents one of ADK’s most defining strengths.

Moving across the stack, the Model Context Protocol (MCP)—an open protocol originally spearheaded by Anthropic—has rapidly become an industry standard for connecting AI applications to tools and external data sources. The community rush to build and operate MCP servers has made standardized tool interaction widespread. ADK and MCP are fundamentally complementary rather than competing technologies: developers can either consume existing MCP servers directly within ADK agents or expose native ADK tools outward through an MCP server. Combining ADK orchestration with MCP connectivity gives developers a direct, flexible route toward production-ready tooling.

- **Deployment Targets:** Containerized deployment across Vertex AI Agent Engine, fully managed Cloud Run, self-managed Docker, GKE clusters, or on-prem servers. - **MCP Integration Modes:** Bi-directional interoperability allows agents to invoke external MCP servers as tools or serve internal ADK capabilities over MCP.

[11:34](https://www.youtube.com/watch?v=72zGRb3CpFw&t=694s) Vertex AI Agent Engine: Enterprise Infrastructure and Memory Management

Within Google's agentic stack, Vertex AI Agent Engine stands out as the core commercial managed runtime. Designed to liberate engineering teams from the toil of managing raw infrastructure, Agent Engine allows developers to focus purely on business and application logic. It handles the operational plumbing that engineering teams typically dread maintaining or rely on dedicated specialists to configure, delivering turnkey scalability and resilience.

A central highlight of Agent Engine is state management. As conversational and multi-turn workflows grow more complex, handling short-term working memory alongside persistent long-term memory across sessions has become a pivotal challenge in modern AI architectures. Beyond memory orchestration, the platform natively provides end-to-end tracing, centralized logging, runtime monitoring, identity and access management, and secure sandbox code execution environments.

- **State Management:** Turnkey handling of short-term conversational context and long-term persistent memory storage. - **Operational Infrastructure:** Fully managed execution handling identity management, observability (monitoring, logging, tracing), and sandboxed dynamic code execution.

[12:19](https://www.youtube.com/watch?v=72zGRb3CpFw&t=739s) The Agent2Agent (A2A) Protocol: Enabling Autonomous Collaboration

The final pillar of the architecture is the Agent2Agent (A2A) protocol, a lightweight specification enabling disparate, modular agents to interact autonomously. Designed so that "black boxes can talk to each other," A2A establishes a vendor-neutral standard for agents to discover each other's capabilities and orchestrate complex, multi-party tasks. Although originally developed by Google, the protocol was contributed directly to the Linux Foundation, where a broad board of major cloud and AI vendors actively oversees its open governance and ecosystem adoption.

A2A structures agent collaboration through standardized primitives. Agents publish an "Agent Card" that advertises what the agent does, its operational bounds, and its exposed capabilities. When an orchestrator—such as a top-level strategy agent—determines it needs specialized support, it invokes peer agents by dispatching discrete tasks, receiving updates through real-time streaming and asynchronous push notifications. This pattern decouples specialized risk, audit, and operational agents into modular microservices that can be composed on demand.

```mermaid flowchart LR accTitle: Agent2Agent Protocol Interaction Flow subgraph ClientAgent["Orchestrating Agent"] SA["Strategy Agent"] end

subgraph A2ALayer["A2A Protocol Interface"] direction TB AC["Agent Card (Capability Advertisement)"] TD["Task Dispatch & Execution"] PS["Push Notifications & Streaming"] end

subgraph ExternalAgents["Collaborating Agents"] direction TB RA["Risk Assessment Agent"] BB["Black-Box Specialist Agent"] end

SA --> AC AC --> TD TD --> RA TD --> BB RA --> PS BB --> PS PS --> SA ```

- **Open Governance:** Seeded by Google and governed by the Linux Foundation with cross-industry vendor backing. - **Core Primitives:** Agent Cards for capability discovery, structured task assignments, and dual push-notification/streaming channels for asynchronous feedback.

[14:06](https://www.youtube.com/watch?v=72zGRb3CpFw&t=846s) Developer Call to Action: Tooling, Documentation, and Next Steps

Reflecting on the evolution of agentic architectures over the past year, modern multi-agent systems have advanced rapidly beyond simple prompts into sophisticated reasoning loops, complex tool calling, and federated agent ecosystems. Google's agentic stack encapsulates this complete hierarchy: ADK serving as the foundational development layer, MCP providing universal data connectivity, Vertex AI Agent Engine delivering managed enterprise runtimes, and A2A unlocking collaborative multi-agent communication.

To get started hands-on, developers can install the core toolkits via Python packaging: running `pip install google-adk` provides immediate access to ADK, supported by an open GitHub repository, 50 to 60 pages of launch documentation drafted by the advocacy team, and eight to ten fully runnable sample agent implementations. Developers looking to explore multi-agent communication can similarly install `pip install a2a-sdk`. After concluding the presentation, attendees were invited to connect on LinkedIn for ongoing updates on Google's agent ecosystem, visit the conference exhibition booth to view live demonstrations and pick up cable organizer bags, and join the evening cocktail hour.

- **ADK Package & Docs:** Available via `pip install google-adk`, backed by comprehensive documentation and 8–10 official sample agents. - **A2A SDK:** Installed via `pip install a2a-sdk` for immediate prototyping of multi-agent federation.

## Notable quotes > [00:04](https://www.youtube.com/watch?v=72zGRb3CpFw&t=4s) I'm the last one standing between you and the cocktail hour. Uh, so I plan to take three hours. No. Okay. — Dave Elliott

> [02:52](https://www.youtube.com/watch?v=72zGRb3CpFw&t=172s) thousands or even millions of agents sort of swarming to try to solve problems — Dave Elliott

> [05:20](https://www.youtube.com/watch?v=72zGRb3CpFw&t=320s) by software developers for software developers — Dave Elliott

> [07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) Gemini rocks. Gemini always does really well — Dave Elliott

> [12:19](https://www.youtube.com/watch?v=72zGRb3CpFw&t=739s) black boxes can talk to each other — Dave Elliott

> [14:06](https://www.youtube.com/watch?v=72zGRb3CpFw&t=846s) pip install google-adk — Dave Elliott

> [14:06](https://www.youtube.com/watch?v=72zGRb3CpFw&t=846s) pip install a2a-sdk — Dave Elliott

## Mentioned Dave Elliott, Google, Google Cloud, Ai4, Gemini, Agent Development Kit (ADK), Model Context Protocol (MCP), Agent2Agent (A2A), Vertex AI Agent Engine, Cloud Run, Google Kubernetes Engine (GKE), Docker, Anthropic, Linux Foundation, Python, GitHub, LinkedIn, Reddit

## Video description Dave Elliott, Head of Developer Advocacy for AI, Google Cloud Abstracts

How can you effectively build and deploy powerful AI agents that move beyond simple prompts? This session dives into the core components of an agentic stack, exploring how orchestration, models, and tools combine to create intelligent, autonomous systems. We'll unveil Google Cloud's agentic stack, highlighting the Agent Development Kit (ADK), Model Context Protocol (MCP), and Agent2Agent (A2A) protocol, and demonstrate how they enable robust agent development and interoperability. Join us to learn how to leverage these innovations to unlock the full potential of AI agents in your applications. How can you effectively build and deploy powerful AI agents that move beyond simple prompts? This session dives into the core components of an agentic stack, exploring how orchestration, models, and tools combine to create intelligent, autonomous systems. We'll unveil Google Cloud's agentic stack, highlighting the Agent Development Kit (ADK), Model Context Protocol (MCP), and Agent2Agent (A2A) protocol, and demonstrate how they enable robust agent development and interoperability. Join us to learn how to leverage these innovations to unlock the full potential of AI agents in your applications.

[Source](https://www.youtube.com/watch?v=72zGRb3CpFw)

中文简报

Google的Agentic AI技术栈：基于Google Cloud的Gemini、ADK与A2A Dave Elliott详细阐述了生成式AI从基础提示词到协作式多智能体集群的架构演进，并指出了将智能体推向企业级生产环境的核心阻碍。他公布了Google Cloud的四支柱智能体技术栈，包括开源的Agent Development Kit（ADK）、Model Context Protocol（MCP）集成、托管式Vertex AI Agent Engine运行时，以及由Linux基金会管理的Agent2Agent（A2A）协议。会议重点介绍了ADK的代码优先与模型无关设计、跨Cloud Run和Kubernetes的灵活容器化部署选项，以及原生多模态流式传输能力。Elliott最后通过`google-adk`和`a2a-sdk` Python软件包及可运行的示例代码库，给出了具体的入门实践步骤。 AI Agent 是企业和开发者释放大语言模型真实价值的核心载体，但早期落地常受阻于生态碎片化、模型快速迭代以及缺乏 MLOps 生命周期管理与治理。 (0:04) 生成式 AI 已从基础 Prompt 问答经历 RAG 与函数调用，逐步演进至具备复杂工具推理循环乃至去中心化的多 Agent 协同体系。 (2:52) Google Cloud 推出包含 ADK、MCP、Vertex AI Agent Engine 和 A2A 协议的 Agent 技术栈，其中三项为开源或开放标准以避免供应商锁定。 (5:20) 开源客户端框架 ADK 专为软件开发者打造，不依赖黑盒抽象，具备模型无关性与跨平台部署能力，原生支持多模态双向流式传输及内置评估套件。 (7:14) 由 Linux 基金会治理的 A2A 协议通过 Agent Card 和任务分发机制，让异构 Agent 实现自主发现与跨系统协作，现已支持通过 Python SDK 快速接入。 (12:19)

Reading summary

Dave Elliott of Google Cloud argues that autonomous agents represent the primary mechanism for enterprises to extract value from large language models, requiring a shift away from brittle proof-of-concepts toward standardized toolkits, open protocols, and managed infrastructure. The Evolution and Roadblocks of Enterprise Agentic AI (2:52) According to Elliott, generative AI architectures have evolved through five distinct phases: raw prompt-and-response interactions, retrieval-augmented generation (RAG) using vector databases, function calling across external APIs, reasoning loops coordinating multiple tools, and emerging multi-agent collaborative networks. Elliott projects that by 2025 and 2026, systems will increasingly rely on swarms of specialized, collaborating agents. Despite widespread interest, early enterprise adoption has faced operational roadblocks, including weekly model churn, fragmented open-source tooling, and high integration friction. Production deployment has been further hindered by an absence of standardized MLOps lifecycle management and enterprise-grade governance. Overcoming these barriers requires three structural elements: developer-focused toolkits, open communication protocols, and managed runtime platforms that provide security, trust, and operational scaling. Code-First Development and Context Interoperability with ADK and MCP (7:14) To streamline application construction, Google introduced the open-source Agent Development Kit (ADK), announced in April as a code-first, client-side framework intended to avoid opaque abstractions. Built to be model-agnostic and deployment-agnostic, ADK supports Google's Gemini models alongside third-party and open-weight models. It allows developers to configure either LLM-driven reasoning loops or deterministic, hardcoded control flows, while natively supporting bidirectional multimodal streaming and integrated evaluation suites. ADK addresses deployment friction by packaging agents into containers that run across Vertex AI Agent Engine, Google Cloud Run, Google Kubernetes Engine (GKE), Docker, or on-premises servers. For data integration, ADK interoperates bi-directionally with the Model Context Protocol (MCP), an open standard originally created by Anthropic. Under this architecture, ADK agents can either query external MCP servers for context or expose their internal tools outwardly as MCP servers. Managed Infrastructure and State Handling in Vertex AI Agent Engine (11:34) While development libraries handle application logic, Google positions Vertex AI Agent Engine as its paid commercial runtime for enterprise operations. The service is structured to decouple application developers from underlying infrastructure tasks such as resource scaling, identity and access management, and observability. A core technical feature of Agent Engine is state management. The platform addresses multi-turn conversational complexity by natively coordinating both working short-term context and persistent long-term memory across sessions. In addition, it integrates centralized logging, end-to-end tracing, runtime monitoring, and sandboxed dynamic code execution environments to enforce enterprise security policies. Federated Multi-Agent Collaboration via the A2A Protocol (12:19) To enable decentralized coordination between modular agents, Google developed the Agent2Agent (A2A) protocol and transferred it to the Linux Foundation for multi-vendor, open governance. The protocol functions as a vendor-neutral communication layer that allows disparate, black-box agent systems to discover and orchestrate tasks without proprietary lock-in. A2A relies on standardized primitives, primarily an 'Agent Card' where an agent advertises its capabilities, operational constraints, and endpoints. Orchestrating agents, such as higher-level strategic planners, read these cards to dispatch tasks to specialized peers—such as risk assessment or audit microservices—receiving progress updates through asynchronous push notifications and real-time streaming channels. Google's agent strategy relies on a hybrid framework combining open-source standards—ADK, MCP, and A2A—with paid managed enterprise services through Vertex AI Agent Engine. While this modular architecture provides flexible deployment targets, its enterprise viability ultimately depends on broad multi-vendor adherence to the Linux Foundation's A2A protocol and effective operational management of dynamic multi-agent networks.

精炼阅读摘要

Google 开发者推广与工程团队负责人 Dave Elliott 指出，智能体（Agent）是大语言模型转化为企业实际生产力价值的核心载体；为解决生态碎片化与生产化治理瓶颈，Google 提出了由开源工具、开放协议与托管平台构成的四层 Agentic AI 技术栈。技术范式演进与企业智能体落地瓶颈 (0:04) 生成式 AI 经历了五个发展阶段：早期的纯提示词交互受制于事实幻觉与知识更新滞后；约十八个月前检索增强生成（RAG）实现了外部向量数据接地；随后模型通过函数调用（Function Calling）接入外部工具和实时搜索引擎；而在 2025 至 2026 年，架构重点正在转向由模型复杂推理驱动的工具编排，并最终迈向多智能体协作系统。Elliott 展望，未来的终极形态将是由数千甚至数百万个专用智能体协同集群化解决复杂问题。底层的智能体系统均由三大核心要素构成：用于决策与逻辑推理的模型、负责工作流控制的编排层，以及提供动作与数据接入的工具与 API。然而，企业在将智能体投入生产时面临严峻阻碍。模型以周乃至以日为单位快速迭代，开源生态与第三方工具高度分散且难以打通，导致原型开发极易陷入集成摩擦。此外，传统软件工程缺乏面向智能体的生命周期管理（MLOps）、规模化监控与企业级安全合规治理，导致大量项目停留在脆弱的概念验证（PoC）阶段。要跨越这一鸿沟，行业必须建立标准化的开发者工具包、开放互操作协议以及企业级运维平台。开源 ADK 框架的设计原则与核心能力 (7:14) 作为 Google 智能体技术栈的核心开发套件，于 4 月宣布的 Agent Development Kit（ADK）是一套专为软件工程师设计、以代码优先（Code-First）为原则的开源客户端框架，旨在摒弃不透明的黑盒封装。Elliott 强调 ADK 遵循三大架构原则：第一是模型无关性，该框架虽然对 Google 自研的 Gemini 模型进行了深度调优，但全面兼容第三方商业模型与开源权重模型；第二是部署无关性，构建的智能体可在全托管平台、容器集群乃至本地环境中无缝运行；第三则是原生基于开放互操作协议构建，以便接入更广泛的多智能体网络。在技术能力方面，ADK 提供了兼顾灵活性与合规性的编排机制。开发者既能配置由大模型自主规划路径的动态推理循环，也能构建严格确定性的硬编码流程，以满足企业高合规场景下的确定性需求。此外，ADK 原生支持多模态双向流式传输，能够低延迟实时处理文本、图像与视频数据流，并内置了用于生产前质量评估与基准测试的 Evals 工具套件，确保系统在部署前的输出准确率与稳定性。 MCP 协议集成与 Vertex AI 托管运行时 (9:47) 生产就绪不仅关乎代码逻辑，更取决于部署途径与上下文接入能力。针对工具交互，ADK 深度集成了由 Anthropic 发起并已演进为行业标准的模型上下文协议（Model Context Protocol，MCP）。ADK 与 MCP 属于互补协同关系：开发者既可以在 ADK 智能体内直接调用外部现成的 MCP 服务器作为工具，也能将 ADK 构建的内部能力包装为 MCP 服务器向外发布。在部署层面，ADK 智能体可直接容器化打包，灵活发布至 Google Kubernetes Engine（GKE）、Cloud Run 无服务器环境、用户自建 Docker 实例或本地私有化服务器。为了消除企业自行维护底层基础设施的繁琐运维负担，Google Cloud 提供了商业付费层 Vertex AI Agent Engine 作为全托管企业运行时。Agent Engine 重点解决了复杂会话中的状态管理挑战，提供开箱即用的短期工作记忆与跨会话长期持久化存储。同时，该平台提供了端到端调用链追踪、集中式运行日志与监控、身份与访问管理（IAM），以及用于动态代码安全执行的沙箱环境，为关键业务应用提供生产级保障。 A2A 协议与 Linux 基金会开放协同治理 (12:19) 为了实现异构系统间智能体的自主协同，Google 推出了 Agent2Agent（A2A）轻量级协作协议，并将其捐赠给 Linux 基金会，由包括主流云厂商和 AI 企业在内的行业委员会共同维护。A2A 协议的设计初衷是让来自不同技术栈的“黑盒智能体”能够互相理解与沟通，防止单一厂商技术锁定。该协议通过三组核心原语规范交互行为：每个智能体对外发布“智能体名片”（Agent Card），用于公开声明自身的业务职能、运行限制与暴露的接口规范；主控智能体（如顶层策略决策模块）可依据名片向对等专业智能体分派结构化任务；执行过程与结果则通过双向实时流式传输与异步推送通知渠道进行反馈。这种模式将风控审查、数据检索、合规审计等特定业务解耦为微服务化的独立智能体，实现了按需动态编排与跨系统协作。 Google 当前的智能体全栈布局中，ADK 框架、MCP 上下文接入和 A2A 协议均采取开源或开放标准治理，结合 Vertex AI Agent Engine 商业托管运行时，构成了从开发、联通到生产运维的完整闭环；然而，面对未来数以万计的多智能体集群协同愿景，系统在极端规模下的通信调度开销、长链路推理可靠性以及跨生态治理的复杂度，仍是该技术栈全面铺开过程中需持续验证的现实课题。

Detailed notes — zh

## Background 本视频由 Ai4 于 2025 年 8 月 28 日发布于 YouTube 平台，主讲人为 Google Cloud 开发者布道与 AI 工程负责人 Dave Elliott。内容简介指出，本次演讲旨在探讨如何超越简单提示词构建强大的 AI 智能体，重点解析编排、模型与工具的协同，并深入公开由 ADK、MCP 与 A2A 协议构成的 Google Cloud 智能体技术栈。 ## TL;DR 演讲系统梳理了 AI 从单次 Prompt 交互、RAG 检索增强演进至多工具推理循环与多智能体协同网络的五个阶段，剖析了企业落地面临的工具碎片化与运维治理挑战。为此，Google 推出了以编排、模型和工具为核心的智能体技术栈，包含四大支柱：代码优先且解耦的开源客户端框架 ADK、连接数据源的标准协议 MCP、负责企业级记忆与运维管理的全托管运行时 Vertex AI Agent Engine，以及跨系统协作协议 A2A。最后，演讲为开发者提供了快速安装 SDK、查阅开源文档与开箱即用示例的完整工程落地路径。 ## Atmosphere & style 整场演讲氛围轻松幽默且极具工程实战感，Dave Elliott 以调侃自己是大家通往“会后鸡尾酒会”的唯一路障开场，瞬间拉近了与技术观众的距离。他的台风自如干练，摒弃了空洞的商业包装，始终坚持从“由软件工程师打造、为软件工程师服务”的务实视角剖析架构细节，让前沿复杂的协议标准与企业级落地痛点显得生动而透彻。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=72zGRb3CpFw&t=4s) AI 智能体（Agents）是释放大语言模型商业价值的核心路径，但当前面临工具生态碎片化与生产级运维治理（Ops & Governance）缺失的严峻挑战。 - [02:52](https://www.youtube.com/watch?v=72zGRb3CpFw&t=172s) AI 技术演进经历从传统 Prompt 对话、RAG 检索增强、函数调用（Function Calling），向多工具推理循环（Reasoning Loops）与多智能体协作网络（Multi-Agentic Swarms）迈进的五个阶段。 - [02:52](https://www.youtube.com/watch?v=72zGRb3CpFw&t=172s) 智能体基础架构由编排（Orchestration）、模型（Models）与工具（Tools）三大要素构成，模型扮演核心决策大脑的角色。 - [05:20](https://www.youtube.com/watch?v=72zGRb3CpFw&t=320s) Google 智能体技术栈由四大支柱构成：开源框架 ADK、数据上下文协议 MCP、全托管运行时 Vertex AI Agent Engine 以及跨智能体互联协议 A2A。 - [07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) Agent Development Kit (ADK) 是专为软件工程师打造的开源代码优先框架，具备模型无关（Model Agnostic）、部署无关与高互操作性三大解耦特性。 - [07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) ADK 支持自主推理循环与确定性工作流（Deterministic Workflows）的双重编排，并原生支持多模态双向流式传输及内置评估体系。 - [09:47](https://www.youtube.com/watch?v=72zGRb3CpFw&t=587s) ADK 将“部署就绪”作为核心设计考量，支持将 Agent 打包为容器镜像并灵活部署在 Vertex AI、Cloud Run、GKE 或本地 Docker 基础设施上。 - [09:47](https://www.youtube.com/watch?v=72zGRb3CpFw&t=587s) ADK 与 Model Context Protocol (MCP) 深度协同，既能在 ADK 中直接消费现有的 MCP Server 工具与数据源，也可将 ADK 工具封装暴露为 MCP 接口。 - [11:34](https://www.youtube.com/watch?v=72zGRb3CpFw&t=694s) Vertex AI Agent Engine 作为全托管运行时，负责接管生产环境中的内存管理（短期与长期记忆）、可观测性（日志/追踪/监控）以及安全代码执行。 - [12:19](https://www.youtube.com/watch?v=72zGRb3CpFw&t=739s) Agent2Agent (A2A) 协议已捐赠至 Linux 基金会，通过 Agent Card 身份能力宣告与标准化任务派发机制，实现跨厂商异构智能体间的自主协同分工。 - [14:06](https://www.youtube.com/watch?v=72zGRb3CpFw&t=846s) 开发者可通过 pip 命令快速安装 google-adk 与 a2a-sdk，借助开源社区的文档与参考示例快速构建生产就绪的多智能体系统。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=72zGRb3CpFw&t=4s) 开场与智能体时代带来的挑战 Dave Elliott（Google Cloud 开发者布道与工程团队负责人，在 Google 工作约 13 年）以轻松幽默的语气开场，调侃自己是全场“挡在大家与鸡尾酒会之间的最后一人”，甚至开玩笑说准备讲上三个小时。他明确本次演讲时长约为 18 到 20 分钟，将重点概述 Google 的智能体 AI 技术栈（Agentic AI Stack），并为开发者提供丰富的上手资源。 ```mermaid flowchart TD accTitle: 智能体落地面临的企业级挑战 subgraph 挑战分析 A["碎片化工具与模型生态 (几乎每天都在迭代)"] --> D["落地难点"] B["工具集成极度困难 (新工具层出不穷)"] --> D C["缺乏运维与治理 (Ops & Governance)"] --> D end subgraph 核心诉求 D --> E["开发者工具包 (Toolkit)"] D --> F["标准化交互协议 (Protocols)"] D --> G["可扩展智能体平台 (Platform)"] end ``` Dave 指出，AI 智能体（Agents）是个人与企业真正释放并兑现大语言模型（LLM）核心价值的关键路径。尽管行业热度极高，但在实际构建中面临着严峻的现实困境： - **生态与工具碎片化**：基础模型和开源工具几乎每周、甚至每天都在快速更替，新工具的涌现让系统集成极为复杂且脆弱。 - **缺乏运维与治理（Ops & Governance）**：在企业生产环境中，模型的可信度、安全性、运维监控以及治理机制是创造真正商业价值的前提，也是当前市场的关键痛点。 - **核心诉求**：开发者急需加速构建的开发工具包、连接异构系统的标准化通信协议，以及支持大规模扩展与管理的智能体平台。 --- ### [02:52](https://www.youtube.com/watch?v=72zGRb3CpFw&t=172s) AI 演进的五个阶段与智能体基础架构回顾 AI 近几年的演进历程，Dave 梳理了技术发展的关键脉络：从最初常出现幻觉、信息滞后的传统 LLM 提示词对话；到约 18 个月前基于向量数据库检索的 RAG（检索增强生成）技术实现数据溯源；再到一年前让智能体能够走出沙盒、通过函数调用（Function Calling）调用外部 API 和 Google Search 等外部工具。 ```mermaid flowchart LR accTitle: AI 技术演进的五个阶段 P1["阶段 1 经典 Prompt 对话 (易幻觉/数据过时)"] --> P2["阶段 2 RAG 检索增强 (向量数据检索)"] P2 --> P3["阶段 3 函数调用 (Function Calling) (连接外部 API/搜索)"] P3 --> P4["阶段 4 (2025) 多工具协同与推理循环 (Reasoning Loops)"] P4 --> P5["阶段 5 (2026+) 多智能体协作网络 (Multi-Agentic Swarms)"] ``` 进入 2025 与 2026 年，技术正迈向更高级的两个阶段： - **阶段 4：多工具协调与推理循环（Reasoning Loops）**：由基础模型驱动任务编排，协调多个工具进行多步推理决策。 - **阶段 5：多智能体协作系统（Multi-Agentic Systems）**：智能体之间不再仅仅是互相通信，而是实现深度的任务协同（Collaboration），这高度依赖跨厂商的标准协议支持。 - **智能体基础三元架构**：任何智能体架构的核心均由**编排（Orchestration）**、**模型（Models）**和**工具（Tools）**三大要素构成，模型作为核心决策大脑，指导选择调用哪些工具及如何推进流程。 --- ### [05:20](https://www.youtube.com/watch?v=72zGRb3CpFw&t=320s) Google 智能体技术栈（Agentic AI Stack）全貌揭晓 Dave 正式揭晓了 Google Cloud 的智能体技术栈。该技术栈主要包含四大核心支柱，其中有三项完全基于开放协议或开源生态，兼顾了灵活性与企业级生产需求： | 核心组件 | 定位与性质 | 核心功能与亮点 | |:--- |:--- |:--- | | **ADK (Agent Development Kit)** | 开源客户端框架 | “全场主角/皇冠明珠”，代码优先（Code-first），专为软件工程师设计，无黑盒封装。 | | **MCP (Model Context Protocol)** | 开放标准化协议 | 业界通用的上下文协议，为智能体提供对外部数据源的安全、标准化直接访问。 | | **Vertex AI Agent Engine** | 全托管企业级运行时（付费服务） | 提供生产级运维（Ops）与治理，负责底层算力管理、安全边界与弹性伸缩。 | | **A2A (Agent2Agent Protocol)** | 开放标准化协议 | 智能体间端到端协作协议，解决异构智能体间的通信与自主协同分工问题。 | --- ### [07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) 核心主角：Agent Development Kit (ADK) 深入解析作为整个技术栈的核心，开源的 Agent Development Kit（ADK）于 2024 年 4 月公布后迅速获得了开发者社区的广泛支持。Dave 强调，ADK 并非由算法研究员或纯机器学习专家闭门造车而成，而是“由软件开发者打造，专为软件开发者服务”（Built by software developers for software developers），彻底摒弃了难以调试的黑盒设计。 ```mermaid flowchart TD accTitle: ADK 核心架构特性 ADK["ADK (Agent Development Kit)"] subgraph 三大核心解耦特性 ADK --> M["模型无关 (Model Agnostic) 适配 Gemini 及第三方主流模型"] ADK --> D["部署无关 (Deployment Agnostic) 支持 Cloud Run / GKE / 自建基础设施"] ADK --> I["高互操作性 (Interoperability) 支持标准协议与多智能体集群协同"] end subgraph 五大关键工程能力 ADK --> F1["灵活编排: LLM 驱动推理或确定性工作流"] ADK --> F2["透明 IDE 环境: 代码优先，告别黑盒"] ADK --> F3["原生多模态双向流式处理 (Bidirectional Streaming)"] ADK --> F4["内置评估体系 (Built-in Evaluation)"] ADK --> F5["生产就绪 (Deployment Ready)"] end ``` ADK 具备三大解耦属性与五项关键特性： - **三大解耦属性**： 1. **模型无关（Model Agnostic）**：虽然针对 Gemini 进行了深度优化，但全面兼容并支持开发者自由接入各类主流大模型。 2. **部署无关（Deployment Agnostic）**：既可无缝对接 Vertex AI Agent Engine 托管服务，也能容器化部署在 Cloud Run、GKE（Google Kubernetes Engine）或企业私有基础设施上。 3. **面向互操作性（Interoperability）**：天生为阶段 4 和阶段 5 的多智能体协作设计，为数以千计甚至数以百万计的智能体“蜂群式”协同解决复杂问题铺平道路。 - **关键工程特性**： - **灵活的编排控制**：既支持大模型驱动的自主推理循环，也允许开发者显式编写确定性工作流（Deterministic Workflows），满足企业对结果稳定性的严苛要求。 - **原生多模态双向流式传输**：支持图像、视频与文本的低延迟双向流式交互，大幅提升智能体的多模态感知能力。 - **内置评估与部署就绪**：内置完备的 Eval 工具链，确保智能体输出可测、可控并直接具备投产上线能力。 ### [09:47](https://www.youtube.com/watch?v=72zGRb3CpFw&t=587s) ADK 的部署优势与 Model Context Protocol (MCP) 协同在社区反馈方面，Reddit 等讨论区及开发者聊天室对 ADK（Agent Development Kit）给予了高度评价，特别是认可 ADK 从设计之初就将“部署”（Deployment）作为核心考量，而不是在构建完成后才草率补充的“事后想法”（afterthought）。一个完整的 Agent 生命周期涵盖了开发、打包以及最终部署到运行时端点的全流程：开发者可以将 Agent 打包为容器镜像，灵活部署在 Vertex AI Agent Engine、Google Cloud 托管服务，或者运行在自建的 Docker 主机、GKE（Google Kubernetes Engine）以及各类本地私有基础设施上。 ```mermaid flowchart LR accTitle: Agent Deployment Flow subgraph Dev["开发阶段"] A["ADK Agent 开发"] end subgraph Package["打包阶段"] B["容器化打包 (Container)"] end subgraph Deploy["部署目标平台"] C1["Vertex AI Agent Engine"] C2["Google Cloud 托管环境"] C3["自建环境 (Docker / GKE / On-Prem)"] end A --> B B --> C1 B --> C2 B --> C3 ``` 除了 ADK，现代 Agent 架构的关键一环是 Anthropic 开发的开放协议——Model Context Protocol（MCP）。MCP 旨在实现 AI 应用、Agent、工具以及各类数据源之间的无缝集成，其中与多样化数据源对接的标准化能力最为亮眼。当前行业正掀起构建和托管 MCP Server 的热潮。ADK 与 MCP 的协同模式主要体现为两类： 1. **在 ADK 内部消费 MCP**：直接在 ADK 构建的 Agent 中调用现有的 MCP Server 及其工具与资源。 2. **将 ADK 工具暴露为 MCP**：将 ADK 中封装的工具能力通过 MCP Server 对外开放，供其他生态系统调用。两者相辅相成，共同加速生产级 Agent 系统的落地。 --- ### [11:34](https://www.youtube.com/watch?v=72zGRb3CpFw&t=694s) 全托管运行时：Vertex AI Agent Engine 在整个技术栈中，Vertex AI Agent Engine 是唯一的商业化全托管运行时（Managed Runtime）产品。该产品旨在接管繁重的底层基础架构运维，让开发者能够将全部精力聚焦在自身应用的业务逻辑实现上。 Agent Engine 集中解决了 Agent 运行中最复杂、最令人头疼的核心基础设施需求： - **内存管理（Memory Management）**：提供全面的短期记忆（Short-term）与长期记忆（Long-term）管理机制。演讲者幽默地调侃道：“如果给我一小时，光是记忆管理我们就能聊上一整天——前提是我还记得自己想讲什么。” - **可观测性与运维**：原生集成监控（Monitoring）、日志记录（Logging）与分布式链路追踪（Tracing）。 - **企业级服务支持**：内置身份与访问管理（Identity Management）以及受控的安全代码执行环境（Code Execution）。 --- ### [12:19](https://www.youtube.com/watch?v=72zGRb3CpFw&t=739s) 跨系统互联：Agent2Agent (A2A) 协议作为全栈中的最简协议层，Agent2Agent（A2A）协议专注于解决多智能体之间的互操作性问题。它不仅支持 Agent 对外宣告（Advertise）自身的功能与容量，更支持不同 Agent 在明晰彼此职责后进行深度协作，使各类“黑盒 Agent”（Black-box Agents）能够跨系统、跨厂商无缝通信。虽然 A2A 最初由 Google 发起开发并持续提供支持，但 Google 已将其捐赠并开源至 Linux 基金会（Linux Foundation）。目前，主流行业厂商均已加入该项目的管理委员会，形成了广泛的行业支持声浪，共同加速多 Agent 协作生态的成熟。 ```mermaid flowchart TD accTitle: Agent to Agent (A2A) Collaboration Architecture subgraph Core["核心协调层"] SA["策略 Agent (Strategy Agent)"] end subgraph Protocol["A2A 协议机制"] Card["Agent Card (能力宣告/识别)"] Task["Task 分派 & 流式/推送通知"] end subgraph SubAgents["外部协作 Agent"] RA["风险评估 Agent (Risk Agent)"] BA["黑盒外部 Agent (Black-box Agent)"] end SA --> Protocol Protocol --> RA Protocol --> BA ``` - **业务场景示例**：左侧的主控“策略 Agent”（Strategy Agent）在执行复杂业务规划时，不仅需要调用基础工具，还会通过 A2A 协议调度中间的“风险评估 Agent”（Risk Agent），甚至进一步级联调用远端的第三方“黑盒 Agent”。 - **A2A 核心协议要素**： - **Agent Card**：用于声明和识别 Agent 的身份、功能范围与接口契约。 - **Task & Notification**：标准化的任务派发机制，支持实时流式传输（Streaming）与异步推送通知（Push Notifications）。 --- ### [14:06](https://www.youtube.com/watch?v=72zGRb3CpFw&t=846s) 开发者行动指南与生态资源演讲回顾了 Agent 从单一提示词到支持多工具、推理循环（Loops）以及多智能体协同系统的技术演进历程。Google 的 Agentic AI 核心技术栈由 **ADK（核心引擎）**、**MCP（上下文与工具协议）**、**Vertex AI Agent Engine（托管运行时）** 以及 **A2A（跨智能体互联协议）** 四大支柱构成。演讲者为开发者提供了具体的实践落地路径与资源： - **上手 ADK**：通过终端执行 `pip install google-adk` 快速安装。官方仓库提供了丰富的社区资源、2025年4月上线时编写的 50 至 60 页详尽文档，以及 8 到 10 个开箱即用的参考示例 Agent。 - **上手 A2A**：通过 `pip install a2a-sdk` 安装 SDK，访问开源仓库获取规范与代码示例（目前处于早期精简阶段，更多特性持续更新中）。 - **展台交流与互动**：演讲者公开了个人 LinkedIn 账号以建立开发者联系，并邀请参会者前往 Google 展台体验实机 Demo、领取定制线缆收纳包等周边礼品，最后祝愿大家享受接下来的鸡尾酒交流时光。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=72zGRb3CpFw&t=4s) 挡在大家与鸡尾酒会之间的最后一人 — Dave Elliott > [05:20](https://www.youtube.com/watch?v=72zGRb3CpFw&t=320s) 全场主角/皇冠明珠 — Dave Elliott > [05:20](https://www.youtube.com/watch?v=72zGRb3CpFw&t=320s) 代码优先（Code-first），专为软件工程师设计，无黑盒封装 — Dave Elliott > [07:14](https://www.youtube.com/watch?v=72zGRb3CpFw&t=434s) 由软件开发者打造，专为软件开发者服务（Built by software developers for software developers） — Dave Elliott > [09:47](https://www.youtube.com/watch?v=72zGRb3CpFw&t=587s) 部署不是构建完成后才草率补充的“事后想法”（afterthought） — Dave Elliott > [11:34](https://www.youtube.com/watch?v=72zGRb3CpFw&t=694s) 如果给我一小时，光是记忆管理我们就能聊上一整天——前提是我还记得自己想讲什么。 — Dave Elliott > [14:06](https://www.youtube.com/watch?v=72zGRb3CpFw&t=846s) pip install google-adk — Dave Elliott > [14:06](https://www.youtube.com/watch?v=72zGRb3CpFw&t=846s) pip install a2a-sdk — Dave Elliott ## Mentioned Dave Elliott, Google, Google Cloud, Ai4, Gemini, Agent Development Kit (ADK), Model Context Protocol (MCP), Agent2Agent (A2A), Anthropic, Vertex AI Agent Engine, Linux 基金会 (Linux Foundation), Google Kubernetes Engine (GKE), Cloud Run, Docker, Google Search, Reddit, LinkedIn ## Video description Dave Elliott, Head of Developer Advocacy for AI, Google Cloud Abstracts How can you effectively build and deploy powerful AI agents that move beyond simple prompts? This session dives into the core components of an agentic stack, exploring how orchestration, models, and tools combine to create intelligent, autonomous systems. We'll unveil Google Cloud's agentic stack, highlighting the Agent Development Kit (ADK), Model Context Protocol (MCP), and Agent2Agent (A2A) protocol, and demonstrate how they enable robust agent development and interoperability. Join us to learn how to leverage these innovations to unlock the full potential of AI agents in your applications. How can you effectively build and deploy powerful AI agents that move beyond simple prompts? This session dives into the core components of an agentic stack, exploring how orchestration, models, and tools combine to create intelligent, autonomous systems. We'll unveil Google Cloud's agentic stack, highlighting the Agent Development Kit (ADK), Model Context Protocol (MCP), and Agent2Agent (A2A) protocol, and demonstrate how they enable robust agent development and interoperability. Join us to learn how to leverage these innovations to unlock the full potential of AI agents in your applications. [Source](https://www.youtube.com/watch?v=72zGRb3CpFw)

Source quotes

[0:04] Dave Elliott: 挡在大家与鸡尾酒会之间的最后一人 [5:20] Dave Elliott: 全场主角/皇冠明珠 [5:20] Dave Elliott: 代码优先（Code-first），专为软件工程师设计，无黑盒封装 [7:14] Dave Elliott: 由软件开发者打造，专为软件开发者服务（Built by software developers for software developers） [9:47] Dave Elliott: 部署不是构建完成后才草率补充的“事后想法”（afterthought） [11:34] Dave Elliott: 如果给我一小时，光是记忆管理我们就能聊上一整天——前提是我还记得自己想讲什么。 [14:06] Dave Elliott: pip install google-adk [14:06] Dave Elliott: pip install a2a-sdk

Source quotes

[0:04] Dave Elliott: I'm the last one standing between you and the cocktail hour. Uh, so I plan to take three hours. No. Okay. [2:52] Dave Elliott: thousands or even millions of agents sort of swarming to try to solve problems [5:20] Dave Elliott: by software developers for software developers [7:14] Dave Elliott: Gemini rocks. Gemini always does really well [12:19] Dave Elliott: black boxes can talk to each other [14:06] Dave Elliott: pip install google-adk [14:06] Dave Elliott: pip install a2a-sdk

Original transcript

[0:04] So, I'm the last one standing between [0:06] you and the cocktail hour. Uh, so I plan [0:09] to take three hours. No. Okay. Uh, so [0:11] I'm Dave Elliot. Um, I've been at Google [0:13] for about 13 years. I run the developer [0:16] evangelism and engineering organization. [0:18] So we work with developers primarily. [0:20] Um, so if you're a developer, yay. Yay. [0:22] Um, this session's 20 minutes long or [0:25] now maybe 18 minutes long. Uh, so we're [0:28] not going to be able to really get in [0:29] depth on a lot of things. What I'm going [0:31] to try to give you is an overview of one [0:34] specific thing, which is Google's [0:36] Agentic AI stack, and then give you lots [0:39] of resources, uh, to send you off to be [0:41] able to go play with it yourself. I will [0:43] say at the start, um, come see us at the [0:46] booth downstairs, booth 500. Um, I'll be [0:48] there for a big part of the day [0:50] tomorrow, um, and we can answer your [0:52] questions, um, and we're giving away [0:53] some free stuff. So, let's get started. [0:56] um agents. It's the way that I think the [0:59] world's going to rec real realize the [1:01] value of LLMs, right? It's delivering on [1:03] the promise of LLMs. That's how I see [1:05] it. Individuals, companies are going to [1:08] realize the value of LLMs through [1:10] agents. So, there's lots of hype. I [1:12] think half the sessions here are on [1:14] agents and for good reason. If you were [1:16] in my session last year here, I talked [1:19] about agents and I talked about really [1:22] the early stages of agents and and it [1:24] was really hard to to to drive that [1:27] value. I think today you're going to [1:29] you're going to uh be able to I think [1:32] realize that value a little bit more [1:33] easily. So why was it so hard? Um lots [1:36] of fragmented it's a fragmented [1:38] landscape. Lots of vendors, lots of [1:41] changes happening very quickly, right? [1:42] the models change almost every well [1:45] every week almost every day now. Um and [1:47] then the tools open source tools very [1:49] fragmented and then to compound it it's [1:51] really hard to integrate all of these [1:54] different tools. A big part of it is [1:56] because they've been changing so quickly [1:57] some new tools pop up this week that um [2:00] you know suddenly become you know the [2:02] the critical tool to use. Uh and then [2:05] the final piece of it is beyond actual [2:06] development is there's a lack really of [2:08] ops and governance. And for this this [2:11] event, I think there's a lot of talk [2:13] about that for good reason, right? If [2:15] you really want to get the value in an [2:16] enterprise, you're going to have to have [2:18] real governance. You're going to have to [2:19] have trust in in your models and in your [2:22] agents. So those are the problems. So [2:25] what do we need? We need a toolkit. So [2:28] some way so you can accelerate the [2:30] development of your agents. You need [2:33] protocols. So standard ways for all of [2:35] these various agents and for these [2:38] various tools and models to speak with [2:40] each other. And then you need an agentic [2:42] platform to actually be able to scale, [2:45] manage, monitor, all those good things [2:47] that you know enterprise customers care [2:49] about. So let's talk a little bit about [2:52] the evolution of AI as I see it. So [2:55] again for those who here were here last [2:57] year, I this is kind of what I what I [2:59] showed started with the old LLM prompt, [3:03] right? This is the the classic chat. It [3:06] hallucinated. It had outdated [3:08] information and the results weren't [3:10] really that great. Then we had this [3:12] incredible breakthrough of rag like 18 [3:15] months ago. Everything was grounded, [3:17] right? Grounded in real data, able to [3:19] use a vector database and that really [3:21] improved things. Then we moved into the [3:23] area of to the era of being able to not [3:25] just ground your your agents, but then [3:28] to be able to have your agents go [3:30] outside the real world, explore, get [3:33] information and and that was function [3:35] calling. And that was really what my [3:36] session was a year ago. That's was sort [3:38] of state-of-the-art a year ago. So, [3:40] being able to go out and call, you know, [3:42] within within your own system, within [3:44] your own LLM, these these external um [3:47] systems to be able to do things like, [3:49] you know, you could you could use uh uh [3:51] Google search. Uh you can you could go [3:54] out and use tools and other APIs. So, [3:57] that's that's where we were up up until [4:00] about this year. This year, we're really [4:02] in 2025. In 2026, I think there's two [4:06] two sort of uh follow-on phases. many [4:09] tools and reasoning loops. So this is [4:12] sort of phase four is where you've got [4:14] coordination across these mini tools [4:16] with the model maybe driving the [4:19] orchestration and then you've got this [4:22] like nirvana that people have been [4:24] talking about for a while which is [4:27] multi-agentic systems where agents not [4:30] just communicate with each other but [4:32] they collaborate with each other and [4:34] that really it requires a significant [4:36] investment from all the vendors and from [4:39] all the all of the all of you as as [4:41] developers and customers in protocols. [4:44] So that's where you think where we are [4:45] today, state-of-the-art today. So that [4:47] gives sets the groundwork for um [4:50] Google's agent stack. So what does a a [4:52] an architecture looks like? Something [4:54] really simple might be these three [4:56] things, right? Orchestration, models, [4:57] and tools. You've got the models which [5:00] are at the core, right? The models again [5:02] might be leveraged for uh across the [5:05] orchestration to be able to make [5:06] decisions um and to be able to make [5:08] decisions for instance which tools to [5:10] call. So any sort of model any sort of [5:13] um market architecture you see for [5:15] agents is gonna have something like this [5:17] right. So let's talk about Google's [5:20] agentic stack big precursor. So this is [5:22] it the big reveal. Um this is um the [5:26] sort of the core things that I think we [5:29] talk about in Google and and and in [5:31] particular I didn't mention I'm in [5:32] Google cloud so we sort of build the [5:34] infrastructure that enables a lot of [5:36] this. Um, so three of the four of these [5:38] are open protocols or open source. So [5:41] agent development kit, model context [5:43] protocol, MCP, vertex AI agent engine, [5:47] and A to A. So across each of these, [5:50] I'll I'll talk literally maybe three [5:51] minutes on each of these, but at a high [5:53] level, agent development kit is the star [5:55] of the show. It's the, you know, the [5:57] crown jewels. It's open source. It was [5:59] announced in April. It's gotten a ton of [6:01] support um from the developer community. [6:04] Uh and what it does is it's it's because [6:06] it's open source, it's uh code first and [6:10] it's ready for deployment. These are the [6:11] things that people seem to really like [6:12] about it. But the key thing is for me as [6:14] a software developer, it was built by [6:16] software developers for software [6:17] developers. So it wasn't built by [6:20] machine learning, you know, experts. It [6:22] wasn't built by by by researchers. This [6:24] was really built for software [6:25] developers. Uh second thing is model [6:28] context protocol MCP. Hopefully most of [6:29] you have heard a lot about that here. [6:31] It's really become standard. a great way [6:32] to provide context and direct access to [6:34] data uh within your agents. And then [6:37] Vert.Ex AI agent engine. This is a uh [6:39] managed runtime, a managed platform for [6:41] you to really achieve that governance [6:44] and ops that we talked about on the [6:46] first slide or second slide I guess. Um [6:48] so this is uh your ability to uh do [6:51] everything from manage your [6:52] infrastructure to scale and provide [6:54] security and things like that. This is [6:55] the paid service. Um but we'll talk [6:58] about ADK and and how all these work [7:00] together and you can use any [7:02] infrastructure you want. And then [7:03] finally is A to A or agentto agent [7:05] protocol. This is exactly what you think [7:07] it is. It's a standard protocol that [7:09] allows not just communication but [7:12] collaboration. I'm sorry. So let's jump [7:14] into each of these. The star agent [7:16] development kit. Agent development kit [7:18] is open source client side framework. Um [7:21] again developed by developers for [7:23] developers. uh you'll see a very uh [7:25] familiar UI, no closed box. Um if you [7:28] remember anything about it, it's these [7:29] three things. Um one is it's model [7:32] agnostic. So we love Gemini. Gemini [7:35] rocks. Gemini is always does really [7:37] well, but this framework supports [7:39] everything or most everything. Um so [7:42] pick the pick the model of your choice. [7:45] Um it can be supported here. Uh second [7:47] is it's deployment agnostic. So I [7:49] mentioned agent engine which is um our [7:52] managed service. You could also deploy [7:53] it in the cloud um with cloudr run um or [7:57] GKE Google uh Kubernetes engine um or [8:00] you can deploy it on your own [8:01] infrastructure. So however you like it's [8:04] deployment agnostic. And the third thing [8:06] is it really is built for [8:07] interoperability. I talked about this [8:09] phase four and phase five. Well, it has [8:11] to be interoperable, right? In the in [8:13] the way the way that people are going to [8:15] realize value from these agents is if [8:17] the agents can can work together. I mean [8:20] ultimately I I love the the the the [8:22] vision of you know being able to have [8:24] thousands or even millions of agents [8:25] sort of swarming to try try to solve [8:27] problems. The only way that's going to [8:28] happen is with standard protocols and [8:30] communications. [8:32] Okay. So six key things or I guess five [8:34] key things to remember about um agent [8:36] development kit because it is um sort of [8:39] again the star of the star of the show [8:41] here. Uh first is modular and flexible. [8:43] So you can deliver that orchestration I [8:45] mentioned driven by the LLM by decisions [8:49] that the LLM makes or you can set the [8:52] workflow yourself. You can have a [8:53] deterministic outcome and that's really [8:55] important for enterprises. Uh second [8:57] thing is uh the IDE so it's no black box [9:01] again designed by software developers [9:03] for software developers. So um you can [9:06] go and and I think use it and feel [9:08] comfortable. Uh third is native [9:11] multimodal birectional streaming. It's a [9:14] mouthful, but this is one of the unique [9:16] things um that generally speaking with [9:18] Google and with Gemini and you'll see [9:20] with with Vertex um which is our [9:22] endto-end platform and here with ADK, [9:24] this is something that's really [9:25] important. You get better results when [9:27] you can do image, video, and text. Um [9:30] two other things, um built-in [9:32] evaluation. So eval is important. um you [9:37] you want to make sure that you're you're [9:38] you're running the best models you're [9:40] you're and you're getting the results [9:41] you expect. And the last thing is [9:42] deployment ready. So when I say [9:44] deployment ready, again, remember I said [9:46] some of the important things about ADK, [9:47] you know, when you look at go to Reddit [9:49] or any of the chat rooms out there about [9:51] ADK and people thought have commented [9:53] that we really thought about how to, you [9:55] know, getting your agent deployed is is [9:57] isn't an afterthought. Um so when I say [10:00] that, this is what I mean and I think [10:01] I've repeated this a couple times, but [10:03] this is a pretty picture that tells it. [10:05] So when you when you're trying to get [10:06] into an agent deployed, right, you [10:09] develop it, then you package it up and [10:11] then you've got some platform to deploy [10:13] it, some some endpoint. So you can [10:15] package this as a container, run it on [10:17] vertexi agent engine, run it on cloud, [10:19] run in the cloud, or you can manage it [10:21] yourself, you know, a docker host GTE or [10:24] onrem your own infrastructure. So [10:27] some of the magic, I think, some of the [10:29] differentiation around agent engine, I [10:31] mean around agent development kit. Okay, [10:33] so now let's move on to the next thing [10:34] here which is model context protocol [10:38] MCP. Um I think most of you know about [10:41] this. It's it's an open protocol [10:43] actually developed by anthropic. Uh it [10:45] enables seamless integration between AI [10:48] apps and agents and tools and data [10:50] sources. So really it's a data sources [10:52] piece that's I think most compelling. Um [10:54] and there's been a whole rush to to [10:56] build and manage uh and make available [10:58] MCP servers. Um, so it's a standard way [11:00] for you to interact with these prompts [11:02] and tools and resources. So how ADK and [11:06] MCP might work together is really two [11:09] things. One is you can use existing MCP [11:13] servers within ADK or you can expose ADK [11:18] tools via an MCP server. So they work [11:21] collaboratively together. they solve uh [11:24] uh very different problems and I think [11:26] it's really important as you as you [11:28] sprint to getting you know agents in [11:29] into production that you think about ADK [11:32] and MCP [11:34] okay the third thing is Vertex AI agent [11:37] engine now this was this is again I want [11:39] to emphasize this is the one commercial [11:41] product this is a managed runtime that [11:43] allows you to um do everything like [11:45] build like like set up your [11:46] infrastructure it kind of makes it so [11:48] you can focus on the logic of your own [11:50] applications you know in a classic [11:52] managed runtime uh scenario and it does [11:55] things like manage memory, right? Memory [11:57] is so huge right now. If I had an hour, [11:59] we could talk just about memory. Such a [12:01] such a if I can remember what I want to [12:03] talk about, we talk about memory. No, uh [12:05] we have short-term, long-term um [12:07] monitor, log, trace, identity [12:09] management, code execution, all the [12:10] things that you that you know typically [12:12] you hate doing or you have got a [12:13] specialist who helps manage that is [12:15] Vertex AI agent engine. [12:19] And then um the last piece of this is uh [12:23] is uh a toa or agent to agent protocol. [12:26] So what is agentto aagent protocol? This [12:28] is probably the simplest one of them [12:30] all. It's literally just a protocol. Um [12:32] it's a protocol that's been set up um so [12:35] that you can again not just communicate [12:37] and advertise sort of what the the uh [12:40] capacity of your of your agent is, but [12:42] you can collaborate once you understand [12:44] that capacity the what what it's [12:46] designed to do. And so this is, you [12:47] know, sort of designed so that um, you [12:50] know, black boxes can can talk to each [12:52] other. That's kind of what it comes down [12:53] to. And this has been something that [12:55] well yes it was developed by Google and [12:56] we still support it but we threw it open [12:58] into the um Linux foundation and now on [13:01] the board there's it's you know all all [13:02] the typical vendors you would think um [13:05] there's been a a ground swell of support [13:07] for a in a way to accelerate you know [13:09] agents again becoming a reality and um [13:14] and and and you know all the all of us [13:16] vendors see this as something that is [13:18] critical. So how what how might a work? [13:21] So you've got um this really interesting [13:24] use case here of well maybe it's not [13:26] that interesting but a strategy agent um [13:29] on the left hand side here and the [13:31] strategy agent may need to go out and [13:33] you know call some not just tools but [13:35] call other agents who might themselves [13:37] be out calling other agents and other [13:39] tools. So you in this case you've got on [13:41] the far right a blackbox agent and then [13:44] you've got um uh that maybe anything and [13:46] then you've got maybe a risk agent right [13:48] so you've got these multiple agents so [13:50] you aa protocol [13:53] um makes it so that you establish an [13:55] agent card right so a way for you to uh [13:58] identify what it does a task and then [14:02] ultimately push notifications and [14:03] streaming all right now let me wrap up I [14:06] think I'm I think I'm on time here I [14:07] wish I had two hours to talk the [14:10] evolution of of of agents I think has [14:13] been really fun and I love the fact that [14:15] I get to come back here and talk um [14:17] because it because it really is this is [14:19] almost you know part two of the [14:21] conversation I had a year ago um now [14:23] we're talking about many tools reading [14:25] and loops and multiple agentic systems [14:28] the heart of that you know this talk is [14:30] about Google's AI agentic stack starts [14:33] with ADK um again the crown jewels MCP [14:37] vertex AI agent engine and then A to A [14:42] and I want to leave you with some actual [14:44] action items some stuff that you can go [14:46] out and do bring back to your teams. So, [14:48] first off, use a product, right? Any [14:50] developer use a product. Pip install [14:53] Google ADK. And here is, you know, you [14:56] break out your camera. Here is um a [14:58] bunch of resources for ADK um that some [15:02] of my team built and some the community [15:04] built. It's really again gotten good [15:06] great reception in the community. The [15:07] GitHub repo is a great place to start. [15:10] Um we've got, you know, some really good [15:12] docs. My team wrote all the like 50 or [15:14] 60 pages of docs when we launched this [15:15] thing in April. Uh and then sample [15:18] agents. Um so you know these are real I [15:22] think we've got eight or 10 real agents [15:23] that have been built that you can go go [15:24] play with [15:26] um for a toa same thing right just use [15:30] it pip install a ad aka a2a SDK [15:34] and you might guess the next slide is [15:37] a QR code so you can go and um play with [15:40] uh there's much less information on a [15:43] toa again it's kind of simple it's you [15:46] know simply a protocol um but a lot more [15:48] is coming so there's There's a there's a [15:51] a repo where you can go and play with [15:52] this. All right. So, um I'm at 18 [15:56] minutes right now. I'm going to finish [15:57] with two things. One is this is my my [16:00] LinkedIn. I love to hear from [16:02] developers. Please take a picture. Uh [16:04] contact me. I promise I'll I'll uh [16:06] respond. I'll I'll I'll accept the [16:08] invite. Um this I I post on here [16:11] occasionally to so you'll get more [16:13] information on what's happening with [16:14] agents at Google. Um so, please connect. [16:17] want to hear from you. And then finally, [16:19] as I said at the top, thank you and come [16:22] see us at the booth. We have um we have [16:25] neat little giveaways. I think it's a a [16:27] cable bag or something like that. Um but [16:28] we also have some demos that might be [16:30] fun. So, thank you so much and enjoy the [16:32] cocktail hour.