《AI Agent 技术原理与架构·决策、记忆与学习》2.3 预算、超时与强制终止

预算不是提示词里的提醒,而是运行时的强制约束。本节把 token、金额、时间、步数四类预算放进统一的使用统计,比较无预算、到限硬停与越过软阈值降级三种策略,说明强制终止必须留下部分结果与原因,并给出预算分配、超限降级与结果保留的设计判据,让超限行为有明确默认处置。

以下数字为教学示例,不构成对任何真实系统或供应商的承诺。

上一节用进展信号判断"该不该继续",这一节处理另一个问题:还能不能继续。即使 Agent 有进展,token、金额、时间或步数也可能先耗尽。预算管理回答的不是"任务好不好",而是"这次运行付不付得起、停不停得下"。

预算有两个容易混的层面:预算是什么(上限值)和预算怎么用(超限后怎么办)。很多人只配置前者,让 Agent 在超限瞬间抛出异常;这一节说明,预算的效力取决于超限后的语义——硬停、降级还是继续。

四类预算

预算至少四类,对应四类不同的资源:

预算计量单位控制什么超限的典型表现
步数循环迭代次数工作量上限死循环、无休止重试
token输入输出 token 和模型调用量长上下文 + 多轮调用叠加
时间墙钟秒数端到端延迟任务挂起、用户等待
金额模型调用成本财务成本成本失控、预算超支

四类预算的消耗节奏不同:步数按循环增量,token 每步都有,金额随 token 与价格走,时间可能被慢调用吃掉。因此它们不能混成一个"总预算",要分别计量、分别判定。

统一使用统计

预算要在同一个 Usage 对象里累积,每次调用工具后把本次消耗加进去。这一设计有两个好处:

  1. 一次提交、统一判定。 每一步结束,同时检查步数、token、时间、金额,四个上限共用同一个当前值。
  2. 可审计。 终止时能回答"消耗在哪一步、哪类资源先超限",而不是只知道"失败了"。

超限判定要按固定优先级进行。实验里采用 steps → tokens → seconds → dollars 的顺序:先用步数上限兜住死循环,再看 token,再看时间,最后看金额。顺序不是任意的,它反映"哪类资源先耗尽最可能说明失控"。

三种终止策略

超限之后怎么处理,是预算设计里最容易被跳过的一环:

策略行为适用
无预算不设上限,靠其他手段演示基线,不作为生产方案
硬停一旦超限立即终止高风险、成本敏感场景
降级越过软阈值后改用更省资源的模式,到硬限才停想保留部分结果的场景

硬停保证成本,降级保证产出。降级用"已用/上限比例"做软阈值:超过 50% 后,每一步改用更省 token 的模式(实验里是更小的输入、更短的输出),把剩余预算花在更多步骤上,而不是更贵的步骤上。

最小实验:三种策略对比

下面的实验在三个场景(token 紧张、时间紧张、步数紧张)下比较三种策略。每个任务有 8 个阶段,每阶段正常消耗 900 token、1.5 秒、0.004 美元;降级后每阶段只花 350 token、1.2 秒、0.0015 美元。

# file: agp_lab/termination_budget.py | write
# tier: 3
# verify: python3 -m unittest tests.test_termination_budget
"""预算、超时与强制终止:token、金额、时间、步数四类上限。

预算不是提示词里的提醒,而是运行时的强制约束。本模块把四类预算放进
同一个 Usage 对象,按固定优先级判定超限,并比较三种策略:无预算、
到限硬停、越过软阈值后降级。实验关心的是部分结果与成功率的差别。
"""
from __future__ import annotations

from dataclasses import dataclass

STEP = "steps"
TOKENS = "tokens"
SECONDS = "seconds"
DOLLARS = "dollars"
LIMIT_ORDER = (STEP, TOKENS, SECONDS, DOLLARS)


@dataclass(frozen=True)
class Budget:
    steps: int
    tokens: int
    seconds: float
    dollars: float

    def __post_init__(self) -> None:
        if self.steps < 1:
            raise ValueError("steps 必须为正")
        if self.tokens <= 0 or self.seconds <= 0 or self.dollars <= 0:
            raise ValueError("token、时间与金额预算必须为正")


@dataclass(frozen=True)
class Spend:
    tokens: int
    seconds: float
    dollars: float


