上一篇结尾我给了个建议:长任务如果等不完,不如拆成几个短工具,让模型自己串起来。
理由写得很顺:不需要任务原语、不需要持久化 store、中途失败只重跑最后一步、模型还能看到中间结果改主意。代价我也提了一句------"模型得多调几次工具,多花点 token"。
这句话写得太轻了。
这次我真的拆了一遍,把账单量出来:同一个任务,拆成三个工具之后,累计 prompt 从 569 tokens 涨到 4194,7.4 倍。 而省下的恢复时间,只有 300 毫秒。
这篇文章就是把这三笔账摊开------token、时间、恢复代价------然后回答一个问题:什么时候拆值,什么时候拆是自残。
先说实验怎么做的
同一个「生成周报」的任务,三种形态,同一份数据(本周 5 篇笔记,7 个标签):
scss
// A:一个长工具,内部串三步
build_weekly_report() // 拉笔记 → 聚类 → 写正文
// B:三个短工具,模型自己串
fetch_week_notes() → cluster_notes() → write_report()
// C:任务原语
build_weekly_report_task() // 返回 taskId,客户端轮询
三条路走的是同一段生成逻辑,所以出来的周报逐字相同。唯一的变量是谁在什么时候调用。
账单口径是客户端实际发出去的东西:system prompt + 全部历史 + 工具清单。tool_call 和工具返回都要在下一轮重新发一遍,所以每轮都算一次。分词用 js-tiktoken 的 cl100k_base,离线精确计数,不调 API。
模型那一步用的是本地假 LLM,按剧本返回工具调用------这点跟前几篇一样,MCP 链路是真的,模型决策是脚本给的。所以下面的数字反映的是协议和上下文的成本,不掺模型的随机性。
第一笔账:拆解把「过程」搬进了上下文
三份账单:
yaml
方案 A 长工具 请求 2 次 每轮 prompt 151 → 418 累计 569
方案 B 三个短工具 请求 4 次 每轮 prompt 265 → 1028 → 1318 → 1583 累计 4194
方案 C 任务原语 请求 2 次 每轮 prompt 146 → 414 累计 560
B 是 A 的 7.37 倍。
拆开看每一轮为什么涨:
yaml
第 1 轮 265 工具清单 187 + system/user 78
第 2 轮 1028 ← fetch_week_notes 返回了 650 tokens 的笔记列表,全进了上下文
第 3 轮 1318 ← 又加进 cluster_notes 的 184 tokens
第 4 轮 1583 ← 又加进 write_report 的 215 tokens
第 2 轮那一跳是 763 个 token,比第 1 轮整个 prompt 还大。原因很朴素:fetch_week_notes 返回了 5 篇笔记的完整 JSON(1173 个字符),而它必须被重发。
这个过程数据被付了几次钱
fetch_week_notes 那 650 个 token,在后面的每一轮都要重新发一次:
第 2 轮 付 1 次
第 3 轮 付 1 次
第 4 轮 付 1 次
合计 3 次,1950 tokens
而它在 A 方案里,从头到尾都在服务端的内存里,一次都没进模型上下文。这就是 7 倍差距的主要来源:不是调用次数多了两次,是过程数据被复制了三遍。
我在第七篇算过一笔账,说工具返回属于"累积成本"------一条 3445 tokens 的返回在 6 轮会话里被收 6 次钱。当时说的是单个工具返回太大。这次是另一个版本:拆解本身就在制造大返回,而且是故意的------因为中间结果必须交给模型,它才能决定下一步。
顺带一个结论:任务原语和长工具在账单上没区别
A 是 569,C 是 560,差 9 个 token。
这说明一件事:对模型来说,"一个跑 900 毫秒的工具"和"一个返回 taskId 的任务工具"是同一件事------都是一次调用拿到最终结果。 任务原语解决的是服务端的生命周期问题(超时、重启、取消),不是上下文问题。
两个维度得分开看,别指望一个方案同时解两个问题。
第二笔账:拆解连时间都更慢
css
A 960ms
B 1282ms
C 1046ms
B 比 A 慢了 33%。原因不是干活慢,是模型往返多了两次。每一步都要停下来问模型"下一步干什么",这个停顿比你省下的计算时间贵得多。
这个结果有点反直觉:拆解通常被描述成"让每一步更轻快",但实际体验是整体更慢。因为轻快的是单次调用,慢的是它们之间的空隙。
第三笔账:恢复代价,这是拆解唯一赢的地方
我让第三步(写正文)在第一次调用时抛错,然后看两种方案各要重跑多少。
A 方案:
ini
第一次 910ms isError=true 生成正文时模型网关 503
第二次 910ms isError=false 本周共 5 篇笔记,覆盖 7 个标签。
整个工具重跑。前两步明明已经成功,但那些结果在服务端的内存里,客户端一个都拿不到,只能全部重来。
B 方案:
ini
fetch 307ms 返回 1173 字符
cluster 307ms 返回 440 字符
write 607ms isError=true 生成正文时模型网关 503
write 重试 606ms isError=false
只补失败的那一步。
对比:910ms vs 606ms。
看着拆解赢了,但赢得很小------因为每步只有 300 毫秒。如果把每步的耗时放大到 30 秒(真实的大模型任务就是这样),A 是 90 秒,B 是 30 秒,差距才变成 3 倍。
而代价是 7 倍的 token,每一轮都在付。 恢复只在失败时发生一次,token 是每次调用都在烧。这笔交换划不划算,取决于你的失败率和单步耗时,不取决于架构图好不好看。
还有一个没算进去的成本:B 方案在成功路径上也是 4 轮,也就是每天正常运行都在多付 7 倍的钱,只为了一天可能遇到一次失败。
拆解还有一个更麻烦的问题:顺序不由你定
这部分是我做完实验才想明白的。
A 方案里,「先拉数据、再聚类、最后写」是代码里的顺序,模型碰不到。B 方案里,这个顺序只是工具描述里的一句建议。
我做了一个实验:让模型跳过前两步,直接调 write_report。
结果:
csharp
[tool] write_report 返回 123 tokens,此刻累计账单 244
本周共 5 篇笔记,覆盖 0 个标签。 分布:。
isError 是 false,调用返回成功,内容是残缺的。 "覆盖 0 个标签,分布:。"------数据是空的,但工具很诚实地报了成功。
而且这次只花了 661 个 token、339 毫秒------比正常跑完便宜 6 倍、快 4 倍。模型抄近路不仅没被拦住,还省了钱,只是交出来的东西是垃圾。
这就是拆解的真实代价:你把编排权交给了模型,而协议不会替你检查前置条件。 tools/call 只搬运调用,它不知道你心里有个"必须先做第一步"的约束。
要拦住只能自己写:在 write_report 里检查前置状态,没聚类过就返回 isError。但这一步一旦做了,你就在服务端维护会话状态了------而"不需要状态"本来是拆解方案最大的卖点。
第十篇讲权限的时候我说过一句话:协议只保证"能不能调",不保证"该不该调"。 顺序问题也是一样,它属于"该不该",得你自己管。
但管这件事,要先把状态加回来
拦住跳步的办法不复杂:记一下每个会话做到哪一步,写正文之前查一次。
dart
// 要拦跳步,就绕不开这张表------而「不需要状态」本来是拆解的卖点
const done = new Map<string, Set<string>>();
server.registerTool("fetch_week_notes", { inputSchema: {} }, async (_args, extra) => {
const notes = await stepFetch();
done.set(extra.sessionId!, new Set([...(done.get(extra.sessionId!) ?? []), "fetch"]));
return { content: [{ type: "text", text: JSON.stringify(notes, null, 2) }] };
});
server.registerTool("write_report", { inputSchema: {} }, async (_args, extra) => {
if (!done.get(extra.sessionId!)?.has("cluster")) {
return {
isError: true,
content: [{ type: "text", text: "还缺标签分布。请先调用 cluster_notes,再来写正文。" }],
};
}
// ...正常生成
});
加了之后,跳步那个调用变成:
makefile
isError: true
返回: 还缺标签分布。请先调用 cluster_notes 拿到结果,再来写正文,否则周报里会是「覆盖 0 个标签」。
按顺序走则是正常的三步,最后一步 isError=false,周报写的是"覆盖 7 个标签"。
这个错误信息是给模型看的,它拿到之后会自己去补调 cluster_notes------和第五篇讲错误自愈是同一个道理。
但代价来了:你刚刚在服务端加了一张状态表。 而拆解方案最大的卖点之一就是"每一步都是独立的无状态调用"。
更麻烦的是这张表在无状态部署下根本活不过一个请求------每个请求都是新的 server 实例,done 表也是新的,校验永远认为你什么都没做过。这个坑第五篇的 elicitation、第九篇的幂等表、第十二篇的 taskStore 都踩过一遍,是同一个来源。
所以"拆解"和"无状态"这两个词经常被放在一起说,但它们是矛盾的:只要你想强制顺序,就得有地方记住做过什么。 要么放服务端(变成有状态),要么让模型每一步都把上一步的结果当参数传回来(变成大 prompt)。
没有第三条路。
还有一个隐性成本:状态怎么传
write_report 需要 cluster_notes 的结果才能写正文。但在无状态的服务里,它拿不到上一次调用的返回值。只有两条路:
路一:让模型把结果当参数传进来。 那 440 个字符的聚类结果要在 write_report 的 arguments 里再出现一次,又进一遍上下文,又付一次钱。
路二:服务端自己再算一遍。 我的实现就是这条------所以上面 B 方案的 write 是 607ms 不是 307ms,因为它在内部又跑了一次聚类。
两条路都要付钱,一个是 token,一个是时间。拆解不是免费的模块化,它把原本在进程内的函数调用,变成了跨网络、跨上下文的数据搬运。
那到底什么时候该拆
我把判断条件整理成一张表,按"先看什么"排序:
| 先看这个 | 如果成立 | 结论 |
|---|---|---|
| 单步是不是贵到不能重跑(>30 秒,或有外部副作用) | 是 | 值得拆,恢复粒度是刚需 |
| 中间结果模型需不需要看(要它改主意、要它补充信息) | 需要 | 值得拆,这是拆解真正的价值 |
| 整个过程能不能在客户端超时内跑完 | 能 | 别拆,长工具最省 |
| 你的失败率是不是高到天天重跑 | 不高 | 别拆,为偶发失败付 7 倍常态成本不值 |
| 拆分后每步的返回是不是很大 | 是 | 谨慎,返回值会变成上下文里的石头 |
顺序很重要。先问"恢复粒度是不是刚需",再问"模型要不要看中间结果",最后才轮到"拆了是不是更灵活"。 很多项目是倒着来的:先按阶段画了三层架构,再回头给每一步找理由。
如果三条都不成立,就用长工具;如果只是想解决超时,用任务原语(token 账单和长工具几乎一样,只多 9 个)。
一个折中做法
如果你确实需要拆,但不想付 7 倍的常态成本,可以只拆"贵的那一步":
scss
fetch_week_notes() → 快,返回小
cluster_notes() → 快,返回小
write_report() → 慢,贵,失败率高
把这个组合包成两个出口:日常用 build_weekly_report(一次调用,账单小),只有在正文那步失败率高的时候,才让模型走三步。
这不是优雅的设计,但它符合现实:架构应该跟着失败率走,不是跟着职责划分走。
总结
- 拆解的 token 成本是 7.4 倍(4194 vs 569),主要来源不是调用次数,是中间结果被复制进了每一轮请求
- 拆解也更慢(1282ms vs 960ms),因为多了两次模型往返;单次调用变快了,整体反而更慢
- 拆解唯一确定赢的地方是恢复粒度:失败时重跑 606ms 而不是 910ms,差距随单步耗时放大
- 任务原语和长工具在账单上没区别(560 vs 569):它解的是服务端生命周期,不是上下文
- 拆解把编排权交给模型,而协议不检查前置条件------跳步的调用会返回成功,内容是空的,还更便宜
- 要拦住跳步就得记"做到哪一步",这等于把状态加回服务端;「拆解」和「无状态」经常被一起说,但它们是矛盾的
- 无状态服务里,步骤之间的状态只能靠参数重传(花 token)或重算(花时间),这是拆解的隐性成本
- 判断顺序:恢复粒度是不是刚需 → 模型要不要看中间结果 → 能不能在超时内跑完。反过来推容易给自己找理由
回过头看,我上一篇写"代价是多花点 token",实测下来这个"点"是 7 倍。写架构建议的时候最危险的一句话就是"代价不大",因为说这话的人通常没量过。
适用边界:这篇的所有数字都来自一个「三步、每步 300 毫秒、返回 1KB 左右」的任务。如果你的任务单步就要跑几分钟、返回只有几百字节,拆解的 token 溢价会小很多,恢复收益会大很多,结论可能反过来。所以别抄结论,抄方法------把你的任务拆一遍,量一次账单,用你自己的数字做决定。