《AI Agent 技术原理与架构·决策、记忆与学习》10.1 工具选择:能力、成本与风险

工具选择不是“挑能力最强的那个”。同一个任务下,能力、成本与风险共同决定一次调用是否合格。本节用六条跨 W1/W2/W3 的任务比较四种选择策略,按正确、选错工具、不安全三类归因,说明风险必须做成硬门禁而不是打分里的扣分项,并给出选择记录与归因的架构判据。

以下数字均为教学假设,不构成对任何真实系统或供应商的承诺。工具能力分、成本与风险等级只用于展示选择策略的计算方式,不代表任何生产环境的真实指标。

工具选择最常见的写法是“给每个工具一段描述,让模型自己挑”。这在小规模、只读、低风险的场景里能工作;一旦工具之间存在成本差异、权限差异和不可逆副作用,模型的选择就会从“能力匹配”退化成“措辞相似度”。一个描述里带“重启”的工具,可能真的重启服务,也可能只是重启一个本地进程,模型看不出这个区别,除非 schema 和策略把它写清楚。

这一节把工具选择拆成三个可比较的维度:能力、成本、风险。能力回答“这个工具能不能完成任务”,成本回答“值不值得”,风险回答“允不允许”。三者不是同一层的问题:能力决定候选,成本决定偏好,风险决定否决。把三者压成一个加权分数,看起来简洁,实际上会把否决权变成可交易项。

三个维度与三类错误

给定任务 $x$,工具 $t$ 有三个属性:

  • 能力 $cap_t(x) \in [0,1]$:工具对这类意图的匹配程度。
  • 成本 $c_t \ge 0$:金额、延迟或资源消耗的归一化表示。
  • 风险 $r_t \in [0,1]$:不可逆性、影响范围、权限敏感度的综合等级。

任务还带两个约束:最低能力 $cap_{min}(x)$ 和风险容忍度 $\tau(x)$。后者的取值来自业务:只读查询可以容忍低风险,不可逆的运维动作只能接受经过审批、影响范围受控的工具。

一次选择按后果分三类:

归因定义典型原因
correct能力达标且风险在容忍范围内策略与约束一致
wrong_tool选中的工具能力低于任务下限关键词匹配、描述误导、缺少候选
unsafe选中工具的风险超过任务容忍度只看能力、风险只做扣分

这三类错误的代价不对称。wrong_tool 通常表现为任务失败或结果不对,可以重试;unsafe 可能产生不可逆副作用,重试无法撤销。因此选择策略的第一目标是避免 unsafe,第二目标才是提高正确率和降低成本。把三者放进同一个平均分,等于允许“高能力”抵消“高风险”,这在只读场景也许可以接受,在 W3 运维处置里不可接受。

四种策略

实验比较四种策略:

  1. capability:只按能力排序,能力相同再看成本。它代表“模型只被工具描述吸引”的基线。
  2. cost_aware:得分 $cap - 0.5 \cdot c$。它开始考虑成本,但仍然不把风险当约束。
  3. risk_penalized:得分 $cap - 0.5 \cdot c - 0.6 \cdot r$。风险进入打分,但只是扣分项。
  4. risk_gated:先过滤 $r_t > \tau(x)$ 的工具,再按 $cap - 0.5 \cdot c$ 排序。风险是硬约束。

这四种策略的差别不在公式复杂度,而在风险有没有否决权。软惩罚可以让高风险工具在能力足够高时仍然胜出;硬门禁则直接把它从候选里移除,代价是可能没有候选,需要走澄清、升级或人工审批。

最小实验:六条任务、七件工具

任务覆盖三类负载:W1 的检索问答、W2 的代码修复、W3 的运维处置。工具包括只读检索、读日志、跑测试、改文件、重启服务、扩容服务和询问用户。每件工具对每类意图的能力分是声明值,成本与风险也是教学设定。

