1.73亿token成本解析：输入输出比例、缓存命中率与模型计费

1. 1.73 亿 token 这个数字，先拆开看它到底意味着什么

先把结论摆在前面：1.73 亿 token 听起来像个天文数字，但真正决定账单的从来不是这个总数，而是输入输出比例、缓存命中率、以及你走的是哪条计费通道。我见过太多人拿着一个总 token 数去乘单价，算出来的数字能差出十倍，问题就出在这三个变量上。

WorkBuddy 这类工具在 9 月跑出 1.73 亿 token，通常不是单一模型贡献的，而是多个模型、多轮对话、加上大量工具调用叠加的结果。要算清楚这笔账，第一步不是打开计算器，而是先把这 1.73 亿拆成几块。

1.1 token 的两种身份：输入和输出，价格差好几倍

在任何主流 API 的计费体系里，输入 token（prompt tokens）和输出 token（completion tokens）是分开计价的，而且输出通常贵 3 到 4 倍。原因不复杂：输入是并行处理的，输出是逐字生成的，后者对算力的占用是串行的、持续的。

假设 1.73 亿 token 里，输入占 70%、输出占 30%，那实际是 1.211 亿输入 + 5190 万输出。如果按某个中端模型的官方价——输入 2 元/百万 token、输出 8 元/百万 token 来算：

• 输入：121.1 × 2 = 242.2 元
• 输出：51.9 × 8 = 415.2 元
• 合计：约 657 元

但如果比例反过来，输出占 70%，那账单直接翻倍还多。所以在没搞清楚输入输出比例之前，任何报价都是耍流氓。WorkBuddy 这种偏 Agent 形态的工具，工具调用的返回结果会反复塞回上下文，输入占比往往比普通聊天高得多，这点后面会细说。

1.2 缓存命中率：被大多数人忽略的"隐形折扣"

这是整篇文章最值钱的一段，请重点看。主流 API 现在都支持prompt caching（提示缓存），命中缓存的那部分输入 token，价格通常只有正常输入价的 10% 到 25%。对于 WorkBuddy 这种会反复携带系统提示词、工具定义、历史上下文的场景，缓存命中率能到 60% 甚至更高。

我实测过一个类似 Agent 项目，同样的对话轮次，开启缓存后输入侧成本直接砍掉了将近一半。原因在于：系统提示词、工具 schema、固定的指令模板这些内容每轮都在重复发送，缓存机制会把它们记住，后续只按缓存价计费。

所以算账时正确的姿势是：

看到没，光是把缓存命中率考虑进去，账单就从 657 掉到了 548。如果你的缓存命中率能到 80%，还能再降。缓存命中率是 Agent 类应用成本优化的第一杠杆，没有之一。

1.3 官方价 vs 实际价：为什么你看到的账单总对不上

还有一个坑：官方价是"标价"，实际结算可能因为批量折扣、预充值优惠、渠道差异而不同。但反过来，如果你用的是某些第三方中转，标价看着便宜，实际可能因为限流、重试、失败请求重复计费而更贵。

我个人的建议是：算账一律以官方价为准，把它当成成本上限。这样你心里有个锚，实际花得更少是惊喜，花得更多说明中间有环节出了问题，需要排查。1.73 亿 token 按官方价算，落在 500 到 900 元这个区间是合理的，具体取决于模型组合和缓存策略。

2. WorkBuddy 的 token 消耗结构，和普通聊天完全不是一回事

很多人拿 ChatGPT 的使用经验去套 WorkBuddy，结果算出来的账完全不对。这两者的 token 消耗模式有本质区别，理解这一点，才能明白为什么 1.73 亿这个数字在 Agent 场景下其实不算夸张。

2.1 工具调用是 token 放大器

普通聊天是一问一答，上下文线性增长。WorkBuddy 这类工具会调用外部能力——读文件、跑命令、查资料、写代码——每一次工具调用都会产生一轮完整的请求和响应，而且工具返回的结果会被塞回上下文，成为下一轮的输入。

举个具体的例子。你让 WorkBuddy 帮你分析一个项目目录，它可能：

1. 先调用列目录工具，返回 200 个文件名（约 2000 token）
2. 读取其中 5 个关键文件（每个 3000 token，共 15000 token）
3. 基于这些内容生成分析（输出 2000 token）
4. 你追问一个细节，它又要把前面所有内容重新带上（约 17000 token 输入）

