第九篇：驾驭复杂AI——Google ADK如何赋能多代理系统设计与实践

随着人工智能（AI）应用的复杂性日益增加，单一代理（Agent）往往难以胜任。多代理系统（Multi-Agent Systems, MAS）通过将复杂问题分解，并由多个具有特定技能的代理协同工作来解决，展现出巨大的潜力。Google 的 Agent Development Kit (ADK) 为构建和管理此类复杂的多代理系统提供了强大的开源框架。本文作为 Google Agent Development Kit 系列的第九篇，将深入探讨多代理系统的设计原则，涵盖协作架构、通信机制、任务分配、子任务委派与结果整合，并通过一个团队协作型项目管理代理的实例，展示如何使用 ADK 构建实际的多代理应用。

1. 多代理协作架构设计

构建高效的多代理系统，首先需要精心设计其协作架构。不同的架构模式适用于不同的应用场景，ADK 提供了灵活的构建模块以支持这些模式。

1.1. 常见多代理架构模式

在多代理系统领域，已沉淀出多种成熟的协作架构模式，理解这些模式及其适用场景对于设计高效的 MAS至关重要：

• 层级式/协调器-工作者模式 (Hierarchical/Coordinator-Worker Pattern): 在此模式中，代理被组织成层级结构，上层代理（协调器）负责任务分解、分配，并监督下层代理（工作者）的执行。这种模式清晰了指挥链，易于管理复杂任务，但也可能在协调器处形成瓶颈。ADK 通过其父子代理层级结构和 LlmAgent 作为协调者的能力，天然支持此模式。

• 顺序管道模式 (Sequential Pipeline Pattern): 任务按预定顺序流经一系列专业代理，每个代理完成特定阶段的处理，并将结果传递给下一个代理。此模式适用于具有明确线性流程的任务。ADK 的 SequentialAgent 是实现此模式的直接工具。

• 并行扇出/聚合模式 (Parallel Fan-Out/Gather Pattern): 一个任务被分解成多个可以并行处理的子任务，分配给不同的代理同时执行，最后将各个子任务的结果汇聚整合。这能显著提高处理效率。ADK 的 ParallelAgent 专为此类场景设计。

• 黑板模式 (Blackboard Pattern): 代理们围绕一个共享的知识库（黑板）进行协作。代理可以向黑板读取信息、发布中间结果或解决方案，实现异步松耦合通信。此模式适用于需要增量式、多方贡献解决的复杂问题。虽然 ADK 没有直接名为“黑板”的组件，但可以通过共享状态管理（如外部数据库结合自定义代理逻辑）或利用消息队列等方式实现类似机制。

• 评审/批评模式（生成 - 评论者）(Review/Critique Pattern 或 Generator-Critic): 通常包含一个生成器代理和一个批判者代理。生成器负责产出解决方案或内容，批判者则对其进行评估、提供反馈，生成器再根据反馈进行修正。这种迭代改进的模式有助于提升产出质量。

• 迭代改进模式 (Iterative Refinement Pattern): 代理或代理组通过多次迭代来逐步完善解决方案。每次迭代都可能涉及新的信息获取、处理或与其他代理的协商。

• 人机协作模式 (Human-in-the-Loop Pattern): 在关键决策点或代理能力不足时，引入人类用户进行干预、确认或提供输入。ADK 支持与用户的交互，包括通过其流式音视频能力实现更自然的对话，这为实现人在回路提供了基础。

选择合适的架构模式，或组合多种模式，取决于具体应用的需求，如任务的可分解性、代理间的依赖关系、对实时性的要求以及系统的可扩展性等。

1.2. ADK 中的架构支持

ADK 通过其核心原语为构建上述及其他自定义的多代理协作架构提供了坚实的基础。

• BaseAgent 层级结构: ADK 中所有代理都派生自 BaseAgent。通过在初始化父代理时传递一个代理实例列表给 sub_agents 参数，可以构建代理的树状层级结构。ADK 会自动在子代理上设置 parent_agent 属性。这种层级结构是 WorkflowAgent 作用范围的基础，并影响 LlmAgent 的委派目标。一个代理实例只能拥有一个父代理，确保了层级关系的清晰。