w2_patch 的容忍度是 0.70,因为改文件可回滚;w2_verify 只有 0.30,因为它只需要跑测试,不应该改文件。w3_scale 的容忍度是 0.60,扩容比重启影响小;w3_restart 是 0.99,代表已经拿到审批、明确允许重启的场景。这个设置是刻意的:同一个“重启”意图,在不同审批状态下应该得到不同答案。

# file: agp_lab/tool_choice.py | write
# tier: 3
# verify: python3 -m unittest tests.test_tool_choice
"""工具选择:能力、成本与风险。

同一批任务、同一组工具,用四种策略做选择:只看能力、成本惩罚、风险
软惩罚、风险硬门禁。每种选择按“正确 / 选错工具 / 不安全”归因,统计
错误类型,说明为什么风险必须是约束而不是扣分项。
"""
from __future__ import annotations

from dataclasses import dataclass


@dataclass(frozen=True)
class Tool:
    name: str
    capabilities: tuple[tuple[str, float], ...]
    cost: float
    risk: float

    def capability(self, intent: str) -> float:
        return dict(self.capabilities).get(intent, 0.0)


@dataclass(frozen=True)
class Task:
    name: str
    intent: str
    min_capability: float
    risk_tolerance: float


TOOLS = (
    Tool("search_docs", (("answer", 0.9), ("locate", 0.7), ("patch", 0.1)), 0.20, 0.05),
    Tool("read_logs", (("answer", 0.4), ("locate", 0.8), ("patch", 0.1)), 0.15, 0.05),
    Tool("run_tests", (("patch", 0.8),), 0.50, 0.20),
    Tool("edit_file", (("patch", 0.9),), 0.30, 0.60),
    Tool("restart_service", (("restart", 0.95),), 0.40, 0.95),
    Tool("scale_service", (("restart", 0.85),), 0.35, 0.55),
    Tool("ask_user", (("answer", 0.3), ("locate", 0.3), ("patch", 0.3), ("restart", 0.3)), 0.05, 0.0),
)

TASKS = (
    Task("w1_answer", "answer", 0.8, 0.10),
    Task("w1_locate", "locate", 0.7, 0.10),
    Task("w2_patch", "patch", 0.8, 0.70),
    Task("w2_verify", "patch", 0.8, 0.30),
    Task("w3_scale", "restart", 0.8, 0.60),
    Task("w3_restart", "restart", 0.9, 0.99),
)

POLICIES = ("capability", "cost_aware", "risk_penalized", "risk_gated")


def score(policy: str, tool: Tool, task: Task) -> float:
    capability = tool.capability(task.intent)
    if policy == "capability":
        return capability
    if policy == "cost_aware":
        return capability - 0.5 * tool.cost
    if policy == "risk_penalized":
        return capability - 0.5 * tool.cost - 0.6 * tool.risk
    if policy == "risk_gated":
        return capability - 0.5 * tool.cost
    raise ValueError(f"未知策略: {policy}")


def choose(policy: str, task: Task, tools: tuple[Tool, ...] = TOOLS) -> Tool:
    """返回策略选中的工具;风险门禁先过滤,再按得分排序。"""
    if policy == "risk_gated":
        pool = tuple(tool for tool in tools if tool.risk <= task.risk_tolerance)
    else:
        pool = tools
    if not pool:
        raise ValueError("没有满足风险约束的工具")
    return sorted(
        pool,
        key=lambda tool: (-score(policy, tool, task), tool.cost, tool.name),
    )[0]


def classify(task: Task, tool: Tool) -> str:
    """按后果归因:unsafe 优先于 wrong_tool。"""
    if tool.risk > task.risk_tolerance:
        return "unsafe"
    if tool.capability(task.intent) < task.min_capability:
        return "wrong_tool"
    return "correct"


def evaluate(policy: str, tasks: tuple[Task, ...] = TASKS) -> dict[str, object]:
    decisions = []
    counts = {"correct": 0, "wrong_tool": 0, "unsafe": 0}
    total_cost = 0.0
    for task in tasks:
        tool = choose(policy, task)
        verdict = classify(task, tool)
        counts[verdict] += 1
        total_cost += tool.cost
        decisions.append((task.name, tool.name, verdict))
    return {"policy": policy, "decisions": decisions, "counts": counts, "cost": total_cost}


