以下 Specialist 能力集、任务与消息序列均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。search_agent/code_agent 的能力是讲解用的模型,真实系统以 A2A 官方规范与双方协商为准,但"能力不匹配要显式拒绝"这一条不变。
6.1 讲了 Agent 调工具(MCP,人与工具)。这一节讲 Agent 调 Agent(A2A,Agent to Agent)。工具调用是"Agent 请求系统做事",Agent 协作是"一个 Agent 请求另一个 Agent 做事"——后者多了一层语义:另一个 Agent 也有自己的状态、能力和失败模式。
A2A 把协作变成协议化的消息流:委派(assign)→ 执行 → 回传(result),任务状态在消息之间推进。核心不变量是:能力不匹配的委派要被显式拒绝,而不是静默失败。
委派流与任务状态
一次委派是三条消息,任务状态随消息推进:
| 阶段 | 消息 | 状态 |
|---|---|---|
| 委派 | assign(from 编排者,to 专家) | PENDING → RUNNING |
| 执行 | (专家内部) | RUNNING |
| 回传 | result(from 专家) | RUNNING → COMPLETED |
被拒绝时状态不同:
| 阶段 | 消息 | 状态 |
|---|---|---|
| 委派失败 | reject(no specialist) | PENDING → FAILED |
任务状态在消息之间推进的意思是:没有消息,状态就不变。编排者派任务给专家,专家执行后回传 result,双方靠同一套状态表对齐——编排者不需要知道专家内部怎么跑,只需要从消息读到状态变化。
为什么能力不匹配要显式拒绝
委派前要判断"这个 Agent 会不会干这个活"。两种做法:
| 做法 | 表现 | 问题 |
|---|---|---|
| 显式拒绝 | 返回 reject,说明原因 | 无;编排者知道要换人 |
| 静默失败 | 接了任务,执行时才报错 | 任务状态失控,编排者不知找谁 |
静默失败是最差的选择。 专家接下一个自己不会的任务,等到执行才失败,任务状态不明不白地挂起。显式拒绝在委派阶段就把"没人会干"说清楚,编排者可以立刻换 Specialist 或改方案——拒绝不是失败,是早期定位。
最小实验:委派流
实验实现 Specialist 能力匹配、assign/result/reject 消息与任务状态推进。
# file: agp_lab/a2a_protocol.py | write
# tier: 3
# verify: python3 -m unittest tests.test_a2a_protocol
"""A2A:Agent 间协作协议与任务委派。
A2A 把"一个 Agent 请另一个 Agent 干活"变成协议化的消息流:
委派(assign)→ 执行 → 回传(result),任务状态在消息之间推进。
能力不匹配的委派会被拒绝,而不是静默失败。
本模块实现最小 A2A 消息流与任务状态机,
演示一次成功的委派和一次被拒绝的委派。
"""
from __future__ import annotations
from dataclasses import dataclass
from enum import Enum
from typing import Any
class TaskState(str, Enum):
PENDING = "PENDING"
RUNNING = "RUNNING"
COMPLETED = "COMPLETED"
FAILED = "FAILED"
@dataclass(frozen=True)
class Task:
id: str
capability: str
payload: dict[str, Any]
@dataclass(frozen=True)
class Specialist:
name: str
capabilities: frozenset[str]
def assign_task(
task: Task, orchestrator: str, specialists: list[Specialist]
) -> dict[str, Any]:
"""把任务委派给有能力执行者;无匹配则拒绝。"""
for specialist in specialists:
if task.capability in specialist.capabilities:
return {
"kind": "assign",
"from": orchestrator,
"to": specialist.name,
"task_id": task.id,
}
return {
"kind": "reject",
"from": orchestrator,
"task_id": task.id,
"reason": "no specialist",
}
def process_assignment(task: Task, specialist: Specialist) -> dict[str, Any]:
"""专家执行任务并回传结果消息。"""
return {
"kind": "result",
"from": specialist.name,
"task_id": task.id,
"result": f"done:{task.capability}",
}
def delegation_flow(
task: Task, orchestrator: str, specialists: list[Specialist]
) -> tuple[dict[str, TaskState], list[dict[str, Any]]]:
"""完整委派流,返回(任务状态表, 消息序列)。"""
states = {task.id: TaskState.PENDING}
first = assign_task(task, orchestrator, specialists)
if first["kind"] == "reject":
states[task.id] = TaskState.FAILED
return states, [first]
states[task.id] = TaskState.RUNNING
recipient = next(specialist for specialist in specialists if specialist.name == first["to"])
result = process_assignment(task, recipient)
states[task.id] = TaskState.COMPLETED
return states, [first, result]
def demo() -> dict[str, Any]:
specialists = [
Specialist("search_agent", frozenset({"web_search", "page_fetch"})),
Specialist("code_agent", frozenset({"read_repo", "patch_file"})),
]
ok_states, ok_messages = delegation_flow(
Task("t1", "web_search", {"query": "KV cache"}),
"orchestrator",
specialists,
)
bad_states, bad_messages = delegation_flow(
Task("t2", "db_query", {"sql": "SELECT 1"}),
"orchestrator",
specialists,
)
return {
"ok_states": {k: v.value for k, v in ok_states.items()},
"ok_messages": ok_messages,
"bad_states": {k: v.value for k, v in bad_states.items()},
"bad_messages": bad_messages,
}
if __name__ == "__main__":
for key, value in demo().items():
print(f"{key}: {value}")
运行:
cd private/labs/agp-lab
python3 -m agp_lab.a2a_protocol
输出:
ok_states: {'t1': 'COMPLETED'}
ok_messages: [{'kind': 'assign', 'from': 'orchestrator', 'to': 'search_agent', 'task_id': 't1'}, {'kind': 'result', 'from': 'search_agent', 'task_id': 't1', 'result': 'done:web_search'}]
bad_states: {'t2': 'FAILED'}
bad_messages: [{'kind': 'reject', 'from': 'orchestrator', 'task_id': 't2', 'reason': 'no specialist'}]
四行输出对应一成一败两条委派流:
- ok_states={’t1’: ‘COMPLETED’}:任务 t1(web_search)被委派给 search_agent,状态推进到 COMPLETED。
- ok_messages:两条消息——
assign(orchestrator 派给 search_agent,task_id=t1)和result(search_agent 回传,result=done:web_search)。结果消息把"做了什么、结果是什么"带回来,编排者不需要轮询专家内部状态。 - bad_states={’t2’: ‘FAILED’}:任务 t2(db_query)没有任何 Specialist 匹配,状态是 FAILED。
- bad_messages:只有一条
reject,reason=‘no specialist’。拒绝发生在委派阶段,不是执行阶段——编排者立刻知道"没人会数据库查询",可以改方案或加 Specialist。
两个值得点破的细节:
- 结果消息携带结果,而不是让编排者去查。 A2A 的关键是消息驱动:专家做完把 result 回传,编排者从消息里读到"完成"与"结果"。没有这条消息,编排者只能轮询专家,退化成同步调用。
- FAILED 来自 reject,不是来自专家执行。 t2 的状态 FAILED 是在委派阶段由 reject 消息触发的——这正体现"显式拒绝"的价值:失败原因(no specialist)在委派时就知道,不用等执行。
A2A 的另一个设计点是任务可以没有显式的接收者。委派消息(assign)里只有能力要求,没有写死哪个 Agent 接单;由能力匹配(Specialist 的 capabilities)决定谁接收。这让新增 Agent 变成"注册能力"而不是"改编排器"——来了一个新 Agent,只要它声明能力,编排器自动就能派单给它。
A2A 与 MCP 的边界在于"对谁说话"。 MCP 让 Agent 与工具对话,工具是无状态的执行者;A2A 让 Agent 与 Agent 对话,对方是有状态、有能力集合、会拒绝的参与者。一套系统里两者并存很常见:编排者用 MCP 调自己的工具,用 A2A 委派给别的 Agent;被委派的 Agent 内部又用 MCP 调自己的工具。边界不用混:工具是你自己的手,Agent 是你的同事。
| 协议 | 对话对象 | 对方特征 |
|---|---|---|
| MCP | 工具 | 无状态执行者 |
| A2A | Agent | 有状态、会拒绝 |
| AG-UI | 用户 | 有意图、要反馈 |
A2A 消息的交付保证也与 MCP 不同。工具调用通常同步等待结果;A2A 委派是异步的——任务状态在消息之间推进(见 6.2 状态表),编排者不能假定"发完 assign 就有 result"。异步意味着双方都要处理"消息丢失":assign 丢了任务没开始、result 丢了编排者以为任务挂起。A2A 要有与 AG-UI 一致的重试与超时语义(见 6.3 的投递语义),不能靠同步假定。
| 消息 | 丢失后果 | 应对 |
|---|---|---|
| assign | 任务未开始 | 编排者重发/超时 |
| result | 任务状态挂起 | 状态查询/超时判定 |
| reject | 委派无响应 | 超时后换人 |
架构判据
A2A 协作是否合格,用五条判据检查:
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 能力匹配 | 委派前按能力选专家 | 随机或总是派给第一个 |
| 显式拒绝 | 无匹配时返回 reject + 原因 | 接任务后静默失败 |
| 消息驱动 | 结果经消息回传 | 编排者轮询专家状态 |
| 状态一致 | 双方按同一状态表推进 | 双方状态口径不一 |
| 失败可定位 | 拒绝/失败原因明确 | 任务挂起,原因不明 |
判据第三条"消息驱动"是 A2A 与直接函数调用的分界:协作是消息流,不是远程调用。 判据第二条"显式拒绝"是协作健康度的底线:能力不匹配要在委派阶段说出来。
小结
- A2A 把 Agent 协作变成协议化的消息流:委派→执行→回传,任务状态在消息之间推进。
- 能力不匹配的委派要显式拒绝(reject + 原因),而不是静默失败。
- 结果经消息回传,编排者不需要轮询专家内部状态。
- 任务状态靠双方同一套状态表对齐;拒绝发生在委派阶段而非执行阶段。
阅读导航:上一节:6.1 Function Calling 与 MCP · 下一节:6.3 AG-UI/事件协议与版本兼容 。
常见错误与边界
- 能力不匹配还接任务。 接了不会干的活,等到执行才失败;委派阶段就要显式拒绝。
- 编排者轮询专家。 结果要经消息回传;轮询退化成同步调用,违背 A2A 消息驱动。
- 双方状态口径不一。 编排者一套状态、专家一套,任务状态对不上;要同一套状态表。
- 拒绝原因不明。 reject 要带 reason(no specialist),否则编排者不知该换人还是改方案。
- 把 A2A 当远程调用。 协作是消息流不是同步函数调用;异步、状态推进、消息回传是它的本性。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。