• WorkflowAgent: ADK 提供了一组专门的 WorkflowAgent（如 SequentialAgent, ParallelAgent, LoopAgent）来管理其子代理的执行流程。

• SequentialAgent: 按照定义的顺序依次执行其子代理。前一个子代理的输出可以通过状态共享，作为后一个子代理的输入。

• ParallelAgent: 并行执行其所有子代理，并在所有子代理完成后汇聚结果。

• LoopAgent: 根据特定条件或次数重复执行其子代理。 这些工作流代理使得开发者可以定义结构化的、可预测的控制流。

• LlmAgent 作为动态协调器: LlmAgent 由大型语言模型驱动，能够基于自然语言指令和上下文进行推理和规划。它可以动态地决定调用哪个工具（包括其他代理封装成的工具）或将任务委派给哪个子代理。这使得 LlmAgent 非常适合作为多代理系统中的协调器或调度器，实现更灵活和自适应的协作行为。

• 模块化与可重用性: 将复杂应用分解为多个小型、专业的代理，增强了系统的模块化程度。每个代理可以专注于特定功能，易于独立开发、测试和维护。这些专业代理也更容易在不同的多代理系统中被复用。

ADK 的这些设计使得开发者能够像搭积木一样构建复杂的多代理系统，同时保持对代理行为的精确控制。

2. 代理间通信与任务分配

代理间的有效通信和合理的任务分配是多代理系统成功的关键。ADK 提供了多种机制来支持代理间的交互。

2.1. ADK 内部通信机制

在 ADK 构建的单个多代理系统内部，代理间的通信主要依赖于层级结构和共享上下文。

• 状态管理与上下文共享: ADK 中的代理在执行过程中可以访问和修改会话状态（Session State）。在层级结构中，父代理和子代理可以共享部分上下文信息。例如，WorkflowAgent 会管理其子代理的执行上下文。当一个 LlmAgent 调用一个封装为 AgentTool 的子代理时，子代理的最终响应以及状态或工件（artifact）的变更会被传递回父代理的上下文中。

• output_key: 在 SequentialAgent 中，子代理可以通过指定 output_key 参数，将其执行结果保存到会话状态的特定键下。后续的子代理则可以从该键读取数据作为输入，实现数据的有序传递 。

• LLM 驱动的委派 (LLM-Driven Delegation) 与 AgentTool: 这是 ADK 中一种重要的内部通信和任务委派方式。可以将一个 BaseAgent 实例（包括 LlmAgent 或 CustomAgent）包装成一个 AgentTool，并将其添加到另一个父 LlmAgent 的工具列表中。父 LlmAgent 在接收到用户请求或需要执行特定子任务时，其内部的 LLM 可以决定调用这个 AgentTool。框架会执行该工具（即运行目标代理），捕获其最终响应，并将任何状态或工件的更改转发回父代理的上下文，然后将响应作为工具调用的结果返回给父 LLM。这种调用本质上是同步的（在父代理的流程内），显式的，并且像调用任何其他工具一样受到控制。

2.2. 跨框架/系统通信：Agent2Agent (A2A) 协议

当需要让不同框架构建的代理，甚至不同供应商提供的代理系统进行协作时，就需要一个标准的通信协议。Google 联合业界伙伴推出的 Agent2Agent (A2A) 协议旨在解决这一挑战。

• A2A 协议的目标: A2A 是一个开放标准，旨在促进独立、可能不透明的 AI 代理系统之间的通信和互操作性。它使得代理能够：

• 发现彼此的能力。

• 协商交互模式（文本、文件、结构化数据，甚至双向音视频）。

• 管理协作任务。

• 安全地交换信息以实现用户目标，而无需访问彼此的内部状态、内存或工具。

• 核心组件:

• Agent Card (代理名片): 一个 JSON 元数据文档，由 A2A 服务器发布，通常位于 /.well-known/agent.json 路径。它描述了代理的身份、能力（技能）、服务端点、支持的认证方案等信息。Agent Card 是实现代理发现的关键。