一轮看似简单的交互，实际消耗可能接近 4 万 token。如果这个流程重复几十次，1.73 亿 token 很快就堆出来了。Agent 的 token 消耗是乘数级的，不是加法级的，这是最核心的认知。

2.2 上下文窗口越大，重复计费越狠

现在的模型上下文动辄 128K、200K 甚至 1M token。窗口大是好事，但有个副作用：每一轮请求都要把整个上下文重新发一遍。如果你在一个长会话里聊了 50 轮，第 50 轮实际发送的输入可能是前 49 轮的总和。

这就是为什么缓存机制对 Agent 如此关键。没有缓存，长会话的成本是平方级增长的；有了缓存，重复部分按折扣价算，成本曲线才压得下来。

我做过一个粗略测算：一个 30 轮的 WorkBuddy 会话，如果每轮平均上下文 2 万 token，不考虑缓存的话，输入侧累计约 30 × 2 万 = 60 万 token（这还是保守估计，因为上下文在增长）。考虑缓存后，实际计费的"新输入"可能只有 15 万 token 左右。差距就是这么来的。

2.3 多模型混用让账单变成一道混合运算题

WorkBuddy 通常不会只用一个模型。简单任务用小模型，复杂推理用大模型，代码生成用专门的代码模型。不同模型单价差好几倍，所以最终账单是一道加权平均题。

假设 9 月这 1.73 亿 token 的分布是这样的：

按输入输出 7:3 拆分，粗算下来总成本会落在 700 到 1000 元之间。如果高端模型占比更高，轻松破千。所以"1.73 亿 token 花多少钱"这个问题，答案的区间可能从 400 到 2000 元，全看模型组合。

3. 按官方价实算：三种典型场景的账单推演

光讲原理不够，直接上三套算法，对应三种典型使用强度。你可以对照自己的实际情况，找到最接近的那一档。

3.1 场景一：以轻量模型为主，缓存命中率高

这是最省钱的情况。假设 WorkBuddy 主要跑轻量模型，缓存命中率 70%，输入输出比 75:25。

• 总 token：1.73 亿
• 输入：1.2975 亿，其中缓存命中 70% = 9082.5 万，普通输入 3892.5 万
• 输出：4325 万

按轻量模型输入 0.5 元/百万、缓存 0.1 元/百万、输出 2 元/百万算：

• 普通输入：38.925 × 0.5 = 19.46 元
• 缓存输入：90.825 × 0.1 = 9.08 元
• 输出：43.25 × 2 = 86.5 元
• 合计：约 115 元

这个数字可能会让很多人惊讶——1.73 亿 token 才一百多块？是的，轻量模型加高缓存命中率，就是这个价。这也是为什么很多团队敢让 Agent 疯狂跑任务，因为成本真的可控。

3.2 场景二：中端模型为主，缓存命中率中等

这是最常见的配置。中端模型能力够用，价格适中，缓存命中率 50%，输入输出比 70:30。

• 输入：1.211 亿，缓存命中 6055 万，普通输入 6055 万
• 输出：5190 万

按输入 2 元/百万、缓存 0.5 元/百万、输出 8 元/百万算：

• 普通输入：60.55 × 2 = 121.1 元
• 缓存输入：60.55 × 0.5 = 30.28 元
• 输出：51.9 × 8 = 415.2 元
• 合计：约 567 元

这个档位是大多数个人开发者和中小团队的日常。五百多块换 1.73 亿 token 的处理量，性价比其实相当高。

3.3 场景三：高端模型占比高，缓存命中率低

这是最烧钱的情况，通常出现在做复杂推理、长文档分析、高难度代码生成的时候。高端模型占比 40%，缓存命中率只有 30%，输入输出比 60:40。

• 输入：1.038 亿，缓存命中 3114 万，普通输入 7266 万
• 输出：6920 万

按高端模型输入 10 元/百万、缓存 2.5 元/百万、输出 30 元/百万算：

• 普通输入：72.66 × 10 = 726.6 元
• 缓存输入：31.14 × 2.5 = 77.85 元
• 输出：69.2 × 30 = 2076 元
• 合计：约 2880 元

看到差距了吗？同样 1.73 亿 token，从 115 元到 2880 元，差了 25 倍。决定账单的从来不是 token 总数，而是模型档位和缓存策略。

提示：如果你发现自己的账单远超预期，第一件事不是砍用量，而是去后台看模型分布和缓存命中率。八成问题出在这两个指标上。

4. 把账单压下来的五个实操手段