@dataclass(frozen=True)
class Usage:
    steps: int = 0
    tokens: int = 0
    seconds: float = 0.0
    dollars: float = 0.0

    def add(self, spend: Spend) -> "Usage":
        return Usage(
            steps=self.steps + 1,
            tokens=self.tokens + spend.tokens,
            seconds=self.seconds + spend.seconds,
            dollars=self.dollars + spend.dollars,
        )


NORMAL_SPEND = Spend(900, 1.5, 0.004)
DEGRADED_SPEND = Spend(350, 1.2, 0.0015)


def usage_ratio(usage: Usage, budget: Budget) -> float:
    """已用资源相对预算的最大比例,用于触发降级。"""
    return max(
        usage.steps / budget.steps,
        usage.tokens / budget.tokens,
        usage.seconds / budget.seconds,
        usage.dollars / budget.dollars,
    )


def over_budget(usage: Usage, budget: Budget) -> str | None:
    """按 steps → tokens → seconds → dollars 的固定优先级返回超限项。

    判定使用严格大于:预算等于上限的那一步允许完成,下一步才终止。
    """
    if usage.steps > budget.steps:
        return STEP
    if usage.tokens > budget.tokens:
        return TOKENS
    if usage.seconds > budget.seconds:
        return SECONDS
    if usage.dollars > budget.dollars:
        return DOLLARS
    return None


@dataclass(frozen=True)
class Result:
    completed: int
    total: int
    usage: Usage
    stop_reason: str | None
    mode: str

    @property
    def partial(self) -> float:
        return self.completed / self.total

    @property
    def success(self) -> bool:
        return self.completed == self.total


def run(
    total: int,
    budget: Budget,
    policy: str,
    normal: Spend = NORMAL_SPEND,
    degraded: Spend = DEGRADED_SPEND,
    degrade_at: float = 0.5,
) -> Result:
    """执行 total 个阶段;policy 为 none、hard 或 degrade。"""
    if total < 1:
        raise ValueError("total 必须为正")
    if policy not in ("none", "hard", "degrade"):
        raise ValueError(f"未知策略: {policy}")
    if not 0.0 < degrade_at < 1.0:
        raise ValueError("degrade_at 必须在 (0, 1) 内")
    usage = Usage()
    mode = "normal"
    for index in range(total):
        if policy == "degrade" and usage_ratio(usage, budget) >= degrade_at:
            mode = "degraded"
        spend = degraded if mode == "degraded" else normal
        candidate = usage.add(spend)
        if policy != "none":
            reason = over_budget(candidate, budget)
            if reason is not None:
                return Result(index, total, usage, reason, mode)
        usage = candidate
    return Result(total, total, usage, None, mode)


@dataclass(frozen=True)
class Scenario:
    name: str
    budget: Budget


SCENARIOS = (
    Scenario("token-tight", Budget(10, 4000, 100.0, 1.0)),
    Scenario("time-tight", Budget(10, 100000, 10.0, 1.0)),
    Scenario("step-tight", Budget(4, 100000, 100.0, 1.0)),
)


def compare(total: int = 8) -> list[tuple[str, str, Result]]:
    rows: list[tuple[str, str, Result]] = []
    for scenario in SCENARIOS:
        for policy in ("none", "hard", "degrade"):
            rows.append((scenario.name, policy, run(total, scenario.budget, policy)))
    return rows


if __name__ == "__main__":
    print(f"{'scenario':<12}{'policy':<8}{'done':>6}{'partial':>8}{'reason':>9}"
          f"{'steps':>6}{'tokens':>8}{'seconds':>8}{'dollars':>9}  mode")
    for name, policy, result in compare():
        reason = result.stop_reason or "-"
        print(
            f"{name:<12}{policy:<8}{result.completed:>3}/{result.total:<2}"
            f"{result.partial:>8.2f}{reason:>9}{result.usage.steps:>6}"
            f"{result.usage.tokens:>8}{result.usage.seconds:>8.1f}"
            f"{result.usage.dollars:>9.3f}  {result.mode}"
        )

运行:

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

输出:

scenario    policy    done partial   reason steps  tokens seconds  dollars  mode
token-tight none      8/8     1.00        -     8    7200   12.0    0.032  normal
token-tight hard      4/8     0.50   tokens     4    3600    6.0    0.016  normal
token-tight degrade   6/8     0.75   tokens     6    3750    8.1    0.017  degraded
time-tight  none      8/8     1.00        -     8    7200   12.0    0.032  normal
time-tight  hard      6/8     0.75  seconds     6    5400    9.0    0.024  normal
time-tight  degrade   7/8     0.88  seconds     7    4650    9.6    0.021  degraded
step-tight  none      8/8     1.00        -     8    7200   12.0    0.032  normal
step-tight  hard      4/8     0.50    steps     4    3600    6.0    0.016  normal
step-tight  degrade   4/8     0.50    steps     4    2500    5.4    0.011  degraded