• A2A Server (远程代理): 一个遵循 A2A 协议规范，暴露 HTTP 端点的代理或代理系统，负责处理来自 A2A 客户端的任务并提供响应。

• A2A Client (客户端代理): 发起任务请求并消费 A2A 服务的应用或代理。

• 通信流程与技术栈:

• 发现: A2A 客户端首先通过获取远程代理的 Agent Card 来了解其能力和服务细节。

• 任务管理: A2A 定义了任务的生命周期状态，允许客户端发送任务、订阅任务更新，并接收最终结果。这对于处理可能长时间运行的异步任务尤为重要。

• 协作: 代理间可以通过共享上下文和指令进行协作。

• 技术栈: A2A 建立在广泛使用的 Web 标准之上，如使用 HTTPS 进行安全传输，使用 JSON-RPC 2.0 作为请求和响应的载荷格式，以及使用服务器发送事件 (Server-Sent Events, SSE) 进行实时流式更新。

• ADK 对 A2A 的支持: ADK 代理可以作为 A2A 客户端调用外部 A2A 服务，也可以通过适当的包装（例如使用 FastA2A 库 或自定义 HTTP 服务）暴露为 A2A 服务器，使其能力可被其他 A2A 兼容代理发现和使用。

A2A 协议的出现，极大地扩展了多代理系统的边界，使得构建跨组织、跨平台的复杂协作型 AI 应用成为可能。它不仅仅是一个技术规范，更是推动整个 AI 代理生态系统向更开放、更互联互通方向发展的基石。

2.3. 任务分配策略

任务分配是将整体目标分解后的子任务有效地分配给系统中合适的代理执行的过程。虽然 ADK 本身不直接规定特定的高级任务分配算法，但其灵活性允许开发者实现多种策略：

• 协调器/调度器模式 (Coordinator/Dispatcher Pattern): 这是 ADK 中最自然的模式之一。一个中心 LlmAgent 或自定义的协调器代理可以根据其内部逻辑、当前状态或 LLM 的推理能力，决定将任务分配给哪个子代理或工具。

• 合约网协议 (Contract Net Protocol, CNP): CNP 是一种经典的去中心化任务分配协议。管理者（Manager）广播任务公告，承包者（Contractor）根据自身能力和意愿进行投标，管理者选择最优投标者并授予合约。任务完成后，承包者通知管理者。虽然 ADK 没有内置 CNP，但可以通过自定义代理间的消息传递和协商逻辑来模拟实现，尤其是在结合 A2A 协议与外部代理交互时，CNP 的思想具有借鉴意义。

• 基于拍卖的机制 (Auction-based Mechanisms): 与 CNP 类似，拍卖机制也常用于多代理或多机器人系统中的任务分配。代理对任务进行出价（基于成本、效用等），拍卖行（可以是中心化的代理）根据预设规则（如最低成本、最高收益）将任务分配给中标者。这种机制适用于资源竞争和动态分配的场景。

• 分布式约束优化 (Distributed Constraint Optimization, DCOP): DCOP 提供了一个形式化的框架，其中多个代理协同选择各自的变量值，以最小化依赖于这些变量值的全局约束成本总和。这适用于需要满足复杂约束并寻求全局最优解的协调问题。

在 ADK 中，开发者可以利用其提供的 LlmAgent 的推理能力、WorkflowAgent 的结构化流程控制，以及自定义代理逻辑，结合上述策略的思想，设计出适合特定应用场景的任务分配机制。例如，一个 LlmAgent 协调器可以评估子代理（通过 AgentTool 描述）的能力，并根据任务需求动态选择最合适的子代理执行。

3. 子任务委派与结果整合

在多代理系统中，一个核心的运作模式是将复杂任务分解为更小的子任务，委派给专门的代理处理，然后将这些子任务的结果整合成最终的解决方案。ADK 为此提供了强大的支持。

3.1. ADK 中的任务委派

任务委派是指一个代理（通常是父代理或协调器代理）将特定的工作单元交给另一个代理（子代理或工作代理）来完成。

