《AI Agent 技术原理与架构·运行时、协议与系统架构》10.1 委托与交接:责任如何转移

把任务给别的智能体做,关键不是消息怎么发,而是责任落在谁头上。委派让执行者干活但编排者仍负责任,交接把责任彻底移交给下一个执行者。责任转移必须显式记录,形成一条可追溯的责任链。实验模拟前台把发票与退款交给财务,演示委派与交接两种责任语义,说明责任链是协调正确性的依据。

以下任务与责任归属均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。“委派保留责任、交接转移责任、责任链可追溯"这三条语义不变,具体任务划分按业务流程实测。

9.3 决定哪些任务值得多智能体,这一节落地第一件协调动作:把任务给别的智能体做。关键不是"消息发给谁”,而是"责任落在谁头上"。委派和交接是两种不同的责任转移,混在一起,出了问题就找不到负责人。

委派:干活的是别人,负责的还是我

委派是"让执行者干活,但编排者仍负责任"。编排者派活出去,但任务一旦出错,兜底的是编排者。委派是授权的,不是甩锅的。

动作执行者责任者
委派(assign)被委派的 agent委派的编排者
交接(handoff)下一个 agent下一个 agent

委派适合"我盯着"的场景:编排者要汇总多个子任务的结果,每个子任务派出去做,但整体成败由编排者拍板。被委派者做完交回来,编排者负责拼装与裁决。

交接:责任彻底移交

交接是"这件事从此归你负责"。编排者把任务交给下一个执行者后,责任就转移了——下一个执行者不只是干活,还要为结果负责。交接是让责任跟着任务走。

场景委派交接
派子任务做、汇总委派—
任务转手、我不再跟进—交接

交接适合"我不管了"的场景:前台收到退款请求,自己处理不了,转给财务——从此财务负责,前台只在边界转交。交接后的错误,责任在财务,不在前台。

责任链:转移要有记录

责任转移不能靠心照不宣,要显式记录成链。责任链回答"现在的负责人是谁、之前是谁"——每次委派、交接、完成,都往链上追加一条。这条链是协调正确性的依据:出了问题,沿链找到当时的责任者。

最小实验:委派与交接的责任语义

实验提供 delegate 与 handoff:都发一条任务消息,但 responsible 字段不同——委派保留编排者、交接指向下一个执行者。responsibility_chain 记录完整责任转移序列。

