自主体跑飞：重试级联200倍税

自主智能体最危险的特质不是它做错了什么，而是它会一直在做。一个聊天机器人出错，用户关掉对话框，损失止于一次请求；一个自主智能体出错，它感知、推理、行动、再循环——失败被它自己当成"还需再试一次"的信号。过去一年公开的生产事故勾勒出一条清晰的失控曲线：某团队的多智能体研究系统里两个 agent 陷入递归澄清循环，跑了整整十一天无人察觉，账单 $47,000；某 CI/CD 流水线里 500 个并发 Bug 修复智能体一夜烧掉 $25,000；一个被卡死在无限循环里的单 agent 三小时烧光 $14,000 的 API 额度。本文拆解这条曲线的微观动力学——单次重试为何能把 $2 放大成 $200、上下文为何是成本黑洞、"进展幻觉"如何让 agent 把时间戳变化误判为进度——并给出工程层面的熔断三件套（步数预算 / 语义收敛检测 / 毒丸预算）与 Agent Contracts 框架带来的 90% token 削减、525 倍方差压缩。

失控账单榜：谁在烧钱、烧了多久

案例	失控形态	存续时长	直接成本	根因
多智能体研究系统	递归澄清循环	11 天	$47,000	无停止条件、无预算上限、无实时监控
CI/CD Bug 修复集群	500 并发 agent "进展幻觉"	一夜	$25,000	时间戳变化被误判为进度，o1 每 10 秒一轮
单 agent 重试风暴	限流触发横向级联	3 小时	$14,000	朴素重试无退避，上下文逐轮重发
单次对话重试放大	429 限流 3 次重试	30 秒窗口	$2→$0.01	全量 8000 token 上下文重提交

注意这张表的横轴是时间：从 30 秒到 11 天，跨度近三万倍。自主性的代价不是"贵一点"，而是损失与存续时长近似线性增长——只要没人按下停止键，账单就一直在走。

多维对比：四种失控模式的工程画像

失控模式	成本放大机制	检测难度	基础设施层能否拦截	标准缓解
垂直放大（单工具重试）	上下文×重试次数	易	部分能（退避/jitter）	指数退避+抖动+Retry-After
横向级联（跨工具）	步骤间乘性放大	中	否（在推理层）	依赖图熔断、步数预算
影子重试环（LLM 自主重试）	绕过基础设施层	难	否	语义收敛检测、强制反思中断
递归委派（多 agent）	预算透传叠加	极难	否	守恒律约束、子合约预算

最危险的一栏是"基础设施层能否拦截=否"。传统的微服务熔断器（Hystrix、resilience4j）拦截的是 HTTP 调用，而 agent 的失控发生在推理层——LLM 看到工具返回失败，会自己决定再调一次，这形成了一条基础设施完全看不见的"影子重试环"。

深度分析

① 重试风暴的 200 倍经济学：上下文才是真凶

理解 agent 重试为何昂贵，关键在于一句话：每次重试都把整段对话上下文重新喂给模型。传统微服务重试成本是一次 HTTP 往返，agent 重试成本是 N 次 × 完整上下文窗口。一个带 8000 token 上下文的 agent 调用某工具拿到 429 限流，配 3 次朴素重试，结果是无控制情形下 4 次 LLM 调用、每次都发完整 8000 token，32,000 输入 token 烧掉却一事无成；加装熔断后仅 1 次调用约 8000 token 即快速失败。某生产团队在 API 故障窗口实测：无控重试 30 秒烧约 $2，熔断后降至约 $0.01——200 倍的成本压缩。成本数学彻底改变了重试的工程决策：在微服务时代"宁可多重试一次"是合理的，在 agent 时代"多重试一次"的边际成本被上下文放大了几个数量级。

② 横向级联：多步骤链路的乘性塌方

垂直放大只发生在一个工具内部，真正的灾难来自横向级联。当 agent 工作流是串行工具调用且第 N 步依赖第 N−1 步时，早期步骤的失败会沿依赖图向下游传染——每个后续工具都拿到残缺输入、各自失败、各自触发重试链。如果每步配 3 次重试且共 5 个依赖步骤，放大就是 3⁵ 量级。tianpan 给出的经典场景：一个支付处理失败触发了订单 agent 重试，订单 agent 又引发库存 agent 重试分配检查，库存服务被瞬间压垮——秒级内负载放大 10 倍以上。这解释了为何 $14,000 能在三小时内烧完：它不是线性燃烧，而是几何级数燃烧。这种级联与"工具链复利误差"是同一个拓扑结构的两面——精度维度是误差累积，成本维度是重试累积，根源都在步骤间的隐式耦合。