if __name__ == "__main__":
    print(f"{'policy':<16}{'correct':>9}{'wrong':>7}{'unsafe':>8}{'cost':>7}")
    for policy in POLICIES:
        report = evaluate(policy)
        counts = report["counts"]
        print(
            f"{policy:<16}{counts['correct']:>9}{counts['wrong_tool']:>7}"
            f"{counts['unsafe']:>8}{report['cost']:>7.2f}"
        )
    print()
    baseline = dict((name, verdict) for name, _, verdict in evaluate("capability")["decisions"])
    gated = dict((name, verdict) for name, _, verdict in evaluate("risk_gated")["decisions"])
    for task in TASKS:
        print(f"{task.name:<12} capability={baseline[task.name]:<10} risk_gated={gated[task.name]}")

运行:

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

输出:

policy            correct  wrong  unsafe   cost
capability              4      0       2   1.75
cost_aware              4      0       2   1.75
risk_penalized          5      1       0   2.05
risk_gated              6      0       0   1.90

w1_answer    capability=correct    risk_gated=correct
w1_locate    capability=correct    risk_gated=correct
w2_patch     capability=correct    risk_gated=correct
w2_verify    capability=unsafe     risk_gated=correct
w3_scale     capability=unsafe     risk_gated=correct
w3_restart   capability=correct    risk_gated=correct

结果可以分成三组来看。

只看能力会选到不安全的工具。 capability 在 w2_verify 选了 edit_file:它的能力 0.9 高于 run_tests 的 0.8,但风险 0.6 超过了任务容忍度 0.3。它还在 w3_scale 选了 restart_service:能力 0.95 最高,风险 0.95 却远超 0.60。两条都是 unsafe。成本惩罚没有改变这两个选择,因为风险没有进入它的公式。

把风险做成扣分项,会避免不安全,但可能错过合法动作。 risk_penalized 没有产生 unsafe,代价是它在 w3_restart 选了 scale_service。这个任务已经拿到审批,容忍度 0.99,restart_service 是合法且能力更高的选择;但软惩罚对风险的扣分与任务上下文无关,仍然把它压了下去。结果是一条 wrong_tool,同时总成本从 1.75 升到 2.05,因为它在两个修复任务里都改用了更贵的 run_tests。

硬门禁同时满足安全和正确。 risk_gated 六条全对,总成本 1.90。它在 w2_verify 只保留风险不超过 0.30 的工具,自然选中 run_tests;在 w3_scale 排除 restart_service,选中 scale_service;在 w3_restart 因为容忍度足够高,允许 restart_service 进入候选并按能力选中。风险约束跟随任务上下文变化,而不是一个全局常数。

这里最值得记住的是 risk_penalized 的失败方式。它不是“选错了工具”,而是“在应该调用的时候选了一个能力不足的保守工具”。这类错误在统计上会被记为 wrong_tool,在线上表现为任务没完成、用户被要求重复确认,或者系统降级到一个功能更弱的路径。软惩罚的隐含假设是“风险可以用能力来交换”;只要业务上存在不可逆动作,这个假设就不成立。

边界与失败模式

第一,能力分是任务相关的,不是工具固有的。同一个 search_docs 对“回答事实问题”能力很高,对“重启服务”能力为零。把能力写成工具级的单一分数,会让选择器在多意图场景里系统性出错。能力必须按意图或按任务类型分别声明,并有评测集支撑。

第二,风险不是一个标量。不可逆性、影响范围、权限敏感度、数据暴露面是不同维度,合成 0 到 1 的分数会丢失信息。工程上更稳妥的做法是先按风险类别做硬约束(例如“生产环境写操作必须审批”),再在同类工具里比较能力和成本。

第三,硬门禁可能返回空集。这是它相对软惩罚的代价,也是它诚实的地方。没有满足风险约束的工具时,正确动作不是降低门槛,而是询问用户、请求审批、升级到人工,或者明确放弃。这条路径会在下一节“放弃与澄清”里展开。

