《AI Agent 技术原理与架构·运行时、协议与系统架构》6.2 A2A:Agent 间协作协议

一个 Agent 请另一个 Agent 干活,不是代码里直接调函数,而是协议化的消息流:委派→执行→回传。实验实现最小 A2A 消息流与任务状态机,演示一次成功的委派和一次被拒绝的委派。结论是能力不匹配的委派要显式拒绝而不是静默失败,任务状态在消息之间推进,双方按同一套状态表对齐。

以下 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'}]

四行输出对应一成一败两条委派流:

  1. ok_states={’t1’: ‘COMPLETED’}:任务 t1(web_search)被委派给 search_agent,状态推进到 COMPLETED。
  2. ok_messages:两条消息——assign(orchestrator 派给 search_agent,task_id=t1)和 result(search_agent 回传,result=done:web_search)。结果消息把"做了什么、结果是什么"带回来,编排者不需要轮询专家内部状态。
  3. bad_states={’t2’: ‘FAILED’}:任务 t2(db_query)没有任何 Specialist 匹配,状态是 FAILED。
  4. 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工具无状态执行者
A2AAgent有状态、会拒绝
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/事件协议与版本兼容 。

常见错误与边界

  1. 能力不匹配还接任务。 接了不会干的活,等到执行才失败;委派阶段就要显式拒绝。
  2. 编排者轮询专家。 结果要经消息回传;轮询退化成同步调用,违背 A2A 消息驱动。
  3. 双方状态口径不一。 编排者一套状态、专家一套,任务状态对不上;要同一套状态表。
  4. 拒绝原因不明。 reject 要带 reason(no specialist),否则编排者不知该换人还是改方案。
  5. 把 A2A 当远程调用。 协作是消息流不是同步函数调用;异步、状态推进、消息回传是它的本性。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图