14|Agent 挂了,如何不丢状态、不丢钱、不丢数据地拉起来?
你好,我是李号双。
我们先来看一个 Agent 容错最常见的写法:
# 经典的无限重试大法
while True:
try:
response = agent.run(task)
return response
except Exception as e:
print(f"Agent 报错了:{e},正在重试...")
time.sleep(5)
continue
跑起来没问题,偶尔网络波动也能自动挺过去。然后你把它推上生产环境,接了个真实业务:让 Agent 处理用户的退款请求,涉及查订单、调支付接口、发通知。支付接口的 API 密钥被风控系统回收了,返回 403 Forbidden。
Agent 捕获异常,开始重试;5 秒后,再次 403;继续重试……两小时后,你发现:
丢钱了:第 17 次重试时,防重放机制因并发重试存在 Bug 而失效,一个退款请求扣了两次款。
丢状态了:重启后失忆。订单查了又查,退款通知发了又发,一切从零开始。
丢数据了:重试的间隙,Agent 把上下文撑爆了,更早的对话历史被滑动窗口截断,关键的用户诉求丢失。
问题出在哪?大多数人理解的容错,就像车熄火了——不管是没油了、爆胎了还是发动机炸了,只会闭着眼疯狂拧钥匙,暴力重试。这招在传统软件里勉强能用,但在 Agent 里就行不通了。网络波动(瞬态故障)重试可以,权限错误(永久故障)重试没用,因为重试解决不了问题。
根因:状态和计算绑在一起了
为什么那个无限重试的写法会丢钱、丢状态、丢数据?往下挖一层,你会发现根源是一个架构问题: Agent 既当爹又当妈,同时背负了大模型推理和业务流程状态管理。
对话历史存在内存里的 Python 对象中,工具返回值存在同一个对象的字段里,重试计数器是个局部变量,待审批的动作挂在实例属性上。进程一死,这些东西灰飞烟灭。重启后,Agent 是一个全新的对象,它不知道自己刚才在干什么、干到哪了、哪些工具已经调过了。
这就像你在玩一个没有存档功能的游戏,打到最终 Boss 前电脑蓝屏了,你只能从第一关重新打。更惨的是,游戏里的 NPC 不记得你已经做过什么——你已经交过的任务会被要求再交一次,已经打过的小怪会重新刷出来。
所以容错的核心不是“加重试”,而是回答一个更根本的问题: Agent 挂了之后,怎么让它装作什么都没发生过?
答案是:把状态从 Agent 进程里彻底剥离。
核心思想:状态外置,Agent 变无状态 Reducer
业界成熟的生产系统早就给出了答案:Agent 本身应该是一个无状态的 Reducer。
什么意思?Agent 只负责一件事——根据当前状态,计算下一步该做什么。它不负责“持有当前状态”。状态必须全外置,托管给可靠的持久化存储。
只要存储不挂,Agent 随便挂。进程崩溃后重新拉起来,从存储里加载出刚才的状态,它就能接着干。这才是容错的真谛:崩溃恢复不是用户的事,是平台的事。
这个思想不是什么新发明。函数式编程里叫“纯函数 + 不可变状态”,事件溯源里叫“Event Log 重建状态”,数据库里叫“WAL 前滚恢复”。Agent 容错就是这些成熟思想在 LLM 场景的落地—— 所有容错能力,都是“状态可重建”这一个原则的推论。
容错能力
依赖什么状态
没有状态会怎样
崩溃恢复
完整六层状态快照
失忆,从零开始
安全重试
动作指纹计数 + 崩溃现场
永久故障被反复重试
不重复扣款
稳定幂等序号
重跑时键变了,重复执行
熔断降级
工具失败率统计
级联故障拖垮全链路
预算控制
Token 和成本账本
崩溃后账本清零,爆预算
看懂了这张表,后面的内容就顺了:先搞清楚状态里到底有什么,再看怎么存,最后看基于这些状态能做哪些容错。
状态解剖:六层结构,缺一不可
很多人以为“状态”就是那份 第 8 课 讲的 Plan-DAG 计划。实际上,一个 Agent Session 的状态是一个多层结构,每一层都有独特的意义。Plan-DAG 只是其中一层。我们一层层剥开看。
第一层:推理轨迹——LLM 的记忆
这是最基础的一层。LLM 本身是无状态的,它做决策的唯一依据就是你喂给它的上下文。这个上下文不只是用户说了什么,还包括 Agent 自己之前的思考过程、调过什么工具、工具返回了什么结果。
不存这一层,进程一崩,Agent 彻底失忆。恢复后用户说“继续”,它会一脸懵:“继续什么?咱们刚才聊到哪了?”不得不重新问用户订单号,重新查订单状态。更可怕的是,如果之前的工具调用有副作用(比如已经发过一次通知),Agent 失忆后会再发一次。这层是 Agent 运行的“黑匣子”,丢了它就丢了整个历史。
第二层:会计账本——烧了多少钱
Agent 是按 Token 计费的“烧钱机器”。你得实时记录:当前跑了多少轮、花了多少钱、用了多少 Token。不存的话,崩溃后账本清零。监控面板显示“本次运行花费 $0.5”,但实际上 Agent 崩溃前已经跑了 50 轮,花了 $20。预算熔断直接失效,你可能因此爆预算。
第三层:动作指纹——熔断防线
假设 Agent 崩溃前已经查了 4 次 order_123(不存在),正准备查第 5 次时崩了。重启后计数器变回 0。Agent 看到之前的报错记录,心想:“刚才没查到,也许这次能查到?”于是又开始查第 1 次……第 5 次……再次触发熔断,再次崩溃。每次恢复都会陷入一次死循环,直到烧光 Token。
所以每个工具调用的指纹(工具名 + 关键参数)和调用次数必须持久化。恢复后计数器还是 4,第 5 次直接触发熔断,不会从头再来。
第四层:待审批动作——暂停键的位置
在 HITL(Human-in-the-loop)场景下,Agent 要停下来等人工审批。比如它想执行高危操作“删除数据库”,被拦截进入 SUSPENDED 状态。不存这个待审批动作,崩溃恢复后 Agent 不知道自己刚才停在哪、在等什么。它可能直接跳过审批继续跑,或者卡住不动。这层是“暂停键”的位置,丢了就找不到暂停点。
第五层:崩溃现场——判决书
如果不存崩溃现场,恢复后 Agent 只看到历史日志里有一个工具执行失败记录。它不知道这个故障是永久的还是瞬态的,可能会想:“哎呀,刚才好像挂了,现在重启了,也许只是瞬态问题?再试一次吧。”于是把永久故障当成瞬态故障又处理一遍。
所以 last_error 必须存下来,而且要带上分类标签(retryable / not_retryable / should_fallback),告诉恢复后的 Agent:“别试了,这个错误重试也没用。”
第六层:计划锚点——配合 Event 绳索
这一层正是 第 8 课 讲的 Plan-DAG 状态。但在这里,它只是六层状态之一。把这六层焊进代码,就得到一个生产级的 AgentRun 状态定义:
@dataclass
class AgentRun:
run_id: str
task: str
# 第一层:推理轨迹(LLM 的记忆)
messages: list[Message]
tool_history: list[ToolCall]
# 第二层:会计账本
turn_count: int
input_tokens: int
output_tokens: int
cost_usd: float
# 第三层:动作指纹(熔断防线)
fingerprint_counter: dict[str, int]
# 第四层:待审批动作
pending_tool_call: ToolCall | None
# 第五层:崩溃现场(判决书)
error: ClassifiedError | None
last_error: ClassifiedError | None
# 第六层:计划锚点(配合 Event 绳索)
plan_state: dict | None
plan_last_seq: int
idempotency_seq: int # 副作用发号器
怎么存:Checkpoint 锚点 + Event 绳索
明确了“要存什么”,接下来是“怎么存”。这里有个工程上的经典矛盾:
全量快照:恢复极快,直接读出来就能拉起现场。但存储成本高,每一步都写全量快照,IO 会拖慢 Loop。
事件重放:存储极省,只记动作流。你可能担心重放要把历史重新跑一遍、再花一遍 Token?不会。重放是确定性的 Reducer 逐条应用事件,全程不经过大模型,一个 Token 都不用花。它真正的代价是慢——耗时随事件条数线性涨。
生产级系统用混合策略,这也是公认的做法:
async def hybrid_restore(run_id, event_log, checkpoint_store, reducer):
# 第一步:拉起锚点(全量六层快照)
run = await checkpoint_store.load(run_id)
# 第二步:补拉绳索(仅重放存档点之后的增量事件)
missed = event_log.get_after(run_id, since_seq=run.plan_last_seq)
for event in missed:
reducer(run.plan_state, event) # 原地修改,不经过 LLM
这就像玩游戏存档:Checkpoint 是完整的存档文件(人物等级、装备、坐标),Event Log 是存档点之后的录像。你不需要重打每一关,直接读存档,再补看一小段录像就行。
Checkpoint 多久存一次?这不是拍脑袋的,由两个指标决定:
RPO(恢复点目标):最多能接受丢失多少进度。RTO 由 Checkpoint 间隔直接决定:每步都存,恢复时几乎不用重放;每 10 步存一次,崩溃后最多重放 9 条事件,恢复时间随间隔线性增长。
RTO(恢复时间目标):崩溃后多久必须恢复。Checkpoint 间隔越大,恢复时要重放的 Event 越多,RTO 越长。
这两个指标由业务决定。资金流水通常要求 RPO=0,也就是说已确认交易不能丢失;这不仅要靠 Checkpoint,还要靠幂等键和事件同步持久化。内部工具如果能接受丢失最近 10 步进度,就可以设 RPO=10 步,并每 10 步存一次 Checkpoint。RTO 则按业务 SLA 确定。
基于可重建状态的容错能力
状态能重建了,容错能力就自然长出来了。下面三个是最核心的,我们一起来看一下。
故障分类:重试要看人下菜碟
模型为了完成任务天生倾向于重试,如果你把裁决权完全交给概率模型,它会把一个永久故障试 N 次,直到耗尽 Token 预算。所以工程代码必须充当法官,强制把错误分类:
故障类型
典型场景
模型的直觉(错)
代码的判决(对)
瞬态故障
网络 500、API 限流 429
再来一把
指数退避重试,设上限
永久故障
403 无权限、400 参数错
换个参数蒙一把
立即中止,抛出异常
降级故障
主模型限流、备用可用
死磕原模型
降级路由,切备用模型
级联故障
DB 挂了→依赖全挂
再调一次工具试试
熔断,停止所有无用请求
分类结果存在第五层状态(崩溃现场)里。恢复后 Agent 看到 last_error 的分类是 not_retryable,就不会傻傻重试了。这就是“状态可重建”带来的好处——故障分类的结果能跨进程传递。
exactly-once:不丢钱的终极答案
状态都恢复了,Agent 知道自己刚才在干什么。但还有个隐蔽的坑:虽然状态恢复了,钱还是可能丢。
场景是这样的:Agent 记了一条 StepStarted(我要调退款接口了),紧接着调用支付接口——钱扣了——但在写 StepCompleted 之前进程崩了。日志里躺着一条悬挂的 StepStarted。恢复时框架看到它,公认的选择是“重跑”而不是“跳过”,因为跳过可能漏执行一个其实没成功的动作,风险更大。
既然要重跑,“不重复扣款”的担子就落下来了。这里有两道防线:
async def safe_execute(call, run):
# 防线一:Agent 侧(意图)—— 防死循环烧钱
is_loop, reason = detect_infinite_retry(run, call, threshold=5)
if is_loop:
raise InfiniteLoopDetected(reason)
# 防线二:工具侧(事实)—— 防重复扣款
key = f"{run.run_id}:{run.idempotency_seq}"
return await execute_payment(call, idempotency_key=key)
防线一靠第三层状态(动作指纹),防线二靠第六层状态里的 idempotency_seq。
这个序号是关键——它存在持久化状态里,跟着 Checkpoint 一起落盘。存档那一刻是 2 号,崩溃重跑时还是 2 号,支付网关认出“这个号处理过”,原样返回上次的结果,款不会扣第二次。
这里最容易犯的错,是用“当前是第几轮”来算幂等键。为什么不行?崩溃后重跑,Agent 往往又烧了几轮 LLM,轮次变了,算出来的键也变了。外部系统一看是新键,照单全收,幂等防线形同虚设。 幂等键必须来自持久化状态里的稳定序号,不能来自运行时变量。
把这件事拔高一层说:Agent 系统天然是 at-least-once(重试导致重复执行),要实现 exactly-once(精确一次),需要三个条件同时满足:稳定的幂等键、外部系统支持幂等、Agent 侧指纹去重。三者缺一,“不丢钱”就是一句空话。
熔断降级:别让一个故障拖垮全链路
故障分类处理的是单次调用,熔断处理的是趋势。如果某个工具在短时间内连续失败 10 次,说明它可能已经挂了,继续调用只会浪费 Token、拖慢整个链路。这时候应该熔断,在一段时间内直接拒绝调用这个工具,要么降级到备用方案,要么中止任务。
熔断的统计数据(每个工具的失败率、连续失败次数)存在第三层状态(动作指纹)里。恢复后这些数据还在,不会因为崩溃就重置计数器——否则一个工具刚好在崩溃前连续失败了 9 次,恢复后又从 0 开始算,永远触发不了熔断。
混沌工程:别等故障来了才验证
容错体系搭好了,怎么知道它真的管用?最靠谱的办法不是等线上出故障,而是主动注入故障测试。这就是混沌工程。
你需要定期做这些演练:
杀进程:在 Agent 跑到第 7 步时 Kill 掉进程,验证恢复后是否从第 7 步继续,而不是从头开始。
模拟工具超时:让支付接口 100% 超时,验证熔断是否触发、降级是否生效。
模拟网络分区:Agent 和状态存储之间断网,验证 Agent 是否优雅降级而不是数据损坏。
模拟重复投递:同一个工具调用被执行两次,验证幂等键是否生效、钱有没有被扣两次。
每次演练都要验证 RTO 和 RPO 是否达标。如果杀进程后恢复用了 15 秒而 RTO 是 5 秒,说明 Checkpoint 恢复或 Event 重放有性能问题,得优化。混沌工程的价值就在于: 在业务低峰期主动把故障演一遍,比在业务高峰期被动挨打好得多。
全景图:一次崩溃的恢复之旅
Agent 正常运行中
│ 每 N 步写一次 Checkpoint(六层全量快照)
│ 每个动作写一条 Event
│
▼ 进程崩溃
│
▼ 重启
│
├─ 加载最近的 Checkpoint(恢复六层状态)
│ ├─ 推理轨迹:消息、工具历史
│ ├─ 会计账本:Token、成本
│ ├─ 动作指纹:调用计数(熔断依据)
│ ├─ 待审批:暂停点
│ ├─ 崩溃现场:last_error 分类(决定是否重试)
│ └─ 计划锚点:plan_state + idempotency_seq
│
├─ 重放 Checkpoint 之后的 Event(不经过 LLM)
│
├─ 检查 last_error:永久故障?中止。瞬态故障?指数退避重试。
│
├─ 检查熔断:某工具连续失败?熔断或降级。
│
└─ 继续执行,幂等键 = run_id + idempotency_seq(稳定不变)
总结
回到开头那三个灾难,现在都有解了:
丢钱:动作指纹熔断死循环,稳定幂等键 + 外部系统幂等防重复扣款,三者合起来实现 exactly-once。
丢状态:Agent 变无状态容器,六层状态全外置,崩溃后从 Checkpoint 恢复。
丢数据:推理轨迹持久化,上下文不会因为进程重启而丢失。
Agent 容错的终极形态,是把系统从“一条道走到黑的单线程”变成“步步为营、随时存档的游戏”。模型负责想,循环负责做,状态全外置负责记,重试时看人下菜碟——四件事各司其职,谁也别越界。
而这一切的根基,就是那一个原则: 状态可重建。 只要状态能从存储里完整拉回来,Agent 挂多少次都不怕;如果状态绑死在进程里,加再多重试和检查点都是治标不治本。
思考题
我们用六层状态 + Checkpoint/Event 解决了“随时崩溃、无损续跑”。但有个场景:Agent 处理一个高额退款请求,查询订单状态为“已发货”,于是将完整 Session 序列化为 Checkpoint,进入 SUSPENDED 等待审批。审批人在开会,2 小时后才批准。
Agent 从 Checkpoint 恢复,继续执行退款。但这 2 小时内,物流系统已把订单更新为“已签收”,业务规则规定“已签收订单需走售后返修,不可直接全额退款”。
问题:Agent 手里的 Checkpoint 是 2 小时前的“绝对真理”,但执行时物理世界已变。直接恢复执行会导致基于过期状态的危险操作。在“长时间挂起 + Checkpoint 恢复”的架构下,你怎么防范这种“状态过期”?是恢复后强制重新校验前置状态,还是在外部系统加锁?如果重新校验发现状态已变,这算执行成功还是失败?
欢迎你把想法分享到留言区,如果你觉得有收获,也欢迎你分享给需要的朋友,我们下节课再见!