• 基于层级结构的委派: ADK 的父子代理层级结构天然支持任务委派。父代理可以通过其内部逻辑（例如，在自定义 BaseAgent 中）或通过 LLM 的决策（在 LlmAgent 中）来调用其子代理执行特定任务。子代理的描述（description 字段）对于父 LlmAgent 理解其能力并进行有效委派至关重要。

• 通过 AgentTool 的 LLM 驱动委派: 如前所述，将一个代理（例如，一个专门负责数据查询的 data_query_agent）包装成 AgentTool 后，父 LlmAgent 可以像调用普通函数工具一样调用它。父 LlmAgent 的提示或指令可以引导 LLM 在适当的时候选择并调用这个 AgentTool，从而将特定的子任务（如数据查询）委派给 data_query_agent。例如，在 travel-concierge 示例的 booking_agent 中，create_reservation、payment_choice 和 process_payment 等子功能被实现为独立的 Agent，并通过 AgentTool 整合到 booking_agent 的工具列表中，由 booking_agent 的 LLM 驱动委派。

• 通过 WorkflowAgent 的结构化委派: SequentialAgent、ParallelAgent 和 LoopAgent 等工作流代理，通过其预定义的流程逻辑，自动地将其管理的子任务“委派”给其包含的子代理们按序、并行或循环执行。这种委派是结构化的，由工作流代理的类型和配置决定。

3.2. 结果整合机制

子任务执行完毕后，其结果需要被有效地收集和整合，以形成对原始任务的完整响应或推动下一阶段的工作。

• SequentialAgent 中的结果传递与整合: 在顺序工作流中，一个子代理的输出（通过 output_key 保存到状态中）可以被后续子代理用作输入。最终，最后一个子代理的输出，或者在工作流中某个 LlmAgent 综合了之前步骤的结果后产生的输出，可以作为整个顺序任务的结果。

• ParallelAgent 中的结果汇聚: ParallelAgent 在其所有子代理并行执行完毕后，会将各个子代理的结果收集起来。这些结果通常会以结构化的方式（例如，一个字典，键为子代理名称或输出键，值为其结果）存储在状态中。父代理或后续代理可以访问这些汇聚后的结果进行进一步处理或整合。

• LlmAgent (作为协调器) 的结果综合: 当一个 LlmAgent 通过 AgentTool 调用了其他代理后，它会接收到这些工具调用的返回结果。LlmAgent 的核心 LLM 可以根据其指令和接收到的多个子结果，进行推理、总结、比较或转换，从而生成一个综合的、更高层次的响应。这是实现复杂结果整合的关键，因为它允许灵活地处理和融合来自不同专业代理的信息。

• 自定义 BaseAgent 中的结果整合逻辑: 对于需要特定复杂整合逻辑的场景，开发者可以创建自定义的 BaseAgent。该代理在其 execute_async 方法中，可以编排对其他代理的调用（可能是通过 Runner 直接运行，或者如果它们是子代理，则通过内部机制），收集它们的响应，然后应用自定义的算法或规则来整合这些结果。

有效的子任务委派和结果整合机制是多代理系统实现“1+1>2”的关键。ADK 提供的这些机制，使得开发者可以根据具体需求，灵活地设计代理间的协作模式和信息流。

4. 实例：构建团队协作型项目管理代理

为了更具体地展示 ADK 在多代理系统设计中的应用，本节将通过一个构建团队协作型项目管理代理的实例，逐步演示其设计与实现过程。这个项目管理代理将模拟一个小型团队协作管理软件开发项目的基本流程。

4.1. 项目需求与代理团队设计

项目目标: 模拟一个项目管理代理系统，该系统能够接收用户提出的项目目标（例如，“开发一个新的客户关系管理 (CRM) 系统”），然后：

1. 将项目目标分解为若干高级任务。

1. （模拟地）将这些任务分配给团队成员。

1. （模拟地）跟踪任务进展并生成项目状态摘要。

代理团队设计:

我们将设计一个由多个专业代理组成的团队，由一个总协调代理来指挥：

• ProjectCoordinatorAgent (项目协调代理):

• 类型: LlmAgent

