AI Agent / 系统课时

Agent 间通信与任务分配

Agent 间通信与任务分配

多 Agent 系统真正难的往往不是“让 Agent 说话”,而是保证消息有明确任务、接收者、状态和重试边界。本篇从消息契约、任务分配和完成确认三个环节搭建一条最小通信链,并用可运行代码演示按能力选择 Worker。

学习目标

  • 设计可追踪的 Agent 消息结构与任务状态
  • 根据 Agent 能力进行确定性任务分配
  • 处理失败、超时和重复执行等通信边界

先定义消息契约

Agent 之间不要只传一段自然语言。至少应携带任务 ID、消息类型、发送方、接收方、负载和状态,这样才能回答“这条消息属于哪个任务”“谁应该处理”“是否已经完成”。

一个最小任务消息可以包含:

  • task_id:贯穿整个任务生命周期的唯一标识
  • sender 与 recipient:明确责任归属
  • kind:区分任务、结果、错误等消息
  • payload:真正交给 Agent 的输入
  • required:调度所需的全部能力
  • attempt:记录当前是第几次尝试。Worker 返回结果时回传任务 ID 和尝试号

Agent 通信与任务分配闭环

用能力表做确定性分配

任务分配可以先从确定性规则开始,而不是让 LLM 每次自由选择。为每个 Agent 注册能力集合,调度器只把任务交给覆盖所需能力的 Worker。这样更容易测试,也能在模型不可用时保持稳定行为。

下面定义任务消息、结果消息和 Worker 注册表。匹配多个 Worker 时按注册顺序取第一个。示例在同一 Python 进程内运行,实际服务要由消息通道验证发送方身份,并在消费侧再次验证其操作权限。

python
from dataclasses import dataclass
from typing import Callable


@dataclass(frozen=True)
class TaskMessage:
    task_id: str
    sender: str
    recipient: str
    kind: str
    payload: str
    required: frozenset[str]
    attempt: int


@dataclass(frozen=True)
class Result:
    task_id: str
    sender: str
    recipient: str
    attempt: int
    text: str


@dataclass(frozen=True)
class Worker:
    capabilities: frozenset[str]
    handler: Callable[[str], str]


def researcher(task: str) -> str:
    return f"已完成检索:{task}"


def coder(task: str) -> str:
    return f"已完成编码:{task}"


workers = {
    "researcher": Worker(frozenset({"search", "summarize"}), researcher),
    "coder": Worker(frozenset({"python", "debug"}), coder),
}


def assign(task_id, required, payload, attempt=1):
    if not required or attempt < 1:
        raise ValueError("invalid capabilities or attempt")
    for name, worker in workers.items():
        if required <= worker.capabilities:
            return TaskMessage(
                task_id, "dispatcher", name, "task", payload, required, attempt
            )
    raise ValueError("no worker supports all required capabilities")


def execute(message: TaskMessage) -> Result:
    worker = workers.get(message.recipient)
    if (
        message.kind != "task" or message.sender != "dispatcher"
        or message.attempt < 1 or not message.required or worker is None
        or not message.required <= worker.capabilities
    ):
        raise ValueError("invalid task message")
    return Result(
        message.task_id, message.recipient, message.sender,
        message.attempt, worker.handler(message.payload),
    )


def accept(active: TaskMessage, result: Result, completed: set[str]) -> bool:
    expected = (active.task_id, active.recipient, active.sender, active.attempt)
    actual = (result.task_id, result.sender, result.recipient, result.attempt)
    if actual != expected or active.task_id in completed:
        return False
    completed.add(active.task_id)
    return True


if __name__ == "__main__":
    required = frozenset({"python", "debug"})
    first = assign("task-001", required, "实现指数退避函数")
    active = assign("task-001", required, first.payload, attempt=2)
    completed = set()
    late = execute(first)
    result = execute(active)
    print(f"分配给 {active.recipient},尝试 {active.attempt}")
    print("接收迟到结果:", accept(active, late, completed))
    print("接收当前结果:", accept(active, result, completed), result.text)
    print("接收重复结果:", accept(active, result, completed))

预期输出

text
分配给 coder,尝试 2
接收迟到结果: False
接收当前结果: True 已完成编码:实现指数退避函数
接收重复结果: False

这里的调度结果由能力表决定,因此“为什么分给 coder”可以直接解释。复杂系统可以再增加负载、优先级、成本或历史成功率,但这些指标仍应进入显式评分逻辑,而不是藏在不可观察的自由对话里。

给通信增加完成确认

发送任务后,调度器跟踪 queued、running、succeeded 和 failed 等状态。只接收与当前在途任务和尝试号匹配的结果。示例的集合只适合同步演示。真实应用中,需要在同一持久化事务里验证当前状态和尝试号、记录结果并更新状态,提交后再确认队列消息。否则两个消费者可能同时把同一任务判为首次完成。

处理超时与重试边界

临时网络故障或限流可在预算内退避重试。参数错误、权限不足等错误需要修正后再提交。每次重试增加 attempt,并限制尝试次数及总时长。若超时后无法确认有副作用的操作是否成功,先记录结果未知,再核对外部状态或走幂等重试。

当一个任务超过最大尝试次数时,最好把它转入失败队列或人工处理,而不是继续在 Agent 之间转发。可靠的多 Agent 通信不是让消息流动得更自由,而是让每一次分配、执行、确认和失败都有可追踪的责任边界。

按自己的节奏,确认真正理解。

目录与阅读设置

记录一个想法

Agent 间通信与任务分配

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通