这张表有三条可操作的结论。

降级不总是赢。 token-tight 场景下降级完成 6/8,明显好于硬停的 4/8;但 step-tight 场景下两者都是 4/8。原因是降级只省单步消耗,不省步数:当瓶颈是步数上限时,降级省下的 token 无处可花,反而可能因为切换到省 token 模式而丢失质量。降级的价值取决于"哪类资源是瓶颈"。

时间紧与 token 紧的收益不同。 time-tight 下降级完成 7/8,比硬停多一步,因为它把省下的资源换成了更多步骤;而时间消耗是硬性的,降级省下的 token 不能换成时间。所以 time-tight 下 9.6 秒的完成时间只比硬停多 0.6 秒,多完成了一步。

无预算是最危险的基线。 所有场景的 none 都显示 8/8 完成,代价是 7200 token、12 秒、0.032 美元。这个"完美"是假象:没有预算约束,任何场景都不会停下来,成本线性增长。预算的本质是用可接受的损失换可控的成本。

强制终止必须留下什么

强制终止和正常完成是两种不同的结束方式,但对外部系统要一样可信。终止时必须留下:

  1. 停止原因:哪类资源超限、超过多少;
  2. 进度快照:已完成哪些阶段、剩下哪些阶段;
  3. 部分结果:已完成阶段的可信产出,不能因为中断而全部丢弃;
  4. 可重放状态:下次继续或回滚所需的全部上下文。

第 3 条最常被忽略。很多实现一超限就抛异常,把已经完成的阶段一起丢掉。对 W2 代码修复来说,这意味着改到一半的补丁、跑过的测试全部消失;对 W3 运维处置来说,已执行的动作和未确认的状态都可能丢失,回滚都无从谈起。

预算与降级的判据

判据合格的样子不合格的样子
分类计量步数/token/时间/金额分开统计只有一个总预算
优先级声明超限判定顺序写死各实现自行判断
终止留痕原因 + 快照 + 部分结果直接抛异常
降级可控软阈值 + 硬限都配置只有一条"省钱"的提示
可重放终止后可继续或回滚中断即丢状态

“降级可控"尤其要注意:降级是一个显式的策略分支,不是让模型"自己省着点”。降级后哪些工具不可用、输出多短、检索多粗,都要定义清楚,否则降级本身会变成另一个不可控源。

预算分配:按负载而不是按全局

三类工作负载的预算形态完全不同,共用一套全局预算会两头不讨好:

负载主要预算超限时的期望
W1 检索问答时间(p95≤8s)快速返回部分答案或拒答
W2 代码修复步数 + token(10–40 步)保留补丁与测试记录
W3 运维处置金额 + 审批停下等人审批,不自动重试

W3 是特殊的:它的"预算超限"通常不是成本问题,而是权限问题。强制终止在这里要触发的是审批流程,而不是静默放弃。把预算一律做成"超限即失败",会掩盖这一类需要人工接管的场景。

小结

  • 预算至少四类:步数、token、时间、金额;要分类计量、统一判定。
  • 超限判定要有固定优先级;先检步数可兜住死循环,再看成本。
  • 预算的效力取决于超限后的策略:硬停保成本,降级保产出。
  • 降级不总是赢:当瓶颈是步数时,省 token 无处可花。
  • 强制终止必须留下原因、快照、部分结果与可重放状态。
  • 预算要按负载分配;W3 的超限要触发审批,而不是静默失败。

阅读导航:上一节:2.2 进展度量与死循环检测 · 下一节:3.1 CoT 的轨迹格式与可验证性 。

常见错误与边界

  1. 只有总预算。 步数、token、时间、金额混在一起,无法判断哪类资源先耗尽。
  2. 超限即抛异常。 中断时丢掉已完成的部分结果,无法交接也无法回滚。
  3. 降级当万能。 瓶颈是步数时,省 token 换不来更多步骤,降级无效。
  4. 提示词里写"省着点"。 降级是显式策略,不是模型的自我约束。
  5. 全局一套预算。 三类负载形态不同;W3 的超限要接审批而不是静默失败。
  6. 不记录停止原因。 终止只留"超时",事后无法审计成本花在哪一步。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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