Fable 5.1 和 Opus 5 哪个更便宜？cache read 占账单超过 1/3，才轮到 5.1

先回答标题。多数情况下，Opus 5 更便宜。Fable 5.1 只在一种情况下反超：cache read 在它账单里占到三分之一以上。 （Fable 5 是 5.1 的前代，两者只差 cache read 一格价，Anthropic 说的省幅都是相对它。）原因是价目表的形状——Opus 5 在输入、缓存写、输出每一行都恰好是 Fable 5.1 的一半，只有 cache read（缓存读取）一行反过来， 是它的 2 倍。Anthropic 说 5.1 比 Fable 5 典型省 25%、高度 agent 型最高约 45%；把这两个数和价目表联立反推， 对应的 cache read 份额约为 11% 和 27%，都在那条线以下。

那个份额官方算不了，它只在你自己的 usage 数据里。下面推这道除法、给两个方向相反的算例、 一张三分钟自查表，以及三个会让结果算错的坑。

价目表只动了一格：Opus 5 在其余每一行都是 Fable 5.1 的一半

先说清表在算什么：prompt caching 把每次重复发送的前缀（系统提示、工具定义、长文档）存在服务端， 第一次存按缓存写价收一次，之后每次命中按缓存读取价收、代替全价输入，5 分钟与 1 小时是存活时长。 本篇整篇算的就是「缓存读取」这一行。

Fable 5.1 于 9 月 1 日发布，官方价目页上它与 Fable 5 只差一格（USD / 百万 token）：

价目页脚注写得直白：Fable 5.1 与 Mythos 5.1（同底座的受限发行版，一般拿不到）的缓存命中按输入价的 0.025 倍计，其余所有模型仍是 0.1 倍 （Pricing）；写价与 512 token 的最小可缓存长度都没动 （What’s new）。

把 Opus 5 那一行逐格除以 Fable 5.1：0.5、0.5、0.5、2、0.5。五格里四格是一半，一格是两倍。这就是全部的数学。

记你 Fable 5.1 账单里 cache read 那一行为 R，其余四行合计为 X。同一组 token 跑 Opus 5 是 2R + 0.5X。 5.1 更便宜的条件是 R + X < 2R + 0.5X，化简得 R > X/2，也就是 cache read 占 5.1 账单超过三分之一。 以下所有比较都假设同一组 token——同样的输入、同样的缓存命中、同样的输出。这个前提在本篇最后一节会被拆开看。

三分之一是切过去之后那张账单的口径，而你手里没有它。换算到你现在这张： 不管你在 Fable 5 还是 Opus 5 上，cache read 那一行要占到三分之二以上，切 5.1 才更便宜 （Fable 5 账单是 4R 对 X，R = X/2 时 cache read 占 2/3；Opus 5 账单是 2R 对 0.5X，同样 2/3）。 这个数能直接对着发票读，下面的算例 A 就是它的反例。

已经从 Fable 5 切过去的人不用算份额：切换省下的比例是 3R / (4R + X)，R = X/2 时正好 50%—— 账单比上个月少了不到一半，那条 workload 在 Opus 5 上更便宜；多于一半，才是 5.1 的地盘。

现在把 Anthropic 的两个数放进去。公告原文是「an estimated 25% less than Fable 5 for typical workloads, wherever usage is billed by token」，高度 agent 型「up to approximately 45%」 （Introducing Claude Fable 5.1 and Claude Mythos 5.1）。 把省幅代进 3R / (4R + X)：省 25% 解出 X = 8R，省 45% 解出 X ≈ 2.67R。换算成 5.1 账单里的占比：

两行都在线以下。这两个份额是我联立公告与价目表反推的——官方公布的是测量口径而非份额：图注写明 「measured at default effort over four weeks of actual usage in August 2026」，典型档覆盖 Claude Enterprise、 Claude Code 与 API，高度 agent 档是「cache reads make up most of the cost」那类流量，与反推出的 27% 同向。 两个数它自己都叫估算。beri.net 做过同一推导，我独立算过一遍，结论一致。

一句前提：**本篇假设两个模型对你的任务都够用；不够用的，价格不是变量。**官方模型页的选型口径是 「For most workloads, start with Claude Opus 5」 （Claude Fable 5.1 — overview）——那是能力口径， 价格上算出来是同一个方向。

同一张价目表，两种 workload，两个相反答案

下面两个算例是按官方价目做的纯算术，token 组合是我假设的，写在每个算例第一行；缓存按持续活跃、前缀只写一次的理想态算。 你的数字会不一样，固定前缀的形状不会。

