以下数字为教学示例,不构成对任何真实系统或供应商的承诺。
上一节用进展信号判断"该不该继续",这一节处理另一个问题:还能不能继续。即使 Agent 有进展,token、金额、时间或步数也可能先耗尽。预算管理回答的不是"任务好不好",而是"这次运行付不付得起、停不停得下"。
预算有两个容易混的层面:预算是什么(上限值)和预算怎么用(超限后怎么办)。很多人只配置前者,让 Agent 在超限瞬间抛出异常;这一节说明,预算的效力取决于超限后的语义——硬停、降级还是继续。
四类预算
预算至少四类,对应四类不同的资源:
| 预算 | 计量单位 | 控制什么 | 超限的典型表现 |
|---|---|---|---|
| 步数 | 循环迭代次数 | 工作量上限 | 死循环、无休止重试 |
| token | 输入输出 token 和 | 模型调用量 | 长上下文 + 多轮调用叠加 |
| 时间 | 墙钟秒数 | 端到端延迟 | 任务挂起、用户等待 |
| 金额 | 模型调用成本 | 财务成本 | 成本失控、预算超支 |
四类预算的消耗节奏不同:步数按循环增量,token 每步都有,金额随 token 与价格走,时间可能被慢调用吃掉。因此它们不能混成一个"总预算",要分别计量、分别判定。
统一使用统计
预算要在同一个 Usage 对象里累积,每次调用工具后把本次消耗加进去。这一设计有两个好处:
- 一次提交、统一判定。 每一步结束,同时检查步数、token、时间、金额,四个上限共用同一个当前值。
- 可审计。 终止时能回答"消耗在哪一步、哪类资源先超限",而不是只知道"失败了"。
超限判定要按固定优先级进行。实验里采用 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 美元。这个"完美"是假象:没有预算约束,任何场景都不会停下来,成本线性增长。预算的本质是用可接受的损失换可控的成本。
强制终止必须留下什么
强制终止和正常完成是两种不同的结束方式,但对外部系统要一样可信。终止时必须留下:
- 停止原因:哪类资源超限、超过多少;
- 进度快照:已完成哪些阶段、剩下哪些阶段;
- 部分结果:已完成阶段的可信产出,不能因为中断而全部丢弃;
- 可重放状态:下次继续或回滚所需的全部上下文。
第 3 条最常被忽略。很多实现一超限就抛异常,把已经完成的阶段一起丢掉。对 W2 代码修复来说,这意味着改到一半的补丁、跑过的测试全部消失;对 W3 运维处置来说,已执行的动作和未确认的状态都可能丢失,回滚都无从谈起。
预算与降级的判据
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 分类计量 | 步数/token/时间/金额分开统计 | 只有一个总预算 |
| 优先级声明 | 超限判定顺序写死 | 各实现自行判断 |
| 终止留痕 | 原因 + 快照 + 部分结果 | 直接抛异常 |
| 降级可控 | 软阈值 + 硬限都配置 | 只有一条"省钱"的提示 |
| 可重放 | 终止后可继续或回滚 | 中断即丢状态 |
“降级可控"尤其要注意:降级是一个显式的策略分支,不是让模型"自己省着点”。降级后哪些工具不可用、输出多短、检索多粗,都要定义清楚,否则降级本身会变成另一个不可控源。
预算分配:按负载而不是按全局
三类工作负载的预算形态完全不同,共用一套全局预算会两头不讨好:
| 负载 | 主要预算 | 超限时的期望 |
|---|---|---|
| W1 检索问答 | 时间(p95≤8s) | 快速返回部分答案或拒答 |
| W2 代码修复 | 步数 + token(10–40 步) | 保留补丁与测试记录 |
| W3 运维处置 | 金额 + 审批 | 停下等人审批,不自动重试 |
W3 是特殊的:它的"预算超限"通常不是成本问题,而是权限问题。强制终止在这里要触发的是审批流程,而不是静默放弃。把预算一律做成"超限即失败",会掩盖这一类需要人工接管的场景。
小结
- 预算至少四类:步数、token、时间、金额;要分类计量、统一判定。
- 超限判定要有固定优先级;先检步数可兜住死循环,再看成本。
- 预算的效力取决于超限后的策略:硬停保成本,降级保产出。
- 降级不总是赢:当瓶颈是步数时,省 token 无处可花。
- 强制终止必须留下原因、快照、部分结果与可重放状态。
- 预算要按负载分配;W3 的超限要触发审批,而不是静默失败。
阅读导航:上一节:2.2 进展度量与死循环检测 · 下一节:3.1 CoT 的轨迹格式与可验证性 。
常见错误与边界
- 只有总预算。 步数、token、时间、金额混在一起,无法判断哪类资源先耗尽。
- 超限即抛异常。 中断时丢掉已完成的部分结果,无法交接也无法回滚。
- 降级当万能。 瓶颈是步数时,省 token 换不来更多步骤,降级无效。
- 提示词里写"省着点"。 降级是显式策略,不是模型的自我约束。
- 全局一套预算。 三类负载形态不同;W3 的超限要接审批而不是静默失败。
- 不记录停止原因。 终止只留"超时",事后无法审计成本花在哪一步。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。