③ 五大计算浪费模式：40–70% 的预算去哪了

Paperclipped 的开发者级追踪指出，生产 agent 的 40–70% 计算预算不是花在复杂推理上，而是烧在五类可定位的浪费上：(1) 冗余工具调用——客服 agent 在不同推理步骤里查同一张订单三次，因为 LLM 在工具调用间不保留结构化状态；(2) 无退避重试风暴；(3) 上下文窗口膨胀——拖着用不到的对话历史；(4) 不澄清就臆测意图；(5) 廉价任务上的冗长推理——给一个本该 $0.02 的任务套了长思维链。这五类会复合放大：一个"冗余调用"嵌在"重试环"里又裹在"膨胀上下文"中，把 $0.02 的任务放大成 $2.00，即 10–20 倍。最立竿见影的修复是工具结果缓存，静态数据（配置、用户画像、策略文档）按任务期缓存，动态数据（股价、实时指标）用短 TTL，落地后通常消除 30–50% 的冗余调用：

class ToolCache:
    def __init__(self):
        self._cache = {}
    def get_or_call(self, tool_name, params, ttl_seconds=300):
        key = f"{tool_name}:{hash(frozenset(params.items()))}"
        if key in self._cache:
            entry = self._cache[key]
            if time.time() - entry["ts"] < ttl_seconds:
                return entry["result"]
        result = self._call_tool(tool_name, params)
        self._cache[key] = {"result": result, "ts": time.time()}
        return result

④ "进展幻觉"：为什么 agent 觉得自己在前进

CloudAtler 复盘的 Bug Fixer 案例揭示了一种最阴险的失控：agent 没有原地打转，而是真诚地相信自己取得了进展。场景是一个修 Python 脚本的 agent：编辑代码→跑单测→测试失败报 404→推理"我应该换个 URL 端点"→重试→测试又失败，但这次错误时间戳变了→agent 把新时间戳解读为"状态在变化=有进展"→继续循环。这是最致命的循环形态，因为它不会触发任何"重复"检测——每一步的输出都略有不同（时间戳不同），相似度阈值抓不到它。按 o1 约 $60/百万 token、每 10 秒一轮计算，单个卡死 agent 每小时烧 $20–50；放大到 500 并发 CI/CD 集群，就是一夜 $25,000。对策不是更严的步数上限，而是语义收敛检测：把每一步的"思考轨迹"向量化，计算当前步与前三步的余弦相似度，若 > 0.95 则判定为自我重复，强制触发 Reflect 中断或直接终止。

⑤ 预算耗尽：从工程缺陷到攻击向量

$47,000/11 天的案例把"失控"从工程失误升级为治理真空。arXiv 上的 Agent Contracts 框架把它定义为系统性缺口而非实现 bug：那个四智能体系统没有停止条件、没有预算上限、没有实时成本监控。这等价于一张可被外部输入触发的"预算耗尽攻击面"——只要攻击者能让 agent 进入任意循环，就能把受害方的 API 额度烧到上限。Gartner 据此预测 到 2027 年超 40% 的 agentic AI 项目会因成本失控或风险控制不足被取消，即便 agentic AI 到 2028 年将出现在 33% 的企业软件中。MIT Sloan 的同期调研显示已有 35% 的组织部署 agentic AI，而领导者最头疼的恰恰是"监督与自治之间的张力"。结论很硬：没有资源边界的自治等于开放式负债，必须用合约把"代理能消耗多少、运行多久"写死。

⑥ 熔断三件套：步数预算 + 语义收敛 + 毒丸预算

工程上阻止跑飞需要三层独立防线，任何一层都不够。第一层步数熔断在编排层（LangGraph/CrewAI）硬限制执行步数，多数可解任务在 5–10 步内完成，第 15 步基本可判定为幻觉或循环，早停能省掉约 80% 的浪费成本。第二层语义收敛检测抓步数上限抓不到的振荡（A→B→A→B）和"进展幻觉"。第三层毒丸预算最关键——永远不要给 agent 一张信用卡：实例化时分配 max_spend（如 $5.00），由 Helicone 或自建网关层实时追踪 token 用量，达到上限即硬切断：