算例 A · 固定前缀、短轮次。 100K token 前缀（仓库上下文 + 工具定义 + 系统提示）写一次 5 分钟缓存； 跑 50 轮，每轮重读这 100K，新增 2,000 token 未缓存输入，输出 2,000。

cache read 占 5.1 账单 14.7%。同一组合在 Fable 5 上是 $12.25，切到 5.1 省了 30.6%，正落在 Anthropic 那个 25% 到 45% 的带子里，听起来像一次成功的升级。同时 Opus 5 便宜 27.9%。两句话都对，因为它们回答的是两个问题。

这一例也是上面那条「现账单三分之二」的反例：同一组 token 在 Fable 5 账单里 cache read 占 40.8%， 看着离三分之一很远的上方，投影到 5.1 账单却只有 14.7%。读份额一定要认准是哪张账单上的份额。

还要注意这一例建模的是固定前缀，不是真实 agent 循环。真实会话里上一轮的输入与输出会追加进缓存， 前缀随轮次增长，cache read 的份额随会话变长而上升——越长越靠近那条线，而这正是 Anthropic 用 「45%」描述的那类流量。所以下面那句「形状不会变」只对固定前缀成立：长会话 agent 这条 workload 必须自己量，不要照搬本例的 14.7%。

算例 B · 固定语料扇出抽取。 200K token 的一份语料（合同、手册、知识库）写一次 1 小时缓存（假设调用间隔超过 5 分钟，否则刷新 5 分钟缓存更省）； 跑 1,000 次短调用，每次重读 200K，新增 500 未缓存输入，输出 200。

cache read 占 72.5%。Fable 5 上是 $219.00，切过来省 68.5%；Opus 5 反而贵 59%。这是 5.1 的地盘。

没有缓存的单发请求不用算：30K 输入、4K 输出，5.1 是 $0.50，Opus 5 是 $0.25，恰好两倍。

算例 B 有一个不太舒服的推论。同一组 token 放到 Sonnet 5 上（按每百万 $2 输入、$4 的 1 小时写、$0.20 读、$10 输出计）是 $43.80。 Fable 5.1 赢过 Opus 5 的那种流量形状，正是中档模型赢得更多的形状。 如果你的 workload 能触发交叉点， 先问一句是否需要旗舰级模型；这个问题本篇不替你答。（换中档模型前记得查最小可缓存长度，Sonnet 5 是 1,024 token、Haiku 4.5 是 4,096， 后者的 200K 窗口还装不下算例 B 的前缀—— Prompt caching — Cache limitations。）

他方有一组实测可以拿来对照形状。techsy.io 在 9 月 2 日 08:55 UTC 经 OpenRouter 跑了 14 个短任务 × 3 个模型， 三者全部 14/14 通过，账单分别是 Fable 5.1 $0.14693、Fable 5 $0.13285、Opus 5 $0.080725 （Claude Fable 5.1 Review: We Metered It Against Fable 5 and Opus 5）。 这些调用基本没有缓存，5.1 比 Fable 5 还贵 11%（它多吐了输出 token），Opus 5 便宜 45%（标价就是一半）。 同一篇里带 1,165-token 前缀的第二轮，cache read 那一行省了 75%，整轮只省 21%——读价降四倍是真的， 账单降多少取决于读占几成。

三分钟自查：从 usage 的四个 token 计数拉 30 天，按 workload 各乘各价

数据每次响应都在给你，usage 里四个 token 计数各乘各价即可 （Prompt caching — Tracking cache performance）：

没存响应日志的走官方 Usage API，按天最多 31 个桶，可按模型、API key 或 workspace 分组，需要 Admin key （Usage and Cost API）：

curl "https://api.anthropic.com/v1/organizations/usage_report/messages?\
starting_at=2026-08-04T00:00:00Z&\
ending_at=2026-09-03T00:00:00Z&\
models[]=claude-fable-5&\
group_by[]=api_key_id&\
bucket_width=1d&\
limit=31" \
  -H "anthropic-version: 2023-06-01" \
  -H "x-api-key: $ANTHROPIC_ADMIN_KEY"

返回的每个 bucket 长这样：

{ "starting_at": "2026-08-04T00:00:00Z",
  "results": [{ "api_key_id": "apikey_01ABC",
    "uncached_input_tokens": 812004, "cache_creation": {
      "ephemeral_5m_input_tokens": 1204000, "ephemeral_1h_input_tokens": 0 },
    "cache_read_input_tokens": 48210500, "output_tokens": 1630220 }] }