算完账，接下来是干货时间。这些手段都是我在实际项目里验证过的，按性价比排序。

4.1 缓存策略：把系统提示词和工具定义固定下来

缓存生效的前提是前缀稳定。如果你的系统提示词每次都在变（比如塞了时间戳、随机 ID、动态排序的工具列表），缓存就永远命中不了。

具体做法：

• 把系统提示词、工具 schema、固定指令模板放在请求的最前面，且内容完全一致
• 动态内容（用户输入、工具返回结果）放在后面
• 避免在系统提示词里插入时间戳、会话 ID 这类每次都变的东西

我踩过的坑：早期为了"让模型知道当前时间"，在系统提示词里加了精确到秒的时间戳，结果缓存命中率直接归零。后来改成只在需要时通过工具查询时间，命中率立刻回到 70% 以上。一个小改动，成本降一半。

4.2 上下文裁剪：别让历史对话无限膨胀

长会话是成本杀手。我的做法是设置一个滑动窗口，只保留最近 N 轮对话，更早的内容做摘要压缩。

具体参数参考：

这样做的代价是可能丢失一些早期细节，但换来的是成本可控。对于大多数任务，最近 10 轮的上下文已经足够。

4.3 模型路由：让简单的活给便宜的模型干

不是所有任务都需要高端模型。我的路由规则大致是：

• 格式转换、简单提取、分类打标 → 轻量模型
• 常规问答、代码补全、内容生成 → 中端模型
• 复杂推理、架构设计、难题排查 → 高端模型

WorkBuddy 这类工具通常支持配置模型路由，或者你可以通过自定义指令引导它选择。关键是别让高端模型去干轻量模型的活，那是纯浪费。

4.4 输出长度控制：输出 token 是最贵的

输出 token 单价是输入的 3 到 4 倍，所以控制输出长度收益极高。几个实用技巧：

• 在提示词里明确要求"简洁回答，不超过 X 字"
• 让模型输出结构化格式（JSON、列表），比散文更省 token
• 避免让模型重复你已经知道的内容

我实测过，同样的任务，加上"用要点回答，不要展开"这句指令，输出 token 能减少 40%。

4.5 批量处理与请求合并

如果有一批相似任务，合并成一次请求比分开请求更省。因为系统提示词只发一次，缓存也能复用。

但要注意别合并过头，单次请求太大反而会触发上下文上限，导致截断或失败。我的经验是单次请求控制在上下文窗口的 60% 以内比较稳妥。

5. 那些算账时容易翻车的地方

最后聊聊几个我亲身踩过的坑，都是真金白银换来的教训。

5.1 重试和失败请求也在烧钱

API 调用失败时，如果客户端自动重试，失败的请求可能已经计费了（尤其是已经生成了一部分输出的情况）。我遇到过因为网络抖动导致同一请求重试三次，账单多出 20% 的情况。

对策：设置合理的重试次数上限（2 到 3 次），并对失败请求做日志记录，定期检查异常重试率。

5.2 工具返回结果没做截断

工具调用返回的内容如果很长（比如读取一个大文件、查询返回大量数据），会直接塞进上下文，成为下一轮的输入。我见过一次因为读取了一个 5 万行的日志文件，单轮输入直接爆到 8 万 token。

对策：工具返回结果做长度限制，超长内容先摘要或分页处理。永远不要相信工具返回的内容是"适量"的。

5.3 把 token 数当成唯一指标

token 数只是成本的一个维度。实际成本还包括：请求次数（有些平台按次收费）、并发限制导致的等待时间、失败重试的额外开销。只看 token 数容易漏掉这些隐性成本。

我的做法是建一个简单的成本看板，同时跟踪 token 用量、请求次数、失败率、缓存命中率四个指标。这样任何异常都能第一时间发现。

5.4 忽略不同模型的上下文计费差异

有些模型对超长上下文有额外计费规则，比如超过 128K 的部分单价翻倍。如果你不注意，一个长文档分析任务可能触发这个规则，成本瞬间飙升。

对策：了解你所用模型的计费细则，尤其是上下文长度分档的部分。必要时把长文档切分处理，避免触发高价档位。

回到最初的问题：9 月用 WorkBuddy 烧了 1.73 亿 token，按官方价到底要花多少钱？答案取决于你的模型组合和缓存策略，合理区间在 500 到 900 元，优化得当可以压到 200 元以内，放任不管则可能破千。这个数字本身不重要，重要的是你知道了它是怎么算出来的，以及怎么把它压下去。