• 职责: 作为主协调器，接收用户输入的项目目标， orchestrate 整个项目管理流程，包括调用其他专业代理，并最终向用户汇报。

• TaskDefinitionAgent (任务定义代理):

• 类型: LlmAgent

• 职责: 接收项目目标，将其分解为一系列可操作的高级任务。

• TaskAssignmentAgent (任务分配代理):

• 类型: LlmAgent (为简化起见，也可以是 CustomAgent)

• 职责: 接收任务列表，（模拟地）将任务分配给预设的团队成员。

• ProgressTrackingAgent (进度跟踪代理):

• 类型: LlmAgent (为简化起见)

• 职责: 接收（模拟的）任务进展更新，生成项目状态摘要。

协作流程:

1. 用户向 ProjectCoordinatorAgent 提供项目目标。

1. ProjectCoordinatorAgent 调用 TaskDefinitionAgent (作为工具) 来获取任务列表。

1. ProjectCoordinatorAgent 接收任务列表，然后调用 TaskAssignmentAgent (作为工具) 来分配任务。

1. ProjectCoordinatorAgent 接收分配确认，（模拟一段时间的任务执行），然后调用 ProgressTrackingAgent (作为工具)，并提供一些模拟的进展数据。

1. ProjectCoordinatorAgent 接收项目摘要，并将其作为最终结果呈现给用户。

这种设计利用了 ADK 的层级委派能力，其中 ProjectCoordinatorAgent 处于顶层，其他专业代理作为其可调用的工具（通过 AgentTool 封装）存在。

4.2. 核心代理实现 (Python ADK)

以下是使用 Python ADK 实现上述代理的代码示例。

项目结构:

.env 文件示例 (用于 API 密钥):

task_definition_agent.py:

"""
任务定义代理模块
本模块包含任务定义代理，负责将项目目标分解为具体的、可执行的任务
该代理专门用于项目规划和任务分解
"""


from google.adk.agents import LlmAgent
import os
from google.adk.models.lite_llm import LiteLlm


# API密钥配置
DEFAULT_DASHSCOPE_API_KEY = "sk-f227634*******************f38d77c"  # 请替换为您的实际密钥
DASHSCOPE_API_KEY = os.environ.get("DASHSCOPE_API_KEY", DEFAULT_DASHSCOPE_API_KEY)


# 任务定义代理 - 专门负责项目任务分解
# 该代理接收项目目标，将其分解为3-5个高层次的可执行任务
task_definition_agent = LlmAgent(
    name="TaskDefinitionAgent",  # 代理名称：任务定义代理
    model=LiteLlm(
                model="openai/qwen-turbo",  # 使用通义千问Turbo模型
                api_key=DASHSCOPE_API_KEY,
                api_base="https://dashscope.aliyuncs.com/compatible-mode/v1"
    ),
    instruction="""
    You are an expert project planner. When given a project goal, break it down into 3-5 high-level, actionable tasks.
    
    Always return the tasks as a clear JSON list of strings. For example:
    
    Input: "Develop a mobile weather application."
    Output: ["Research weather APIs", "Design user interface", "Implement weather data fetching", "Create location services", "Test and deploy application"]


    Focus on creating practical, achievable tasks that can be assigned to team members.
    Be specific but not overly detailed - these should be high-level milestones.
    
    Provide only the JSON list of tasks as your response.
    """,
    description="Breaks down a project goal into actionable tasks."  # 代理描述：将项目目标分解为可执行任务
)

Python

task_assignment_agent.py:

"""
任务分配代理模块
本模块包含任务分配代理，负责将定义好的任务分配给合适的团队成员
该代理基于团队成员的专业技能进行智能任务分配
"""


from google.adk.agents import LlmAgent
import os
from google.adk.models.lite_llm import LiteLlm


# API密钥配置
DEFAULT_DASHSCOPE_API_KEY = "sk-f227634*******************f38d77c"  # 请替换为您的实际密钥
DASHSCOPE_API_KEY = os.environ.get("DASHSCOPE_API_KEY", DEFAULT_DASHSCOPE_API_KEY)