MAX_STEPS = 15
def governance_node(state):
    steps = state.get('steps', 0)
    cost  = state.get('total_cost', 0.0)
    if steps > MAX_STEPS:              # Breaker 1: step limit
        return {"status": "error", "reason": "Step limit exceeded"}
    if cost > 2.50:                    # Breaker 2: budget cap ($2.50/run)
        return {"status": "error", "reason": "Budget cap exceeded"}
    return {"steps": steps + 1}

三层必须正交：步数能抓死循环，语义能抓振荡，预算是最终的、与模型无关的物理护栏——即便前两层都失效，毒丸预算仍能在 $2.50 处把账单物理截断。

⑦ Agent Contracts：90% token 削减与 525 倍方差压缩

把上面散件收束为系统的是 Agent Contracts 框架，它把 1980 年的合同网协议从"任务分配"扩展到"资源有界执行"。一个合约 C=(I,O,S,R,T,Φ,Ψ) 把输入输出规格、多维资源约束、时间边界和成功准则统一进一个带显式生命周期的治理机制；对多智能体场景，它建立守恒律——委派给子 agent 的预算必须服从父约束，从而层级化协调。跨四个实验的实证给出亮眼数字：迭代工作流中 token 消减 90%、方差降低 525 倍，多智能体委派中守恒律零违规。方差这个指标尤其关键——它意味着加合约后单次运行成本从"开盲盒"变成可预测区间，FinOps 才有了做预算规划的基准。其本质是把"尽力而为的推理"改造成"可审计、可预算的受控执行"。

自主智能体失控动力学与熔断拦截

flowchart TD
    A[Agent 调用工具] --> B{工具返回}
    B -- 429/超时 --> C[朴素重试: 重发完整上下文]
    C --> D[垂直放大 200x: $2→$0.01]
    B -- 失败 --> E[下游工具拿残缺输入]
    E --> F[横向级联 3的N次方]
    F --> G[多 agent 委派: 预算透传叠加]
    G --> H["进展幻觉: 时间戳变化误判为进度<br/>11天=$47,000"]
    D --> I{有无护栏?}
    F --> I
    H --> I
    I -- 无 --> J[账单线性增长至上限]
    I -- 有 --> K[第一层: 步数预算 MAX_STEPS=15]
    K --> L[第二层: 语义收敛 cosine>0.95]
    L --> M[第三层: 毒丸预算 max_spend=$5]
    M --> N[Agent Contracts 守恒律<br/>token -90%, 方差 -525x]
    N --> O[可审计受控执行]
    style J fill:#f4cccc
    style O fill:#d9ead3

图中上半部分是失控的三条放大路径（垂直、横向、幻觉），下半部分是三层正交护栏如何把盲盒账单收敛为可预测区间。关键洞见：左路（无护栏）的损失上限等于你的 API 余额，右路（有护栏）的损失上限等于 max_spend——两者的差，就是这套熔断工程的全部价值。

推荐方案

单 agent 脚本类任务：先上工具结果缓存（消除 30–50% 冗余调用）+ 步数硬上限（MAX_STEPS=15）。这是性价比最高的一步，半小时落地，立刻堵住最常见的死循环。

生产编排型（LangGraph/CrewAI）：三件套全上。步数预算在编排层、语义收敛检测挂在每步之后、毒丸预算放网关层。毒丸预算是底线——它和模型无关，换模型不会失效，是唯一能保证"$2.50 必停"的物理护栏。

多智能体集群：必须引入守恒律约束，否则子 agent 委派会形成预算透传黑洞。直接采用 Agent Contracts 式合约，把每个子 agent 的 max_spend 钉死在父预算内，并强制实时成本监控上墙（不是事后看账单，是运行时告警）。$47,000 案例的根本教训是：跑了 11 天才发现，说明监控是事后的、而非运行时的。

避免的反模式：不要用微服务时代的纯基础设施熔断器去拦 agent 失控——它看不见 LLM 自主发起的影子重试环；也不要只配单层护栏，步数上限抓不到"进展幻觉"，语义检测抓不到递归委派，必须三层叠加。最后，永远不要给任何 agent 一张没有上限的信用卡——这是 2025–2026 所有公开跑飞事故唯一共同的根因。