15|Agent 的成本总是悄悄飙升:创建网格化天眼账本
你好,我是李号双。
做过传统软件开发的工程师,对成本通常有一个非常直观的线性模型:用户请求量翻倍,服务器资源就会翻倍,成本也会跟着翻倍。这也是为什么做容量规划时,我们总习惯性地画一条直线。
但如果把这套直觉带到 Agent 系统里,往往就不适用了。
Agent 第一天上线,账单只有几块钱;第二天用户量稍微上来一点,账单跳到几十块;到了第七天,大模型厂商告警:API 额度已消耗 95%。你检查日志,既没有黑客攻击,也没有恶意刷接口 —— 只是一个用户提了一个模糊的需求,Agent 理解偏了,在那儿纠结,自我修正了二十多轮,Token 消耗是正常任务的几十倍。
Agent 的成本从来不是线性增长的,它是会“失控放大”的。
背后的根本差异在于:传统软件的计算路径是确定的,Agent 的计算路径是概率性的。大模型可能一步到位解决问题,也可能陷入“反思-重试-再反思”的死循环。每一次纠结,都是在烧钱。
所以,如果你不在架构层给 Agent 装上“计价器”,它就会变成公司服务器里一台静默运转的碎钞机。
根因:为什么 Agent 成本会失控
传统软件的成本为什么是线性的?因为每个请求的计算路径是固定的——收到请求、查数据库、返回结果,走的代码路径都一样,CPU 时间和内存消耗基本可预测。容量规划画一条直线,八九不离十。
Agent 完全不一样。同一个任务,大模型可能 3 步搞定,也可能绕 30 步。它可能用便宜的小模型一次成功,也可能反复切换到贵的模型还搞不定。它可能正常返回,也可能陷入死循环把 Token 预算烧光。
这种不确定性来自三个地方:
推理路径不确定:模型每一步选什么工具、要不要反思、要不要重试,都是概率性的。
子任务膨胀:主 Agent 派生出 Sub-Agent,Sub-Agent 又派生更小的 Agent,层级一深,Token 消耗指数级增长。
上下文膨胀:对话历史越长,每轮请求的输入 Token 越多,边际成本递增,第 40 轮的单次调用,输入 Token 可能是第 1 轮的 10 倍。
这三个因素叠加,导致 Agent 的成本不是“用户量 × 单次成本”的线性关系,而是“用户量 × 单次成本 × 失控系数”的非线性关系。失控系数可能是 1,也可能是 50。
所以成本治理的核心不是“省”,而是 把不确定性变成确定性——让每一分钱花在哪、为什么花、花得值不值,都能度量、能归因、能控制。
核心思想:经济学引擎,成本是运行时一等公民
绝大多数团队的初版做法是:调用完 LLM,拿到 usage 字段,存到数据库,晚上出报表。这叫“看总账”。
但在 Agent 体系里,看总账有两个致命盲区:
第一,Sub-Agent 的隐蔽性。 主 Agent 接到任务,往往不会自己干,而是派生出几个子 Agent(查日志、改代码、发通知)。这些子 Agent 各自跑几十轮,甚至调用更贵的模型。如果记账只盯着主 Loop,你只能看到主 Agent 花了几百 Token(用于生成分包指令),完全忽略了底下那些“分包商”烧掉的几万 Token。
第二,执行步骤的独立性。 复杂任务通常拆成多个 Step,比如“诊断→修复→验证”。每个 Step 消耗的资源截然不同——诊断可能只需一次工具调用,验证可能跑几百次测试。只看总账,你根本不知道哪个 Step 是“吞金兽”。
两个盲区指向同一个解法: 把记账提到架构一等公民的位置,和状态管理平起平坐。 每一个执行单元——主 Loop、Plan 的一个 Step、一个 Sub-Agent——都必须实时维护自己的微观账本,并且向上汇总。
这就像财务报表里的合并报表。子公司的亏损必须汇总到母公司,每一步执行的成本必须实时累加到任务总账。钱在哪里烧,就在哪里记;子任务烧的钱,父任务必须知道。
这就是经济学引擎的核心:成本不是事后看的账单,是运行时的核心约束,和状态、安全、可靠性平起平坐。整个引擎分四层转起来:
层级
干什么
核心能力
回答的问题
度量层
实时记账
网格化账本 + 单位任务成本 + 多维度归因
钱花在哪了
预算层
硬约束 + 动态调整
四轴熔断 + 动态预算 + 阶段性审批
超了怎么办
优化层
花在刀刃上
成本-质量权衡 + 模型路由 + 自动降级
怎么花更值
防御层
堵隐性浪费
前缀缓存 + 上下文排布 + 缓存命中率监控
哪些钱白花了
下面我来给你逐层说透。
度量层:单位任务成本 + 网格化归因
- 别只看总账,看单位成本
总账单随用户量增长是正常的,单位任务成本飙升才是问题。一个用户提了模糊需求导致 Agent 反思 47 轮烧 15 万 Token——这不是总账单问题,是这个任务的单位成本异常。
所以度量的核心不是“今天花了多少钱”,而是“每个任务花了多少钱、每个用户平均花多少、每个场景的单位成本是多少”。有了单位成本,才能做异常检测——某个任务的单位成本突然涨到历史均值的 5 倍,大概率是死循环或 Prompt 退化。
- 网格化账本:钱在哪 儿 烧就在哪 儿 记
单位成本要算得准,前提是每一步的成本都实时记录。在 Plan 执行器里,同一个 run 贯穿所有 Step, run.cost_usd 是实时累加的:
class PlanExecutor:
async def _execute_plan_events(self, plan, run, run_id):
for _ in range(len(plan.steps) * 3 + 5):
if plan.is_complete():
return
# 每轮开始前查账
check_budget(run, self._budget)
# 并发执行当前可执行的 Step,成本实时累加
ready = plan.get_parallel_ready()
await asyncio.gather(
*[self._step_runner.run_one(s, plan, run, run_id)
for s in ready],
return_exceptions=True,
)
# 每轮结束后再查一次
check_budget(run, self._budget)
关键在于:每轮循环前后都调 check_budget,任何一步烧超了立刻抛 BudgetExceeded 终止。不存在“等所有 Step 跑完才发现账单炸裂”这种事,钱在烧的当下就被拦住。
Sub-Agent 的账本也要折叠回父 Agent:
def fold_spawn_accounting(run, accumulator):
"""把子 Agent 的开销折叠进父 Agent"""
if accumulator.spawn_count == 0:
return
run.cost_usd += accumulator.cost_usd
run.turn_count += accumulator.turns
子 Agent 烧的钱,算在父 Agent 头上。只有这样,主 Run 账本上那个数字才是真实的痛感,而不是被掩盖的幻觉。
- 多维度归因:谁在烧钱
光有总数不够,还得能拆解。每个成本记录要带上维度标签:哪个用户、哪个任务类型、哪个模型、哪个 Step、有没有命中缓存。有了这些标签,你才能回答:
哪个用户是“烧钱大户”?(可能需要单独设更低的预算)
哪个任务类型的单位成本最高?(可能需要优化 Prompt 或换模型)
哪个 Step 是“吞金兽”?(可能需要拆分成更细的步骤或加缓存)
缓存命中率是多少?(命中率低说明上下文排布有问题)
归因能力是优化的前提——不知道钱花在哪,就不知道该优化哪。
预算层:四轴硬熔断 + 动态预算
钱才是硬约束,轮数只是参考
很多团队设一个“轮数上限”,比如 max_turns = 20。这能防住一部分死循环,但太粗糙了。因为轮数和钱不是线性的——前 5 轮用便宜模型每轮几分钱,第 6 轮突然切到昂贵模型加多模态识别,这一轮可能就烧几块钱。
所以预算结构体里必须有金额熔断线。轮数、时间、Token 数、金额四个轴全是硬熔断,任何一个越界都立刻停机。但它们地位不平等:轮数防死循环,时间防挂死,都是钱的粗糙代理;只有金额轴直接对应账单,是唯一不能靠“拍脑袋估轮数”推导的。
@dataclass
class HardBudget:
max_turns: int = 50 # 防死循环
max_seconds: float = 600 # 防挂死
max_tokens: int = 500_000 # 防 Token 爆炸
max_cost_usd: float = 5.0 # 核心:金额上限
def check_budget(run, budget):
if run.turn_count >= budget.max_turns: ...
if run.elapsed_seconds() >= budget.max_seconds: ...
if run.billable_tokens() >= budget.max_tokens: ...
if run.cost_usd >= budget.max_cost_usd:
raise BudgetExceeded(
f"预算耗尽: ${run.cost_usd:.2f} >= ${budget.max_cost_usd:.2f}"
)
这种设计把“省钱”变成了“保命”。 BudgetExceeded 和程序崩溃一个级别——立刻停机,不留情面。而且是分层阻断:主任务有总预算,子任务有子预算,子任务超了子任务停,主任务超了全家停。
动态预算:区分“马拉松”和“原地打转”
固定预算有个痛点:区分不了“合法的长程高消耗任务”和“非法的死循环”。让 Agent 调研前沿技术写深度报告,天然需要 30 步、20 万 Token;硬顶设 10 万永远出半成品,放开到 50 万遇到死循环又烧光预算。
解法是动态预算:不是一次性给满,而是按里程碑分批给。
初始预算:给一个基础额度(比如 5 万 Token),够完成大多数常规任务。
进度评估:Agent 每完成一个里程碑(比如“已完成调研”“已生成初稿”),可以申请追加预算。评估器检查进度是否真实推进——如果最近 5 轮没有新的工具调用、没有新的信息获取,只是在反复反思,申请被拒。
阶段性审批:大额追加(超过初始预算的 2 倍)需要人工确认。审批人看到“已完成 3 个里程碑,当前进度 60%,追加后预计总成本 $3.5”,可以判断值不值得继续投。
动态预算的核心是 用进度换预算。真正在推进的任务,预算会源源不断;原地打转的,到点就断粮。这比固定预算聪明得多,也比完全放开安全得多。
优化层:成本-质量权衡,把钱花在刀刃上
度量和预算解决的是“别超支”,优化层解决的是“怎么花更值”。这里最容易犯的错是一味省钱——便宜模型可能导致更多重试,总成本反而更高。
模型路由:简单的活别用贵模型
不是所有任务都需要最贵的模型。查个订单状态、转个格式、提取个字段,小模型完全够用,成本是大模型的十分之一甚至百分之一。
模型路由的思路是:在任务进入执行前,先做一个轻量级的“难度评估”——这个任务需要推理吗?需要长上下文吗?需要多模态吗?根据评估结果选模型:
任务类型
典型操作
推荐模型档
成本对比
简单结构化
格式转换、字段提取
小模型
1x
常规推理
总结、分类、翻译
中模型
5x
复杂推理
代码生成、多步规划
大模型
20x
多模态
图片理解、图表分析
多模态大模型
50x
路由不是一次性的。执行过程中如果小模型搞不定(连续两次重试失败),自动升级到更大的模型。这叫“渐进式升级”——先试便宜的,不行再加码,而不是一上来就用最贵的。
自动降级:预算紧张时的生存策略
当预算用到 80% 时,系统应该自动进入降级模式:
模型降级:大模型切到中模型,接受质量下降。
工具降级:跳过昂贵的工具调用(比如网页搜索),只用本地知识库。
上下文压缩:对历史对话做摘要,减少每轮输入 Token。
提前交付:用当前已有的结果做一个“最佳努力”的回复,而不是继续烧钱追求完美。
降级的核心思想是: 在预算约束下最大化产出质量,而不是追求无限质量。 用户拿到一个 80 分的结果,总比 Agent 烧光预算后什么都拿不到强得多。
成本:质量权衡的本质
说到底,成本治理不是越省越好,是找到成本和质量的平衡点。这个平衡点因业务而异:
客服场景:单次任务成本上限 $0.5,质量要求 80 分(能解决大多数问题就行)。
代码审查场景:单次任务成本上限 $5,质量要求 95 分(漏一个 bug 损失更大)。
研究报告场景:单次任务成本上限 $20,质量要求 90 分(深度比速度重要)。
每个业务线根据自己的损失模型定出“愿意为 1% 质量提升付多少钱”,经济学引擎根据这个偏好自动调整路由和降级策略。这才是真正的“把钱花在刀刃上”。
防御层:堵住隐性浪费
度量、预算、优化管的是“显性成本”,还有一类“隐性成本”最让人心痛,那就是花了本来可以不花的钱。最典型的就是缓存粉碎机。
时间戳陷阱:一行代码废掉所有缓存
最心痛的浪费,就是 System Prompt 里的一个动态时间戳。如果你写了 当前时间:{datetime.now()},这行代码会让后面几千 Token 的静态指令全部无法缓存。原本几万次请求能共享的折扣,瞬间变成每次全额付费。
上下文组装的原则不是笼统的“静态在前、动态在后”,而是一条更精确的判据: “只追加、不改写”的内容放前面,“每轮都重写”的内容放最后。
按这条判据,真实发送给 LLM 的上下文结构是这样的:
L0 宪法层(最前):系统指令、核心约束。以独立 system 字段发送,永不压缩,极少变动——是 Prompt Cache 命中的基石。
工具定义(紧跟 L0):随版本更新、单次会话内静态,通常几千 Token,跟着前缀一起吃缓存红利。
L3 历史层(messages 前部):历史对话和工具返回日志。append-only——老消息永不改写,新对话只往后追加。天然成为稳定前缀的主体,缓存断点打在最后一条历史消息上。
L2 记忆层 / L1 状态层(最后):RAG 检索片段、长尾记忆、当前执行状态。每次请求都可能不同,统一甩到上下文最尾部。
缓存命中率本身也要纳入度量层监控——命中率突然下降,说明有人改了 Prompt 结构或者加了动态内容,得立刻查。
和体系打通:成本账本是运行时状态的一部分
经济学引擎不是孤立的,它和整个 Agent 工程体系共享状态和数据:
和容错体系共享状态:成本账本就是 容错那一课 里 AgentRun 六层状态的第二层(会计账本)。崩溃恢复后,Token 计数和成本累计不会清零,预算熔断依然有效。
和监控体系打通:每次预算检查、每次模型路由、每次降级决策,都作为事件记录在 Trace 上。你在监控面板看到一条失败 Trace,能同时看到“这条任务花了 $3.2,其中 Sub-Agent 占 $2.8,第 7 轮触发了降级,缓存命中率 45%”。
和安全体系联动:单位成本异常飙升(比如突然涨到历史均值的 10 倍),可能是提示词注入导致的异常行为,触发安全课的行为可信度评估。成本异常是安全事件的早期信号。
成本、状态、监控、安全——四套体系共用同一个运行时状态,在同一个 Trace 里交汇。这就是企业级 Agent 工程体系的样子:不是一堆独立的工具,是一个有机整体。
全景图:一分钱的旅程
任务到达
│
▼ 度量层:初始化微观账本,记录任务类型/用户/模型
│
▼ 优化层:难度评估 → 模型路由(简单→小模型,复杂→大模型)
│
▼ 预算层:分配初始预算,四轴熔断就位
│
├─ 执行中:
│ ├─ 每轮前后查账(事前阻断)
│ ├─ Step 成本实时累加,Sub-Agent 账本折叠回父
│ ├─ 预算 80% → 自动降级(模型降级/工具降级/上下文压缩)
│ ├─ 完成里程碑 → 申请追加预算(进度评估,原地打转被拒)
│ └─ 缓存命中率实时监控(命中率骤降→告警)
│
▼ 任务结束:
│ ├─ 计算单位任务成本
│ ├─ 多维度归因记录(用户/任务类型/模型/Step/缓存命中)
│ └─ 成本事件写入 Trace
│
└──→ 异常检测:单位成本超阈值 → 告警 + 触发安全行为评估
总结
Agent 的成本控制,本质上是把“不确定性”变成“确定性”。这一讲其实只做了一件事:把 Agent 运行时的钱,从事后看的账单变成运行时的核心职责。
具体做法是四层经济学引擎:
度量层:网格化账本,Sub-Agent 开销折叠回父 Run,每个 Step 前后都查账,核心指标是单位任务成本而不是总账单。
优化层:成本-质量权衡,模型路由让简单的活别用贵模型,预算紧张时自动降级,在约束下最大化产出质量。
预算层:四轴硬熔断(轮数/时间/Token/金额),金额是核心约束;动态预算按里程碑分批给,用进度换预算,区分马拉松和原地打转。
防御层:前缀缓存钉死,动态内容甩到尾部,缓存命中率纳入监控,堵隐性浪费。
下次再看账单上那个数字,希望它背后是一张你能拆解到每一步、每个子 Agent、每个缓存命中与否的明细表,而不是一团说不清的模糊数字。
Agent 的可靠性不来自模型更聪明,来自围绕模型的工程更可靠。成本也一样——不来自模型更省钱,来自围绕模型的经济学引擎更精密。
思考题
我们用“单次任务预算熔断”解决了死循环烧钱的问题,又用“动态预算”尝试区分合法长任务和非法死循环。但动态预算的进度评估本身有个难题:怎么判断 Agent 是“真的在推进”还是“假装在推进”?
假设 Agent 为了骗取追加预算,每轮都调用一个“看起来有进展”的工具(比如反复搜索不同关键词),但实际上没有获取任何新信息。它的动作指纹在变,工具调用在增加,可任务实质没有推进。
请你设计一个“进度真实性评估器”,能区分“真实推进”和“表演式忙碌”。给你一个提示:单独看每轮调用都是无辜的,但把一串调用的信息增益放在一起看,会留下痕迹——真正的推进会带来新的状态变化、新的知识获取,而表演式忙碌只是在重复已知信息的不同排列。
欢迎你在留言区留下你的设计,如果你有所收获,也欢迎你分享给需要的朋友,我们下节课再见!