第 4 篇改成两阶段之后,选题助手稳定了一阵;第 5 篇加了评估,它变差了我能第一时间看见。
然后有一个周三下午,它没变差,它只是停不下来。
我把评估集挂成了每天跑一次。那天 30 条用例里有 6 条没跑完——不是答错,是撞到了我自己设的 max_steps = 8。我打开其中一条的 trace,看到的是这个形状:
第 3 步 list_topics -> 429(限流)
第 4 步 重试 -> 429
第 5 步 重试 -> 429
第 6 步 suggest_topics -> 429
第 7 步 重试 -> 429
第 8 步 被 max_steps 掐断
42 秒,0 个选题,烧掉了一整条任务的 token。而那条用例两小时前刚跑过一次:5 步、11 秒、满分通过。
同一周我还收到一条平台提醒:那周 token 消耗是上周的 3.4 倍,而任务量只涨了不到 40%。
这两件事其实是同一件:我把「失败」当成一种状态来处理,而不是当成需要分别处理的几类东西。
那个 429 本来该等一两秒再来一次。结果它在 42 秒里重试了三次,每次都把整个上下文原样重发一遍——而它真正该做的,是第一次 429 之后就退避,或者在退避期间换成小一点的模型把这一步先做完。
它没有坏。它只是不知道该怎么失败。
先给结论,后面所有内容围着它展开:
可靠性不是「让它不出错」,是「出错的时候,它知道该花多少钱、多少时间去救,以及什么时候该放弃」。
它的推论决定了后面所有的设计:每一次重试、每一次降级、每一次换模型,都是拿成本换成功率。你要管的不是错误本身,是这笔交易的汇率。
还有一句是本篇最想反驳的:
无差别重试不是可靠性措施,是买彩票。
很多人以为「我给所有调用都加了 3 次重试」就等于高可用。不是的。失败很少是随机的:同样的输入、同样的模型、同样的上下文,再来一次,大部分时候得到的是同样的失败,外加一份账单。真正提高成功率的是「换一种做法」,不是「再来一次」。
阅读提示:本文是「Agent 工程进阶」系列的第 6 篇,面向已经跑稳一个 Agent、开始被账单或超时困扰的读者。如果你还没做过第一个 Agent,建议先看新手系列的让 Agent 更像项目:工具、记忆、文件读写和简单界面。如果你想要一张整体地图,可以看第 0 篇从 Demo 到可交付:如何做一个 Agent 项目。
一、失败有四种,只有一种值得重试
第 3 篇讲过一类错误语义:工具要把错误说清楚给模型听,让它知道下一步能做什么。那一层是工具 → 模型。
本篇讲的是另一层:编排拿到一个错误之后,该做什么动作。两层的分类要对齐,但动作完全不同——模型能做的是「换个参数再来」,编排能做的是「退避、降级、换模型、交给人」。
先把失败分成四类:
| 类型 | 典型例子 | 重试有用吗 | 正确动作 |
|---|---|---|---|
| 瞬时(transient) | 429 限流、超时、5xx、连接重置 | 有用。这是唯一真正值得重试的一类 | 退避 + 抖动后重试 |
| 输入(invalid) | 参数不合法、schema 不匹配、路径不存在 | 无用,重试一百次结果一样 | 改输入;把结构化错误回传给上游 |
| 语义(semantic) | 输出漏了约束、格式不对、跑偏了 | 有用,但必须带变化 | 带上反馈重试,或换温度 / 换模型 |
| 致命(fatal) | 没权限、key 失效、依赖不存在、预算耗尽 | 无用且有害 | 立刻降级或交给人 |
判断方法,可以当场做:
重试变化测试。 假设这一次重试,和上一次相比唯一的区别是「再试一次」。如果你说不出第二个区别,就不要重试。
这一条能把「输入类」和「致命类」一次性筛掉——它们的重试没有任何变量在变。参数写错了,第二次的模型还是那个模型、参数还是那个参数;没权限,第二次还是没权限,而且连着三次未授权可能会触发风控。
两个工程约束:
用白名单,不用黑名单。 只重试你确认过的错误码(429 / 500 / 502 / 503 / 504 / timeout / connection_reset),其他一律不重试。写成黑名单(「除了 401 之外都重试」)的结果是:你永远在追赶新的错误类型,总有一天会把一个认证错误重试三次。
分类必须发生在编排层,不能交给模型。 让模型自己看着错误信息决定要不要重试,它几乎总会选择重试——因为在它当前的上下文里,「再做一次」永远是最合理的下一步。这正是第 4 篇说的「编排是决定下一步」,而这一步不值得交给模型。
二、重试:让第二次和第一次不一样
四条规则,按重要性排。
1. 指数退避 + 抖动
delay = min(base * 2^attempt, cap) × random(0.5 ~ 1.0)
抖动不是优化,是必需。没有抖动,一批同时失败的任务会在同一时刻一起重试,形成重试风暴(thundering herd),把刚刚恢复的服务再打垮一次。限流场景下最常见的自伤就是这么来的。
2. 无变化的重试最多 1 次,有变化的重试最多 2 ~ 3 次
这两种重试的性质完全不同,不该共用同一个次数:
- 无变化重试(瞬时错误):最多重试 1 次就够了。限流通常在一次退避之后就恢复,超过两次说明不是抖动,是容量问题——那时候该做的是降级,不是继续等。
- 有变化重试(语义错误):可以给 2 ~ 3 次,但每次都必须带新东西:第 4 篇 gate 给的结构化错误、或者换温度、或者换模型档位。第 4 篇那段
st.feedback = errs就是在做这件事——它给的重试不是「再来一次」,是「带着《X》缺少 angle 这条具体意见再来一次」。
3. 幂等是重试的前提
回第 3 篇:没有幂等键的写操作,重试就是重复副作用。三条再列一遍,因为这里最容易翻车:写前可读(先确认现在是什么状态)、写操作带 idempotency_key、失败可恢复(atomic write)。
一个特别容易被忽略的点:重试时要带上同一个 idempotency_key。这样即使第一次请求其实已经成功了(只是响应在回来的路上丢了),第二次也不会写两份。
4. 超时设三层,deadline 向下传递
连接超时 5s —— 连不上就换端点
单次调用 30s —— 一次采样
整任务 90s —— deadline,向下传递
最常见的 bug 是:每一层都各设各的 30 秒,于是整条链的最坏耗时是 30 × 步数 × 重试次数。
deadline 必须是一个绝对值往下传——每一步拿到的是「还剩多少时间」,而不是「我最多能用多久」。这是分布式系统里传了二十年的老经验,在 Agent 上一样成立,而且更容易被忽略,因为你的「每一步」是动态的,你事先不知道会有几步。
最后一件:第 5 篇的 trace 里那个 retry_of 字段,就是为了让重试在 trace 上可见。一条值得记住的经验:
如果 trace 上你看不出哪一步是重试,你的成本分析一定是错的——你会把三次的钱记成一次的钱。
三、降级:用便宜的方式做完同一件事
先纠正一个误解:降级不是「关掉功能」,是「用更保守的方式完成同一件事」。
关掉功能,用户拿到的是一句「服务暂不可用」;降级,用户拿到的应该是一个能用、但可能没那么好的结果,外加一句如实说明。这两者的差距,就是「系统挂了」和「系统扛住了」的差距。
五级阶梯,从轻到重依次尝试:
| 级别 | 做法 | 省什么 | 代价 |
|---|---|---|---|
| L1 换模型 | 强模型 → 便宜 / 快的模型 | 钱、时间 | 质量可能下降 |
| L2 减上下文 | 全量历史 → 摘要 + 最近 N 条 | 钱(大头)、时间 | 可能丢细节 |
| L3 减能力 | 多工具 → 只读 / 核心工具 | 钱、出错面 | 少一些功能 |
| L4 减自主 | Agent 循环 → 固定流水线 → 单步问答 | 时间、稳定性 | 灵活性 |
| L5 交给人 | 带着 state 和已尝试记录交接 | 不省钱,止损 | 用户体验 |
L2 直接复用第 1 篇的压缩与「选」,L3 复用第 3 篇的分层装载,L4 则是第 4 篇那条自由度光谱的反向应用——那篇说「越往左越可预测」,这里说「出事的时候往左走」。
三条设计原则:
触发条件写死在代码里,不要交给模型判断。 什么时候降级是一个工程决策(连续 N 次失败、预算剩余低于 X%、P95 延迟超过 Y、上游健康度),不是模型该管的事。让模型判断「我要不要降级」,它永远不会降——因为它的目标是完成当前这一步。
降级要可观测,降级率是一个正经指标。
降级率 = 触发过至少一次降级的任务数 / 总任务数
这个数字长期是 0%,说明你的阈值设得太松,或者降级根本没生效;长期在 30% 以上,说明你的容量或模型档位选错了。最危险的是你根本不记录它——那样你既不知道系统一直在降级,也不知道它其实一次都没降成。
降级必须诚实,不能静默。 这是本节最重要的一条,两个方向都要做:
- 对用户:输出里标明「这次走的是简化模式」,不要假装一切正常。
- 对系统:降级标记要写进 trace 和产物。否则回到第 5 篇——降级产出的分数会和正常产出的分数混进同一条基线,你的可比性就断了。 你已经花力气让 judge 的模型名和 rubric 版本写进基线,别让静默降级把它悄悄毁掉。
L5 交接时要带什么,顺带接上第 7 篇:不是一句「失败了」,而是 state 里已经完成的部分 + 已经试过什么 + 失败原因属于哪一类。让人从头再来一遍是最糟的交接方式。
四、预算:硬上限,不是告警
第 4 篇的 state 里有一个 budget: {"max_steps": 8, "max_tokens": 60_000}。那只是个计数器。真正的预算是一个钱包,它要回答四件事。
1. 三层预算,粒度不同
| 层 | 单位 | 防的是什么 |
|---|---|---|
| 任务级 | 步数 / token / 时间 | 单次任务失控(第 4 篇已有) |
| 会话 / 用户级 | 滚动窗口内的 token 或金额 | 一个人或一次循环把配额烧光 |
| 全局 / 日级 | 金额 | 最后一道闸,也是你对账的依据 |
只设任务级预算,最常见的后果是:某个用户的会话陷入了一个循环,每次都是合法的 8 步,一天跑了两千次。
2. 它是硬上限,不是告警
告警没有人会在半夜看;而且「超出预警」的实现通常是打一行日志,然后继续跑。真正有用的是:超了就停,并且在停下之前先把已经完成的部分交付出去。
这一点决定了用户体验,值得展开:
错误做法:预算耗尽 -> 抛异常 -> 用户看到「生成失败」
正确做法:预算耗尽 -> 停止探索 -> 用现有 artifact 走完最后一步
-> 输出 + 标注「因预算上限提前收敛」
一个「部分完成但说明清楚」的结果,几乎总是好过一次硬失败。这跟第 4 篇那句「三次不达标就交给人」是同一个思路的不同档位:先降级,再收敛,最后才放弃。
3. 预估 + 实时扣减 + 事后对账,三件事都要
- 预估(pre-flight):按输入长度估一次,够不够跑完下一个阶段;不够就直接降级,别等到中途才发现钱花完了。
- 实时扣减:每步记账,
budget.remaining -= step_cost。 - 事后对账:用 trace 里的 token 累加出一个数,跟平台账单对一次。这两个数对不上是非常常见的,对不上就说明有调用没被记账——通常是失败的重试,或者流式输出中断的那一次。
4. 预算快用完时,行为要分级
剩余 > 50% 正常跑
30% ~ 50% 关掉可选步骤(自检、扩展调研)
10% ~ 30% 降模型档 + 收敛输出
< 10% 停止探索,直接进最后一步
把这套接进路由层,预算就不再只是一个「会不会挂」的开关,而是参与决策的一个变量。这也是「可靠性」和「成本」这两个词在本篇被放在同一个标题里的原因:在 Agent 系统里,它们是同一件事的两面。
5. 重试从同一个钱包里扣
这一条最容易被忘记:你设了 max_tokens = 60_000,然后每次重试都重发整个上下文,于是实际消耗是三倍。
要么把重试计入预算,要么明确接受「这个预算只管单次采样」——但你必须知道你选的是哪一种,并且把它写进注释。含糊的预算定义,等于没有预算。
五、模型路由:不是每一步都需要最强模型
三种路由,从简单到复杂。
① 静态路由(按阶段)
90% 的场景到这就够了。第 4 篇已经把流程切成阶段了,给每个阶段配一个模型档位,是最便宜的一次优化:
抽取约束、分类、格式化、查重判断 -> 小模型(便宜、快)
生成选题、写作、复杂推理 -> 强模型
judge -> 另一个家族(第 5 篇)
② 动态升级(escalate)
先小模型,不合格再上大模型。听起来很省,但它有一个前提,而且经常被忽略:
小模型的失败必须是可判定的。 你必须有一个明确信号说「这份输出不合格」——就是第 4 篇的 gate、第 5 篇的硬断言。如果判不了,你就不知道该不该升级,最后只能「全都升级一遍」,那等于没路由,还多花了一次调用。
而且要算清楚一笔账:escalate 不是免费的。 小模型失败了才升级,你付的是「小模型 + 大模型」两份钱,比直接用大模型还贵。它只在「小模型大概率能过」的场景下才划算——
先测一下小模型在这个阶段的通过率,高于 70% 再上 escalate。
③ 按预算路由
剩余预算决定档位,就是上一节的第 4 条。
三个隐藏成本
换模型 = 缓存失效。 前缀缓存通常跟模型和前缀绑定,中途换模型等于前面攒的缓存全废。这可能吃掉路由省下来的那点钱。
不同模型的失败模式不同。 换了模型,第 5 篇那套基线就跨模型不可比了——所以 model 必须写进 trace 和基线,跟 judge 的模型名一样。
路由本身会增加一个判断环节。 如果这个判断还要一次模型调用(「这个任务难不难?」),那你就是在为省 token 而多花一次调用。用规则判断难度,不要用模型判断难度。
一个反直觉的结论
我认为这是本节最重要的一句:
模型路由能省的钱,通常比你预期的少。
因为大部分成本在输入 token,而你积累的上下文不会因为换模型而变小。一次 8 步的任务,输入占比经常在 80% 以上——换掉输出端的模型,只动得到那 20%。
真正省大钱的是第 1 篇的上下文治理(压缩、缓存、隔离)和第 2 篇的按需召回。先做完那两篇,再来看路由。 顺序反了的话,你会花很多力气做路由,然后看着账单没什么变化。
六、延迟:用户等的是第一个字
用户感知的等待 ≠ 任务总耗时。 一个 40 秒但每 5 秒吐出一行的任务,比一个 12 秒全程静默的任务感觉快得多。
三件事,按性价比排:
1. 首字延迟(TTFB)优先于总时长。 流式输出对总耗时毫无帮助(一秒不少),但对「它是不是卡住了」的观感影响最大。这是投入产出比最高的一项,而且它几乎不花钱。
2. 阶段可见性。 不要让用户对着一个转圈的图标等 60 秒。每完成一个阶段给一句状态——「已读 12 篇历史选题」「正在生成候选(2/5)」。这一条和流式是同一件事的两面:用户能容忍等待,不能容忍未知。
3. 真并行才省时间。 回第 4 篇信号二:只有子任务之间不写同一个东西,并行才成立。常见错误是「把串行改成并行」之后,几个子任务争抢同一个文件,最后花在锁和重试上的时间比省下的还多。
然后是测量上的两个坑。
看分位数,不看均值。 平均 3 秒、P95 28 秒,用户实际体验到的是后者——因为那 5% 的慢请求恰恰会落在最活跃的用户身上。第 5 篇说过「过程指标比结果指标更早发现问题」,延迟是最典型的一个过程指标:
那时候结果指标还全绿,你还有一周的时间可以提前处理。
延迟预算要倒推,不是事后优化:
用户可接受 20s
- 阶段一 research <= 8s
- 阶段二 write <= 6s
- 余量(重试 / 网络) 6s
这个倒推的价值在于:它会逼你承认「那个自检环节根本塞不进去」,从而把它砍掉或者挪到异步去。延迟预算和 token 预算一样,是设计约束。
七、动手改一遍:给选题助手加一层可靠性
目标很具体:同样是遇到 429,从「42 秒、0 个选题」变成「退避一次就恢复,恢复不了就降级完成」。
目录
src/
pipeline.py
reliability/
errors.py # 错误分类:classify(err) -> transient / invalid / semantic / fatal
retry.py # 退避 + 抖动 + 预算扣减
budget.py # 钱包:预估 / 扣减 / 剩余比例
router.py # 阶段 -> 模型档位
degrade.py # 降级阶梯 + 标记
改之前
第 4 篇留下的那段(留着当对照组):
# src/pipeline.py —— 改之前
for attempt in range(3):
out = research.run(st, tools=registry.active_tools("read"))
errs = gates.check_candidates(out.candidates, st.constraints)
if not errs:
break
st.feedback = errs
st.budget["max_steps"] -= 1
else:
return handoff_to_human(st, "候选连续三次未通过校验")
四个问题:range(3) 不分错误类型(工具限流和输出漏约束走同一条路)、没有退避(限流时立刻重试)、重试不计预算(最坏三倍)、三次之后直接交给人(中间没有任何降级)。
第一步:分类
# src/reliability/errors.py
TRANSIENT = {"rate_limit", "timeout", "connection_reset", "server_error"}
FATAL = {"auth", "permission", "quota_exceeded"}
def classify(err) -> str:
code = getattr(err, "code", None) or type(err).__name__
if code in TRANSIENT: return "transient" # 唯一值得原样重试的
if code in FATAL: return "fatal" # 立刻停
if isinstance(err, (ValidationError, FileNotFoundError)):
return "invalid" # 重试一百次也一样
return "semantic" # 输出不合要求:可救,但要带变化
第二步:带预算的重试
# src/reliability/retry.py
TRIES = {"transient": 2, "semantic": 3, "invalid": 1, "fatal": 1}
def with_retry(fn, *, kind: str, budget):
last = None
for i in range(TRIES[kind]):
if not budget.can_spend(fn.estimate()): # 重试也从同一个钱包扣
return Degraded(reason="budget")
try:
return fn(i) # i > 0 时带上 feedback / 换档
except Exception as e:
last = e
k = classify(e)
if k == "fatal" or k != kind: # 性质变了,原策略不再适用
break
if k == "transient":
sleep(min(0.5 * 2 ** i, 8) * random.uniform(0.5, 1.0)) # 退避 + 抖动
budget.spend(0) # 失败的那次也要记账
raise GiveUp(last)
四处关键点:TRIES 按类型给次数;只有 transient 才退避;k != kind 说明错误性质变了(比如原本是限流,重试时变成了认证失败),立刻停;失败的那次也要 spend,否则你的 trace 会少记一大块。
第三步:钱包
# src/reliability/budget.py
@dataclass
class Budget:
max_tokens: int
max_steps: int
deadline_at: float # 绝对时刻,不是"还剩多少"
spent_tokens: int = 0
steps: int = 0
def can_spend(self, est: int) -> bool:
return (self.spent_tokens + est <= self.max_tokens
and time.time() < self.deadline_at)
@property
def ratio(self) -> float: # 剩余比例 -> 驱动路由与降级
return 1 - self.spent_tokens / self.max_tokens
def spend(self, n: int):
self.spent_tokens += n
self.steps += 1
deadline_at 是绝对时刻,这是第二节第 4 条的落地:每一步拿到的是「还剩多久」,而不是「我还能用 30 秒」。
第四步:路由表
# src/reliability/router.py
TIERS = {
"extract": {"primary": "fast", "fallback": "fast"},
"research": {"primary": "strong", "fallback": "fast"},
"write": {"primary": "strong", "fallback": "fast"},
"judge": {"primary": "judge", "fallback": None}, # 不降级:降了就不可比
}
def pick(stage: str, budget: Budget) -> str:
t = TIERS[stage]
return t["fallback"] if (t["fallback"] and budget.ratio < 0.3) else t["primary"]
请单独看 judge 那一行:fallback: None。judge 不参与降级——它一降级,第 5 篇那条「分数跨时间可比」就断了。这是一个「宁可失败也不降级」的例子:评估数据的可比性,比这一次评估跑完更重要。
第五步:编排层接起来
# src/pipeline.py —— 改之后(节选)
def run_pipeline(user_input: str):
st = init_state(user_input)
b = Budget(max_tokens=60_000, max_steps=8, deadline_at=time.time() + 90)
degraded = []
def research_step(attempt: int):
return research.run(
st,
model=router.pick("research", b),
tools=registry.active_tools("read"),
feedback=st.feedback if attempt else None, # 重试要带新东西
idem_key=st.run_id, # 幂等键:重试不重复写
)
try:
out = with_retry(research_step, kind="semantic", budget=b)
except GiveUp as e:
if classify(e.last) == "transient":
degraded.append("L1:model") # 换小模型
out = research.run(st, model="fast", summary_ctx=True) # L2 减上下文
else:
return handoff_to_human(st, reason=classify(e.last), state=st) # L5
errs = gates.check_candidates(out.candidates, st.constraints)
if errs:
st.feedback = errs
...
result.tags += degraded # 降级标记进产物,不静默
trace.log_step(st, role="research", model=router.pick("research", b),
degraded=degraded, retry_of=..., tokens=..., ms=...)
return result
改完之后的对比
改之前(range(3) 硬重试) | 改之后(分类 + 预算 + 路由 + 降级) | |
|---|---|---|
| 429 限流 | 立刻重试 3 次,每次重发全量上下文 | 退避 + 抖动,重试计入预算 |
| 参数写错 | 重试 3 次,结果一模一样 | 一次就停,错误结构化回传 |
| 输出漏约束 | 重试,带的还是原 prompt | 带 gate 的具体错误重试 |
| 没权限 / key 失效 | 重试 3 次,可能触发风控 | 立即交给人 |
| 单次任务最坏成本 | 3 倍 | 钱包封顶 |
| 卡住 40 秒 | 用户干等,不知道发生了什么 | 流式 + 阶段状态 |
| 降级发生了 | 无从得知 | 标记进 trace 与产物 |
| 评估数据 | 降级结果混进基线 | 降级标记可筛除 |
| 用了哪个模型 | 不记录 | model 写进 trace |
| 超时 | 每层各 30s,最坏叠加 | 绝对 deadline 向下传 |
八、一份可以直接照着自查的清单
关于重试
- 你的重试逻辑是白名单还是黑名单?
- 每一次重试,第二次和第一次的区别是什么?说不出第二个区别的那次,删掉它。
- 瞬时错误有没有退避和抖动?没有抖动的话,一批任务会不会同时重试?
- 无变化的重试最多几次?有变化的重试最多几次?这两个数字是不是被写成了同一个?
- 每一次重试有没有记
retry_of?trace 上看不出重试次数的话,你的成本分析是错的。 - 写操作的重试有没有幂等键?重试时带的是不是同一个 key?(回第 3 篇)
关于降级
- 降级阶梯有几级?触发条件是写死在代码里,还是交给模型判断的?
- 降级会不会被记录?降级率是多少?长期 0% 是不是说明阈值太松?
- 降级有没有告诉用户?静默降级正在污染你的评估基线。
- L5 交给人时,带的是「失败了」三个字,还是 state + 已尝试记录 + 失败分类?
关于预算
- 预算是硬上限还是告警?超了之后是抛异常,还是交付部分结果?
- 预算剩 30% 和剩 10% 的时候,系统行为有什么不同?
- 有没有预检(pre-flight)?会不会等到中途才发现钱不够?
- trace 累加出来的 token,和平台账单对得上吗?对不上差多少?
- 重试是不是从同一个钱包里扣的?
关于路由和延迟
- 每个阶段的模型档位写死了吗?
model有没有写进 trace? - 上 escalate 之前测过小模型通过率吗?高于 70% 吗?
- 小模型的失败是可判定的吗?(没有 gate 就没有 escalate)
- judge 有没有被排除在降级之外?
- 延迟看的是均值还是 P95?P95 最近一个月涨了多少?
- 用户有没有在等一个全程静默的 40 秒?首字延迟是多少?
- 超时设了几层?整任务的 deadline 是不是一个向下传递的绝对值?
常见误区
误区一:给所有调用加了 3 次重试,就是高可用。 这是本篇最想反驳的一句。无差别重试是在买彩票——失败很少是随机的,同样的输入再来一次,大部分时候得到同样的失败,外加一份账单。真正提高成功率的是「换一种做法」,不是「再来一次」。
误区二:降级 = 关掉功能。 关掉功能,用户拿到的是「服务不可用」;降级应该是「用更保守的方式做完」,拿到一个能用但可能没那么好的结果,并且如实说明。这两者的差距就是「挂了」和「扛住了」的差距。
误区三:预算设成告警就够了。 没有硬上限的预算等于没有预算。半夜超支的时候,没有人会去看那条日志。而且「超出预警」的实现通常是打一行日志然后继续跑——你等于给了一个没有任何后果的约束。
误区四:换小模型一定省钱。 输入 token 才是大头,而换模型不会让你的上下文变小。先做第 1 篇的上下文治理和第 2 篇的按需召回,再来看路由。顺序反了,你会花很多力气做路由,然后看着账单没什么变化。
误区五:escalate(小模型失败再上大模型)总是划算。 失败的那次要付两份钱。小模型通过率低于 70% 的时候,escalate 比直接用大模型更贵。而且它还有一个前提:小模型的失败必须是可判定的——判不了,你就只能全都升级一遍。
误区六:静默降级。 最隐蔽的一个。降级结果混进评估集,你的分数就跨时间不可比了——第 5 篇花力气建立的基线会被它悄悄毁掉。而且它是那种「出事的时候你查不出来」的问题:三个月后你看到一个分数下跌,根本想不到原因是某天下午有 30% 的任务走了降级路径。
误区七:看平均延迟。 平均 3 秒、P95 28 秒,你的用户实际体验是后者。而且 P95 上涨通常是最早的退化信号——比结果指标早一周以上。
可靠性在整套系统里的位置
可靠性是保障层的第二块,而且它是唯一一块每一层都会用到、也都会反过来影响它的地方:
- 上下文工程(第 1 篇):P95 延迟上涨和 token 上涨,最先反映的往往就是上下文膨胀;L2 降级(减上下文)直接复用那里的压缩与「选」。顺带一句:上下文治理是本篇所有手段里省钱最多的一项。
- 记忆系统(第 2 篇):按需召回是输入 token 的第一大省法。另外,那里提到的
lesson类型记忆(教训)在本篇有了新用途——「这类失败重试没用」应当被记成一条 lesson,下次同类错误直接跳过重试。 - 工具设计(第 3 篇):错误语义是本篇错误分类的上游。工具说不清错误,编排层就分不了类,只能退回无差别重试。你在第 3 篇为错误语义花的力气,是在为这一篇省的钱。
- 编排(第 4 篇):重试、降级、预算、路由全部挂在编排层——因为只有它知道现在在第几步、还剩多少钱、还剩多少时间。
- 评估(第 5 篇):trace 里的
retry_of、降级标记、model、token 与 ms,就是本篇的全部输入数据。反过来,静默降级会毁掉评估的可比性——这是一个双向依赖。 - 人机边界(第 7 篇):L5 交接就是 gate 的终点;预算耗尽和连续降级失败,最终的出口都是交给人,而不是继续跑。
回到开头那个周三下午
那 6 条撞上 max_steps 的用例,每一条的 trace 都是同一个形状:429 → 重试 → 429 → 重试 → 429 → 掐断。它花了一整条任务的钱,产出是 0,而且它以为自己在解决问题。
改完之后,同样的场景是这样跑的:第一次 429 → 退避 1 秒重试 → 成功。如果连续两次都是限流 → 换小模型 + 精简上下文(L1 + L2)→ 完成,产物上带一个 degraded: ["L1:model"] 的标记,trace 上多一行 retry_of。如果换成权限错误 → 一次都不重试,直接带着 state 交给我。
两个版本的差别,不在于「它更不容易失败了」——它一样会遇到 429,一样会遇到没权限,一样会输出漏约束。差别在于它知道每一种失败该怎么办。
可靠性不是让系统不失败,是让失败有章可循:知道哪些值得救、救一次花多少钱、救不了的时候怎么收场。
在那之前,先做最小的一步:把你的重试逻辑打开,看一眼它有没有区分错误类型。如果没有,把 for attempt in range(3) 换成一次 classify()。
这一步几乎不花钱,而且它通常是整张成本账单上最立竿见影的一刀。
本系列目录
这是「Agent 工程进阶」系列的第 6 篇。
- 第 0 篇(地图):从 Demo 到可交付:如何做一个 Agent 项目
- 第 1 篇:上下文工程:为什么你的 Agent 越聊越笨
- 第 2 篇:记忆系统:Agent 怎么记住该记的,忘掉该忘的
- 第 3 篇:工具设计深水区:粒度、错误语义、幂等与 MCP
- 第 4 篇:编排与多 Agent:什么时候该拆,什么时候千万别拆
- 第 5 篇:评估体系:怎么知道你的 Agent 变差了
- 第 6 篇:可靠性与成本:什么时候该重试,什么时候该放弃(当前篇)
- 第 7 篇:人机边界:什么时候该问人,什么时候该放心让它做
新手系列入口(偏入门,建议先跑通第一个 Agent):先听懂:AI、LLM、Prompt、Agent、RAG、Tool、Memory 到底是什么