# 任务分配代理 - 专门负责任务分配
# 该代理维护预定义的团队结构，并根据成员专长分配任务
# 团队成员包括：Alice(后端负责人)、Bob(前端开发)、Charlie(QA工程师)
task_assignment_agent = LlmAgent(
    name="TaskAssignmentAgent",  # 代理名称：任务分配代理
    model=LiteLlm(
                model="openai/qwen-turbo",  # 使用通义千问Turbo模型
                api_key=DASHSCOPE_API_KEY,
                api_base="https://dashscope.aliyuncs.com/compatible-mode/v1"
    ),
    instruction="""
    You are a task assignment specialist. You work with a predefined team: 
    - Alice (Backend Lead)
    - Bob (Frontend Developer) 
    - Charlie (QA Engineer)
    
    When given a list of tasks, assign each task to the most appropriate team member based on their expertise.
    
    Always return the assignments as a clear JSON object where keys are tasks and values are assigned team members.
    
    For example:
    Input: ["Design database schema", "Implement user interface", "Write test cases"]
    Output: {"Design database schema": "Alice", "Implement user interface": "Bob", "Write test cases": "Charlie"}


    Consider each team member's specialty:
    - Alice: Database design, backend architecture, API development
    - Bob: User interface, frontend frameworks, user experience
    - Charlie: Testing strategies, quality assurance, bug tracking
    
    Provide only the JSON object with assignments as your response.
    """,
    description="Assigns defined tasks to simulated team members based on their expertise."  # 代理描述：基于专业技能将任务分配给团队成员
)

Python

progress_tracking_agent.py:

"""
进度跟踪代理模块
本模块包含进度跟踪代理，负责生成综合的项目进度报告和状态摘要
该代理专门用于项目状态监控和进度分析
"""


from google.adk.agents import LlmAgent
import os
from google.adk.models.lite_llm import LiteLlm


# API密钥配置
DEFAULT_DASHSCOPE_API_KEY = "sk-f227634*******************f38d77c"  # 请替换为您的实际密钥
DASHSCOPE_API_KEY = os.environ.get("DASHSCOPE_API_KEY", DEFAULT_DASHSCOPE_API_KEY)


# 进度跟踪代理 - 专门负责项目进度监控和报告生成
# 该代理生成包含项目状态、任务进度、潜在问题和下一步行动的综合报告
progress_tracking_agent = LlmAgent(
    name="ProgressTrackingAgent",  # 代理名称：进度跟踪代理
    model=LiteLlm(
                model="openai/qwen-turbo",  # 使用通义千问Turbo模型
                api_key=DASHSCOPE_API_KEY,
                api_base="https://dashscope.aliyuncs.com/compatible-mode/v1"
    ),
    instruction="""
    You are a progress tracking specialist. When asked to provide a project summary, 
    generate a realistic progress report for the project tasks.
    
    Your report should include:
    1. Overall project status
    2. Individual task progress (with realistic percentage completion)
    3. Any potential blockers or challenges
    4. Next steps and timeline
    5. Team performance insights
    
    Format your response as a comprehensive but concise project status report.
    
    For simulation purposes, assume tasks are in various stages of completion:
    - Some tasks may be 60-80% complete
    - Others may be just starting (10-20% complete)  
    - Include realistic challenges teams might face
    
    Always provide a professional, informative summary that a project manager would find useful.
    """,
    description="Generates comprehensive project progress reports and status summaries."  # 代理描述：生成综合的项目进度报告和状态摘要
)

Python

agent.py:

"""
多智能体项目管理系统 - 主代理模块
本模块定义了项目协调代理(root_agent)，负责协调整个项目管理生命周期
"""

import os
from google.adk.agents import LlmAgent
from google.adk.tools.agent_tool import AgentTool
from google.adk.models.lite_llm import LiteLlm
from .task_definition_agent import task_definition_agent  # 导入任务定义代理
from .task_assignment_agent import task_assignment_agent  # 导入任务分配代理
from .progress_tracking_agent import progress_tracking_agent  # 导入进度跟踪代理