在 Fable 5 上的，拉 Fable 5 的历史就够了：两个模型除 cache read 外同价，把返回的 cache_read_input_tokens 乘 $0.25 而不是 $1，就是切到 5.1 之后的账单。在 Opus 5 上的， 把 Opus 5 的各行乘 2、cache read 那一行乘 0.5，同样得到 5.1 账单。然后算：

# All args in MILLIONS of tokens. USD per million, official price sheet as read on 2026-09-03.
def decide(uncached, write_5m, write_1h, read, output, output_growth=1.0):
    output *= output_growth            # 5.1 may emit more output tokens; see the sensitivity note
    fable = uncached * 10 + write_5m * 12.5 + write_1h * 20 + read * 0.25 + output * 50
    r = read * 0.25
    opus = 2 * r + 0.5 * (fable - r)   # Opus 5: 2x on cache reads, 0.5x on every other line
    return r / fable, fable, opus      # share > 1/3  =>  Fable 5.1 is the cheaper model

四条纪律，每条旁边是照做要多付的东西。

按 workload 分开算。 算例 A 和算例 B 同时存在时合计份额落在中间，两个各自正确的答案互相抵消。 代价：按 API key 或 workspace 分组——一把 key 混跑的历史拆不开，这周先分 key，30 天后再算。

拉 30 天，不拉 3 天。 缓存命中率随流量形态波动，周一的会话和周五的批处理不是一个份额。代价：一次拉够 31 天，不用分段。

把 output 乘 1.1 到 1.3 再算一遍。 上面的投影假设 5.1 跑同样的任务吐同样多的 token，而这一条不一定成立—— techsy 那 14 个无缓存短任务里 5.1 比 Fable 5 贵 11%，就是因为它多吐了输出，而输出是 $50 那一行。 output_growth=1.3 之后结论还不翻，才算稳。代价：多跑一次同一个函数。

经中转的读者先看一件事。 网关有没有把这四个 token 计数原样透传给你。透传不了这道除法就算不了， 而那本身也是一条信息。

用 Claude Code 订阅的读者不用算：公告那句「wherever usage is billed by token」的限定语就是给你的—— 订阅按 5 小时窗口计量，不按 cache read 计价，25% 与 45% 都不在那里发生。

前作《同一个模型 18 家托管、6 倍价差：账单看不见的四处》的第一条底线是 「每次响应带 token 计数分开存」——存了的三分钟出答案，没存的这周开始存。

三个会让这道除法算错的坑

一次 cache miss 从 12.5 次 read 变成 50 次

读价降了四倍，写价一分没动，于是一次未命中导致的 5 分钟缓存重写相当于多少次读取，从 $12.50 ÷ $1.00 = 12.5 变成 $12.50 ÷ $0.25 = 50；1 小时缓存从 20 变成 80。Opus 5 与 Fable 5 都还是 12.5。

含义要说准：以读价为尺子，一次 miss 的代价是从前的四倍；美元上 miss 并没有变贵， 是命中变便宜了（省下的从 $9 变成 $9.75），所以命中率的波动在 5.1 的账单里更显眼。

让缓存失效的方式一个都没变，prompt caching 文档里逐条写着 （Prompt caching — What invalidates the cache）：

• TTL 从请求开始计，不是从响应结束。一次 4 分钟的流式响应之后，下一请求要在约 1 分钟内到。 5.1 默认 high effort（推理力度开关，low/medium/high，越高想得越久、吐得越多）、adaptive thinking 常开（模型自己决定想多久），长一轮的响应时间会直接吃进这个窗口。
• 失效级联单向：tools → system → messages。改一个工具描述，后面整条缓存作废。
• 改顶层 output_config.effort 会让 messages 缓存失效。（逐条消息设 effort 的 beta 能力是例外，做路由的人可以查文档。）
• 低于 512 token 不缓存，且不报错。cache_creation_input_tokens 与 cache_read_input_tokens 同时为 0，就是按全价付了输入。

还有一层不在缓存里：5.1 的行为变了，token 组合会跟着变。 官方迁移说明列了两条与账单直接相关的—— 并行工具调用更不稳定，本来一轮批量发出的几个调用可能拆成每轮一个，多出来的轮次每轮都要重读一遍前缀； 默认 effort 是 high，想得更久也吐得更多，而输出是 $50 那一行 （What’s new in Claude Fable 5.1 — Changed from Claude Fable 5）。 两条都往「输出与轮次变多」的方向推，也就是把份额往三分之一线以下推。这是上面那步敏感性检查存在的原因， 也是切过去之后第一件要对的账。

代价：把命中率做成带告警的指标，不是仪表盘上的一格。写读比 50:1 的时候，前缀稳定性的一次回归就是一次预算事件。