第四,成本和风险会随上下文变化。同一工具在测试环境和生产环境的成本、风险不同;同一动作在有无审批时容忍度不同。选择器需要把环境、租户、审批状态作为输入,而不是在启动时固化一份全局权重。

第五,工具组合会改变单工具的风险判断。一次 edit_file 加一次 run_tests 可能比单独一次 edit_file 更安全,因为测试提供了验证;一次 scale_service 后面跟一次健康检查,也比裸扩容更可控。单步选择器看不到这种组合效应,需要在计划层或运行时补充约束。

把选择策略落到架构

一个可检查的工具选择组件至少包含五部分:

  1. 工具注册表:每个工具声明能力向量、成本模型、风险类别、所需权限和幂等性。
  2. 任务约束:每个任务或意图声明最低能力、风险容忍度、预算和审批状态。
  3. 硬门禁:先按权限、环境、风险类别过滤,再在剩余候选里排序;过滤原因要记录。
  4. 排序与回退:排序可以使用能力减成本的线性分,但回退路径必须显式:无候选时进入澄清、审批或放弃。
  5. 决策日志:记录候选集、过滤原因、得分和最终选择,支持失败复盘和策略回归。

对三类负载的落地重点不同。W1 检索问答以只读工具为主,风险门禁通常不是瓶颈,重点是能力匹配和引用质量;W2 代码修复要区分“读、改、跑测试”三类动作,改文件必须有回滚和测试约束;W3 运维处置的风险最高,重启、扩容、回滚必须与审批状态和环境绑定,任何“能力更高所以选它”的逻辑都要让位于风险门禁。

判据表

判据合格的样子不合格的样子验证方式
能力按意图声明每个意图有独立能力分一个工具一个总分分意图评测
风险是约束超容忍度直接排除风险只进加权分构造高风险候选
约束随上下文环境、审批、租户参与判断全局固定阈值切换审批状态回归
空集有出路澄清、审批、放弃显式可选自动降低门槛构造无安全候选用例
决策可复盘记录候选、过滤原因、得分只记录最终工具名失败样本回放
成本可比较成本口径统一且可解释金额、延迟混在一起按负载分别核算

小结

  • 工具选择有三个维度:能力决定候选,成本决定偏好,风险决定否决,三者不在同一层。
  • 只看能力会选到不安全工具;只看成本会忽略风险;风险软惩罚会在高能力工具面前失效。
  • 风险必须是硬门禁,并且跟随任务上下文变化;全局固定阈值会同时造成误拒和误放。
  • 硬门禁的代价是可能没有候选,此时应走澄清、审批或放弃,而不是降低门槛。
  • 本实验中 risk_gated 六条全对、成本 1.90;capability 与 cost_aware 各有两条 unsafe;risk_penalized 避开不安全但产生一条 wrong_tool,成本最高。
  • 选择器的输出不只是工具名,还应包含候选集、过滤原因和回退路径。

阅读导航:上一节:9.3 上下文预算 · 下一节:10.2 参数构造 。

常见错误与边界

  1. 把能力当唯一标准。 能力最高往往意味着权限最大、副作用最强;不先过滤风险,等于让能力替风险做决定。
  2. 把风险做成扣分项。 加权分允许高能力抵消高风险;只要存在不可逆动作,风险就必须是否决权。
  3. 用全局风险阈值。 测试环境和生产环境、有无审批的场景不能用同一个阈值;约束必须来自任务上下文。
  4. 把能力写成工具级总分。 工具对不同意图的能力差异很大;单一分数会让选择器在多意图场景里系统偏移。
  5. 无候选时自动降级。 没有满足约束的工具时,降低门槛是最危险的回退;应澄清、审批或放弃。
  6. 只记录最终选择。 没有候选集和过滤原因,失败后无法判断是检索没找到、门禁太严,还是排序错了。
  7. 忽略工具组合。 单步安全不代表组合安全;写操作后的验证、扩容后的健康检查都属于选择的一部分。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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