# 创建工具列表，将子智能体包装为工具
# 任务定义工具 - 负责将项目目标分解为具体任务
task_definition_tool = AgentTool(agent=task_definition_agent)

# 任务分配工具 - 负责将任务分配给合适的团队成员
task_assignment_tool = AgentTool(agent=task_assignment_agent)

# 进度跟踪工具 - 负责生成项目进度报告和状态摘要
progress_tracking_tool = AgentTool(agent=progress_tracking_agent)

# API密钥配置
DEFAULT_DASHSCOPE_API_KEY = "sk-f227634*******************f38d77c"  # 请替换为您的实际密钥
DASHSCOPE_API_KEY = os.environ.get("DASHSCOPE_API_KEY", DEFAULT_DASHSCOPE_API_KEY)

# 根据ADK文档要求，定义root_agent（项目协调代理）
# 这是整个系统的核心代理，负责协调其他专门的子代理
root_agent = LlmAgent(
    name="ProjectCoordinatorAgent",  # 代理名称：项目协调代理
    model=LiteLlm(
                model="openai/qwen-turbo",  # 使用通义千问Turbo模型
                api_key=DASHSCOPE_API_KEY,
                api_base="https://dashscope.aliyuncs.com/compatible-mode/v1"
    ),
    instruction="""
    You are a Project Coordinator. Your goal is to manage a project based on the user's input project goal.
    Follow these steps meticulously:
    1. Acknowledge the user's project goal.
    2. Use the 'TaskDefinitionAgent' tool to break down the project goal into specific tasks. The user's original goal should be passed as 'user_input' to this tool.
    3. Present the defined tasks to the user.
    4. Use the 'TaskAssignmentAgent' tool to assign these defined tasks. The output from 'TaskDefinitionAgent' (the list of tasks) should be passed as 'tasks_to_assign' to this tool.
    5. Inform the user about the (simulated) task assignments.
    6. Simulate some time passing and tasks being worked on. Provide a placeholder update like "Team is now working on the assigned tasks. Progress will be updated shortly."
    7. Use the 'ProgressTrackingAgent' tool to generate a project summary. For simulation, provide it with a generic update string like "Task 1 (from the defined list) is 60% complete, Task 2 is 30% complete, other tasks are starting." This update should be passed as 'simulated_updates' to the tool.
    8. Present the final project summary to the user.

    The user's initial message will contain the project goal.
    Ensure your responses are clear, follow the steps, and explicitly mention when you are using a tool and what its output is.
    """,
    tools=[task_definition_tool, task_assignment_tool, progress_tracking_tool],  # 配置可用的工具列表
    description="Coordinates the entire project management lifecycle from goal to status reporting using specialized sub-agents."  # 代理描述
) 

Python

__init__.py

"""
多智能体项目管理系统包
本包实现了一个基于多智能体架构的项目管理系统，包含以下组件：
- 项目协调代理 (root_agent)：整个系统的核心协调者
- 任务定义代理：负责项目目标分解
- 任务分配代理：负责任务分配给团队成员
- 进度跟踪代理：负责项目进度监控和报告生成
"""


from . import agent  # 导入主代理模块

在上述 agent.py 中，instruction 字段详细指导了协调代理如何一步步调用其他专业代理（作为工具）。当协调代理的 LLM 决定调用某个工具时，它需要知道如何将当前对话或状态中的信息映射到该工具期望的输入参数。例如，TaskDefinitionAgent 工具期望一个名为 user_input 的参数，协调代理的指令中明确了将用户的原始目标作为这个输入。同样，TaskAssignmentAgent 期望 tasks_to_assign，协调代理的指令指导它使用 TaskDefinitionAgent 的输出来填充这个参数。这种通过 LLM 的自然语言理解和遵循指令来编排工具调用和数据流转的方式，是 LlmAgent 作为协调器的核心能力。

使用 adk web 进行交互式测试:可以在项目根目录运行 adk web。然后在浏览器中打开 http://localhost:8000，选择09muti_agent，并通过聊天界面输入项目目标进行交互。这将提供一个可视化的界面来观察代理的响应和工具调用。