inference_geo: "us" 乘的是全部四类 token，包括 cache read

合规要求推理落在美国境内的团队，Claude 4.6 及之后的模型可以传 inference_geo: "us"，代价是 1.1 倍。 官方写得很完整：输入、输出、缓存写、缓存读，四类全乘 （Data residency — Pricing）。

两个推论。一，三分之一那条线不动：Fable 5.1 和 Opus 5 都在 4.6 之后，同乘 1.1 不改变比值。 二，你拿 8 月账单对 9 月账单时，如果中间开了 inference_geo，多出来的 10% 不是模型变贵，是你的对照组变了。 价目页另一句要记住：这些乘数彼此叠加，含 Batch（批处理接口，两模型所有行同乘 0.5，所以那条三分之一线不动）折扣 （Pricing — Prompt caching）。

5.1 的推理块只有 5.1 读得懂，中途切模型会被静默丢掉

先给结论：按 workload 路由，不按轮次路由——一条对话从头到尾留在一个模型上，切换发生在 workload 之间。 不做多模型 fallback、也不在对话中途换模型的读者，这一节到此为止即可。

下面是为什么。thinking block 是模型答题前写下的推理过程，API 随响应返回，多轮对话时你要把它原样带回下一轮请求。 这一条最容易让「按价格路由」的方案在账单之外先出问题。5.1 的每个 thinking block 记录了产出它的模型， 且只被 5.1 或更新的模型读取；Opus 5、Fable 5 都读不了。请求里带了目标模型读不了的 block——路由器或 fallback 在对话中途切模型就是这种情况——API 会在模型看到之前把块丢掉。不加 thinking-binding-controls-2026-08-01 这个 beta 头，丢块没有任何提示；加了，会在顶层 input_transformations 里报出来 （What’s new in Claude Fable 5.1 — Breaking changes）。

丢掉的 token 不计费。但迁移指南接着说的那句才是账单：目标模型没有那段推理，要重新规划， 切换后的第一轮成本与延迟可能上升 （Migrating to Claude Fable 5.1 — Breaking changes）。

再叠一层。prompt cache 按模型隔离，fallback credit 文档第一句就是「Prompt caches are per-model」 （Fallback credit）。切模型等于在新模型上把前缀重写一遍； fallback credit 能退这笔钱，但它只在模型拒答后重试另一模型时发放。为省钱做的切换，没有 credit。 算例 B 那条 200K 前缀的会话中途切到 Opus 5，光 1 小时缓存重写就是 $2.00，等于在 5.1 上把这个前缀重读 40 次。

这就是节首那条结论的由来。做路由的人把 binding 头打开、把 input_transformations 记日志， 代价是一个 header 和一行日志。

价格轴的另一头：GLM-5.3 Flash 的 4 分钱，本篇前提是你已决定用旗舰

8 月底，掘金上有位前端作者用 GLM-5.3 Flash 跑了 4 个真实任务——竞态 bug 诊断、并发控制器、 React 代码评审、截图 UI 诊断——自述输入 2,309 token、输出 21,668 token，按五折促销价（9 月 9 日到期）算出 $0.0056， 他换算成人民币约 4 分钱，原价 $0.15/$0.50 约 8 分 （我拿 4 个真实前端任务试了 GLM-5.3 Flash：代码一遍跑通，账单 4 分钱）。

放在这里不是比谁强，只是标一下价格轴的另一头：Fable 5.1 输出 $50，GLM-5.3 Flash 列表价输出 $0.50，差 100 倍。 本篇这道除法的前提，是你已经决定这条 workload 要旗舰级模型。 那个决定是另一道题；GLM-5.3 Flash 的价格结构本刊 《Ox Alpha 就是 GLM-5.3-Flash》对过账，这里不重复。

回到能做的事，每条旁边是代价：

1. 这周拉 30 天 usage，按 workload 算份额。 过三分之一的切 5.1，没过的留 Opus 5。代价：一段脚本，上面那几行。
2. 切了的，把命中率做成告警。 代价：一个指标。写读比 50:1，回归就是预算事件。
3. 路由层加 thinking-binding-controls-2026-08-01，记 input_transformations。 代价：一个 header、一行日志。 切换只在 workload 之间发生。

我们自己做路由层时的取向也是这个：切不切模型看 usage 的 token 计数按 workload 的份额，不看价目表上的两列。 英文刊同日有一篇姊妹篇从路由交叉点切入（Fable 5.1’s cache-read crossover）， 读英文的可以对照着看。

Anthropic 比你更容易看到那个份额，它给出的是两个估算。精确值在你自己的 usage 日志里，前提是你存了。