# file: agp_lab/delegation_handoff.py | write
# tier: 3
# verify: python3 -m unittest tests.test_delegation_handoff
"""委派与 Handoff:任务交接的责任转移。

委派是把任务交出去并跟踪结果;Handoff 是把"对话/责任"转移给另一个
Agent,原 Agent 不再继续。本模块实现带责任链的委派,演示只委派不
交接(责任仍在原 Agent)与真正 Handoff(责任转移到新 Agent)的区别。
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any


@dataclass(frozen=True)
class Task:
    id: str
    capability: str


@dataclass(frozen=True)
class Agent:
    name: str
    capabilities: frozenset[str]


def delegate(task: Task, orchestrator: str, agents: list[Agent]) -> dict[str, Any]:
    """委派:找到能执行者,责任仍在委派方(结果要回传)。"""
    for agent in agents:
        if task.capability in agent.capabilities:
            return {
                "kind": "assign",
                "from": orchestrator,
                "to": agent.name,
                "task_id": task.id,
                "responsible": orchestrator,
            }
    return {"kind": "reject", "task_id": task.id, "responsible": orchestrator}


def handoff(task: Task, current: str, agents: list[Agent]) -> dict[str, Any]:
    """Handoff:责任随交接转移,原 Agent 不再对结果负责。"""
    for agent in agents:
        if agent.name != current and task.capability in agent.capabilities:
            return {
                "kind": "handoff",
                "from": current,
                "to": agent.name,
                "task_id": task.id,
                "responsible": agent.name,
            }
    return {"kind": "keep", "task_id": task.id, "responsible": current}


def responsibility_chain(actions: list[dict[str, Any]]) -> list[str]:
    """沿消息序列追踪责任归属。"""
    responsible: str = "unknown"
    chain: list[str] = []
    for action in actions:
        responsible = action.get("responsible", responsible)
        chain.append(f"{action['kind']}->{responsible}")
    return chain


def demo() -> dict[str, Any]:
    agents = [
        Agent("front", frozenset({"intent", "policy"})),
        Agent("billing", frozenset({"invoice", "refund"})),
    ]
    invoice = Task("t1", "invoice")
    refund = Task("t2", "refund")

    delegated = delegate(invoice, "front", agents)
    handed = handoff(invoice, "front", agents)
    refund_handoff = handoff(refund, "front", agents)

    actions = [
        {"kind": "assign", "responsible": "front"},
        {"kind": "handoff", "responsible": "billing"},
        {"kind": "complete", "responsible": "billing"},
    ]
    chain = responsibility_chain(actions)

    return {
        "delegate_invoice": delegated,
        "handoff_invoice": handed,
        "handoff_refund": refund_handoff,
        "responsibility_chain": chain,
    }


if __name__ == "__main__":
    for key, value in demo().items():
        print(f"{key}: {value}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.delegation_handoff

输出:

delegate_invoice: {'kind': 'assign', 'from': 'front', 'to': 'billing', 'task_id': 't1', 'responsible': 'front'}
handoff_invoice: {'kind': 'handoff', 'from': 'front', 'to': 'billing', 'task_id': 't1', 'responsible': 'billing'}
handoff_refund: {'kind': 'handoff', 'from': 'front', 'to': 'billing', 'task_id': 't2', 'responsible': 'billing'}
responsibility_chain: ['assign->front', 'handoff->billing', 'complete->billing']

四条输出对应四件事:

  1. delegate_invoice:委派消息 assign,from front、to billing,但 responsible 是 front。委派的精髓就在这个字段:执行者是 billing,责任者是 front。
  2. handoff_invoice:交接消息 handoff,同样的 from/to,但 responsible 变成 billing。动作相同、责任不同——从 assign 到 handoff,责任人换人。
  3. handoff_refund:第二笔退款同样交接给 billing,responsible 是 billing。交接是可以复用的动作,一个流程里多次转手都走同一个语义。
  4. responsibility_chain:完整链 assign->front → handoff->billing → complete->billing。责任链按顺序记下每次转移,最后完成时责任停在 billing——“谁负责到完成"一目了然。

一个值得点破的细节:delegate_invoice 和 handoff_invoice 处理的是同一个任务 t1,前一条 responsible 是 front,后一条变成 billing——同一条任务,责任在转移。这就是委派与交接的分界:委派是"我借你的手”,交接是"我脱手给你"。如果实现里没有 responsible 字段,两类消息看起来一模一样,责任归属就彻底丢了。

责任链与故障定位

责任链的最大价值是故障定位。多智能体出问题,第一个问题是"谁负责的"。 责任链给出答案:沿链往回找,最后一个 responsible 就是现在的负责人,前一条链上的就是上一任。交接后出错、前手要负责的场景,责任链能明确说"责任已经转走了"。

场景责任链回答
完成后出错完成前的 responsible 是负责人
交接后出错责任已转给交接对象
委派后出错责任还在编排者

责任与 10 章其他机制的接口

责任链是协调机制的地基。仲裁(10.2)裁决冲突时,责任链告诉仲裁员"谁的意见代表哪个责任者";死锁(10.3)检测到环时,责任链帮定位"环上每个节点各负责什么"。委托与交接把"谁负责"变成显式数据,仲裁与死锁才有依据——没有责任链,仲裁变成空谈,死锁定位变成猜谜。

责任与追踪、审计的接缝

责任链还连接第 12 章的追踪与第 13 章的审计。追踪(12.1)记录消息与调用,责任链记录责任归属——两者是不同层的可观测性:追踪回答"发生了什么",责任链回答"谁该负责"。审计(13.3 的合规视角)要能沿责任链查"谁在什么任务上负过责"。责任链是把"协调正确性"变成可审计证据的关键——没有它,多智能体只有"发生了什么",没有"谁负责"。

责任链的存储

责任链是数据,要能查。每条责任转移落一条记录:动作、从者、到者、时间、任务。存起来才能回溯——出了问题沿链找,审计要能按任务拉出完整责任史。责任链存哪一层?跟随任务记录(任务生命周期内)还是独立存储(长期可查),看责任追溯的需求。

存储保留适用
随任务任务结束即失效只需运行期追溯
独立长期保留合规审计需要

责任链与 8.3 的审计是同一种数据——责任转移是"谁负责了",审计日志是"谁做了什么",两个视角合起来才是完整的"谁在何时负责了什么"。责任链的独立存储通常复用的就是审计存储。

责任与超时

责任有个时间维度:任务超时,责任还在吗? 委托的任务超时未完成,编排者要重新委派或接管——责任从执行者回到编排者,要记录这次"收回"。交接的任务超时,交接对象失联,责任如何善后?要有一个"责任兜底"的规则。

场景责任变化
委托超时收回给编排者
交接对象失联兜底接管
完成超时责任停在最后执行者

超时责任要写进责任链——“超时收回"也是一次责任转移,不记录,出了问题就说不清是谁在超时后该负责。这呼应 10.3 的预算:预算强制终止之后,责任转移的收尾动作要显式。

责任链与可见性

责任链要暴露给运维与审计。运行期,责任链帮定位"卡在谁那”——任务挂起,查链最后一条就知责任在谁;审计期,责任链回答"某任务的历史负责人都有谁"。责任链是运行与审计共用的视图,实现上就是一条可查询的表。

架构判据

委托与交接是否合格,用五条判据检查:

判据合格的样子不合格的样子
责任字段显式每条消息有 responsible责任靠猜
委派与交接区分两种动作语义不同动作相同责任混乱
责任链可追溯每次转移有记录责任转移无痕迹
责任随任务走交接后责任人更新交接后还是旧负责人
与仲裁死锁配套责任链供仲裁定位责任链悬空不用

判据第一条是"责任必须落在一个字段上",判据第三条才是关键:责任转移要显式记录成链,出了问题沿链找。判据第五条是 10.1 与 10.2、10.3 的接缝——责任链不只是记录,更是仲裁与死锁定位的输入。

小结

  • 委派保留责任:干活的是别人,负责的还是我。
  • 交接转移责任:从此归你负责,责任随任务走。
  • 责任链显式记录每次转移,回答"现在的负责人是谁"。
  • 责任链是故障定位的第一依据。
  • 责任链是仲裁与死锁定位的地基。

阅读导航:上一节:9.3 单智能体还是多智能体 · 下一节:10.2 仲裁:多数、优先级与版本 。

常见错误与边界

  1. 责任靠猜。 消息里没有 responsible 字段,出了事找不到负责人。
  2. 委派与交接混用。 一个动作两种语义,责任归属彻底混乱。
  3. 责任转移无记录。 交接不记链,后续定位只能考古。
  4. 交接后责任还停在旧人。 责任不随任务走,交接等于没交接。
  5. 责任链悬空。 记录了不用,仲裁与死锁定位时想不起来查链。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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