这个项目管理代理的实例虽然经过简化，但清晰地展示了 ADK 如何通过 LlmAgent 作为协调器，并利用 AgentTool 封装和调用专业子代理，来实现分层任务委派和结果整合。一个真实世界的项目管理系统无疑会更加复杂，需要更精细的状态管理（例如，使用数据库来持久化任务、截止日期、分配情况和进展），更复杂的团队成员代理（可能作为独立的、可通过 A2A 协议交互的服务存在），以及更强大的错误处理、依赖管理和动态重规划能力。然而，此示例已为理解 ADK 在构建此类协作型多代理系统中的核心机制提供了坚实的基础。这种将复杂问题分解给专业代理，再由协调代理进行编排的模式，是构建可扩展、可维护的智能系统的有效途径。

5. 结论与展望

本文深入探讨了使用 Google Agent Development Kit (ADK) 进行多代理系统（MAS）设计的关键方面，从协作架构模式、代理间通信机制、任务分配策略，到子任务委派与结果整合的具体实现。通过构建一个团队协作型项目管理代理的实例，我们展示了 ADK 如何支持这些复杂系统的开发。

ADK 的核心优势在于其模块化设计和灵活的组合能力。BaseAgent 的层级结构为任务分解和委派提供了自然的基础。LlmAgent 凭借其强大的自然语言理解和推理能力，可以作为动态的协调器，智能地编排子代理或工具的执行。而 AgentTool 机制则优雅地将其他代理封装为可供 LlmAgent 调用的工具，实现了清晰的职责分离和内部任务委派。对于结构化流程，WorkflowAgent（如 SequentialAgent 和 ParallelAgent）提供了可预测的控制流管理。

当多代理系统的边界扩展到不同框架或组织时，Agent2Agent (A2A) 协议的重要性便凸显出来。A2A 通过标准化的 Agent Card 进行能力发现，并采用 JSON-RPC 和 SSE 等成熟技术进行任务交换，为构建真正开放和互操作的代理生态系统铺平了道路 8。这使得 ADK 构建的代理不仅能在其内部高效协作，还能与外部世界广泛连接。

项目管理代理的实例虽然简化，但它揭示了构建此类系统的普遍模式：一个中心协调者（ProjectCoordinatorAgent）负责理解总体目标，并将专业化的子任务（定义、分配、跟踪）委派给专门的子代理。这种分而治之的策略是应对复杂性的有效手段。然而，将此类原型发展为生产级应用，还需要考虑更多因素，例如：

• 持久化状态管理: 真实项目信息（任务、依赖、截止日期、负责人、评论等）需要存储在数据库中，而非仅仅依赖 ADK 的会话状态 。

• 与外部系统和人工的集成: 真正的项目管理往往涉及与 Jira、代码仓库、日历等外部工具的集成，以及与人类团队成员的交互。A2A 协议和 Model Context Protocol (MCP) 为这类集成提供了标准接口。

• 更复杂的交互逻辑: 实际项目管理充满动态变化，需要代理具备处理异常、管理任务依赖、资源冲突解决和动态重规划的能力。

• 评估与测试: ADK 提供了评估框架，对于验证 MAS 的行为正确性和性能至关重要。

多代理系统的开发是一个迭代演进的过程。ADK 的模块化特性非常适合这种方式：开发者可以从一个简单的协调代理和几个基础的专业代理开始，逐步增加功能复杂度，引入更精细的子代理，并采用如 A2A 这样的高级通信模式来扩展系统边界。这种由简入繁的构建方法，使得开发者能够更好地控制开发节奏，并随着对问题域理解的加深而不断优化系统设计。

展望未来，ADK 与 A2A、MCP 等开放标准的结合，预示着一个由众多可互操作、专业化代理组件构成的广阔生态系统。开发者将能够像组装精密仪器一样，从这个生态中挑选或贡献代理模块，快速构建出功能强大、适应性强的 AI 应用。这将极大地推动 AI 技术的普及和创新，使更复杂的智能协作成为可能。要充分利用这一趋势，持续学习 ADK 的高级特性、关注社区的最佳实践，并积极探索将代理部署到生产环境，将是开发者不断提升的关键。