一次重试，可能比你省下的所有token都贵

一个任务的成本，以及重试的成本

你不会为了购买百万级 token 而开始工作。你开始工作是为了实现一个功能、完成一次迁移，或运行一个任务。token 数量只是模型到达终点所需的数量。

两个每 token 成本相同的模型，在同一个任务上的花费可能差别很大。一个模型只读一遍代码。另一个模型读一遍、尝试修复，再读一遍。每一步都是一轮（turn），每一轮都会重新发送当前对话。因此，需要更多轮次的模型成本更高，即使价格相同。

读完这篇文章，你应该能回答关于你自己工作的三个问题：

- 我的典型任务在 Opus 5.5 上要花多少钱？
- 哪些设置会改变这个成本，改变多少？
- 如何查看我自己会话的使用量？

我想提前分享一个权衡：每一种少花 token 的方式，都可能让你失去一个完成的任务。更低的 effort、更小的模型或更少的上下文，确实都能节省 token。但一次重试的成本可能超过这些节省。这篇文章试图为每种权衡标上价格。

这里的一些数字是标价（list price），另一些是基于标价构建的示例。图表是交互式的，阅读时可以调整输入。这些是尽力而为的示例，请务必查看我们的文档并自行核算。

一个任务要花多少钱？

在 Claude Code 中，一个任务就是一个循环。模型读取对话、调用工具、读取结果，然后再次循环，直到完成。每次绕循环一圈就是一次请求。有四个因素决定这个循环的成本。

轮次（Turns）

每一轮都会重新发送当前对话。轮次越少，处理的输入就越少。

缓存读取。一轮重新发送的内容大多是模型在上一轮已经见过的文本。这部分按缓存读取计费，价格仅为输入价格的一小部分。

输出 token 类型。这是最昂贵的 token，价格为输入价格的五倍。思考（thinking）也按输出计费，所以在得到答案过程中推理较少的模型成本更低。

模型。每个模型有自己的价格，列在定价页面上，因此你选择的模型决定了每个 token 的价格。

我们的示例使用 Opus 5.5 API 标价：每百万输入 token 4 美元，每百万输出 token 20 美元，每百万缓存读取 0.20 美元。与后面的计算器一样，示例中缓存的输入按读取价格计费，其他所有内容按输入价格计费，缓存写入不计入。token 数量只是示例。

假设一个任务从 20K token 的上下文开始，随着模型读取文件和工具结果增长到 120K。在 40 轮时，平均每轮发送约 70K token。也就是任务总共约 2.8M 输入 token，尽管对话从未超过 120K。如果 90% 从缓存读取，输入成本约为 1.62 美元。同样的任务用 25 轮处理约 1.75M token，输入成本约 1.02 美元。

一轮的成本不仅仅是它新增的 token，因为它会重新发送之前的所有内容。所以最便宜的一轮是你不必进行的轮次。一个减少轮次的习惯是让模型能够检查自己的工作，例如一个可运行的测试、一次构建，或一个调用端点的脚本。能检查自己工作的模型会更早发现错误。

如果一个模型能一次性收集所需信息，并批量进行工具调用，它支付重发（resend）的次数也会更少。

缓存读取

同样的 2.8M 输入 token，如果没有来自缓存，成本是 11.20 美元。90% 命中率时成本 1.62 美元，96% 时约 0.99 美元。没有其他设置能如此大幅度地改变输入成本。一个稳定的会话自然会保持较高的命中率。我将在本文后面介绍一些避免破坏缓存的操作。

输出 token

在 Opus 5.5 上，一个输出 token 的成本是缓存读取的 100 倍。一个典型任务的 60K 输出 token 需要 1.20 美元，相当于从缓存读取 6M token。输出包括思考。即使 Claude Code 只显示摘要，你也要为全部内容付费。这就是为什么 effort（努力程度）——它主要改变模型思考多少——对账单影响如此之大。

模型

缓存读取更便宜的模型主要对长时间会话有利。输出更便宜的模型主要对需要大量推理的任务有利。

Opus 5.5 发生了什么变化

有两件事发生了变化：价格，以及模型做了多少工作。

每一行价格都更低。输入和输出 token 比 Opus 5 便宜 20%。缓存读取便宜 60%。输入价格下降，读取率也随之下降，从输入价格的十分之一降到二十分之一。图 A 比较了两个模型每百万 token 的价格。这些是 API 标价。在 Pro、Max 或 Team 套餐中，Opus 5.5 较低的价格会转化为你的限额（包括缓存上下文），因此它们比 Opus 5 多约 25% 的可用量。缓存读取价格的额外降低是 API 价格变动。

图 A. 每百万 token 的价格。

在 API key 下，缓存读取价格下调对 Claude Code 影响最大。长时间的代理式（agentic）会话将大部分输入花费在缓存读取上。在下面图 B 定价的会话中，缓存行从 1.00 美元降至 0.40 美元，这是账单上最大的降幅。

你能节省多少取决于你工作的形态。一个以缓存读取为主的会话最多可节省 60% 的输入成本。一个没有缓存、答案很长的简短问题最多可节省 20%，因为输出占主导。大多数 Claude Code 任务介于两者之间。下面的计算器会显示你的任务处于什么位置。

Opus 5.5 在一个回答上可能使用更多 token，因为它总是在回复前思考。我们预计人们在 Opus 5.5 上能完成更多工作，但这因任务而异，所以请在你自己的工作中测量。图 C 比较了两个模型每个任务的成本。这部分对你的工作的依赖程度远高于对价格的依赖。

在一个范围明确的任务上，两个模型完成所需的轮次大致相同，你能得到的只有价格下降。差距最大的应该是开放式的任务，模型可能会花很多轮在错误的想法上。没有一个数字适用于所有代码库，所以请测量（见最后一节）。

长时间运行会以一份报告结束。Opus 5.5 会在长时间运行结束时告诉你它改变了什么、发现了什么，以及它需要你做什么。这也能省钱，因为当你能看到发生了什么时，你就不会那么频繁地重新运行会话。

同样的任务并排对比

图 B 以相同的 token 数量为两个模型的一个会话定价。因此差异纯粹来自价格变化。切换模型进行比较。token 数量仅为示例。

图 B. 以相同 token 在两个模型上的示例会话，因此这纯粹是价格变化。

账单包含 /usage 显示的会话三行。缓存读取是 token 最多的一行，为 2M。输出是 token 最少但成本最高的一行。新输入介于两者之间，涵盖每个文件的首次读取和每个新的工具结果。

图 B 给两个模型相同的 token 数量，所以它只显示价格变化。你自己的会话在 Opus 5.5 上可能使用更多或更少的 token。按这种方式定价，会话成本降低约 31%。一次实际记录运行会加入第二个效应，即模型工作量的变化。在一个有错误起点的任务上，差距应该会更大。

试试你自己的数字

设置你某个任务的使用量，或从预设开始。预设只是示例，但我仍建议你自己核算。缓存输入按缓存读取价格计费，新输入按输入价格计费，因此缓存滑块显示差距中有多少来自缓存读取。

要从真实会话中填写滑块，请在任务结束时运行 /usage。Session 区块会给出输入、输出和缓存数字。最后一个滑块是你对 Opus 5.5 在你的任务上少做多少工作的假设。保留 0% 则只看价格变化。要根据你自己的工作进行设置，方法是：在 Opus 5 和 Opus 5.5 上运行同一个任务，比较轮次和输出 token。自己测量一节会详细说明，阅读会话一节会显示在 /usage 中要查看什么。

每个任务的输入 token：所有轮次中发送给模型的所有内容，无论是否缓存。
从缓存读取的比例
每个任务的输出 token：包括思考，按输出计费。
每天的任务数
Opus 5.5 上的 token 减少量（你的假设）：保留 0% 则只看价格。Opus 5.5 用更少的 token 做更多事，但请在你自己的任务上测量。

每个任务 Opus 5 成本──
每个任务 Opus 5.5 成本──
每个任务变化──
一个月按 个工作日计算。标价。没有批量或用量折扣，缓存写入不计入（见下面缓存一节）。

最大化会话价值的技巧

在更换模型之前先提高 effort

Effort 决定了模型每一轮花费多少 token 的总体倾向：它的思考、它写的文本，以及它的工具调用。在较低的 effort 下，它进行的工具调用更少，也更简短。Opus 5.5 有四个级别（low、medium、high 和 xhigh），加上用于单个会话的 max。选择下面的级别，查看何时使用它以及设置它的命令。

级别从每轮思考最少到最多排列。

Claude Code 为每个模型设置默认级别，/effort status 会显示你的级别。对于范围明确的日常工作，可以尝试 medium。当 medium 卡住时，尝试 high。它每轮花费比 medium 多，但比换成更大的模型少。对于机械性工作，如重命名或跨文件应用已知模式，使用 low。

粗略思考 effort 定价的方式：假设 high 在一个任务中增加 20K 思考 token。在 Opus 5.5 上这是 0.40 美元。一个十轮重试循环，100K 缓存上下文，总共 10K 输出 token，成本大致相同。因此，在能节省一次重试的任务上，high 的价值就体现出来了。如果 medium 本可以第一次就完成的任务，high 就是浪费。

当 medium 只修复了一层

最明显的需要更高 effort 的迹象，是修复只停留在一层。

假设一个 API handler 中重命名了一个字段。在 medium 下，模型更新了 handler，handler 的测试通过，但客户端仍然发送旧字段。它做了被要求的事，只是没有读得足够远，没有发现第二个调用方。在 high 下，它会在写代码前花更多轮次阅读调用点，并一次更改两层。

检查也能捕捉同样的 bug。如果模型能运行一个经过客户端的测试，那么在 medium 下，旧字段会在写入的那一轮就使测试失败。所以，在提高 effort 之前，先检查模型是否有办法检查自己的工作。运行一次测试花费一轮及其输出。更高的 effort 会给每一轮增加思考。

如果提高 effort 级别和添加检查都不起作用，那就换一个更大的模型。

在会话中途更改 effort

在 Claude Code 中，运行 /effort 并加上级别，例如 /effort high。/effort status 会显示当前级别。你可以在任务中途更改，新级别适用于下一个请求。

更改 effort 或思考设置会清除缓存的对话，因为这些设置是缓存匹配的 prompt 的一部分。下一个请求将为整个对话支付缓存写入价格。

为你的工作选择合适的模型

模型选择决定了会话中每个 token 的价格，所以它对账单的影响比 effort 更大，影响范围也更广。每个继承主模型的子代理（subagent）也继承其价格。大多数日子需要三种模型：一个用于查找的小模型，一个用于你密切监督工作的 Opus 5.5，以及一个用于最困难任务的更大模型。

将 Opus 5.5 作为日常主力

把 Opus 5.5 用于你监督的工作：跨几个文件的功能开发、调试，以及带后续修改的代码审查。你阅读它做了什么，在它跑偏时介入，所以循环保持简短。

升级到 Fable 5.1

当结果比 token 价格更重要时，升级到 Fable 5.1。例如，你不会监督的长时间运行、代码库中没有现有模式的问题，以及需要协调许多子代理的大型变更。不要等到第三次失败。如果 Opus 5.5 在 high 下两次遇到同一个问题，就切换，并在问题解决后切回。对于交互式工作，Opus 5.5 更合适，因为它延迟更低、成本更低。

Fable 5.1 的标价是每百万输入 token 10 美元、每百万输出 50 美元，是 Opus 5.5 价格的 2.5 倍。它的缓存读取每百万 0.25 美元，仅为 Opus 5.5 费率的 1.25 倍，因为按输入价格的 0.025 倍计费。因此，在长时间、缓存密集的运行中差距最小，在写入量大的任务中差距最大。

在自然的间断点切换。缓存属于前一个模型，所以新模型的第一个回合预计会为整个对话支付写入价格。先运行 /compact，或用一个简短书面计划开始新会话，以让这个回合更小。运行 /model 并加上别名或模型名称来切换。/model 也会将你的选择保存为新会话的默认值，所以在困难部分完成后切回来。

向下移动到查找任务

查找类任务，向下移动到 Sonnet 或 Haiku，而不是用于写代码：搜索和总结的子代理、阅读日志和测试输出，以及“这个在哪里定义”的问题。对于跨多个文件的机械修改，保留 Opus 5.5 并将 effort 设为 low。修改仍然留在编写你其余代码的模型上，每轮成本更低。

要让子代理使用更小的模型，在其定义中设置 model: haiku 或 model: sonnet。要让所有子代理使用同一个模型，设置 CLAUDE_CODE_SUBAGENT_MODEL 环境变量。子代理定义中指定的模型会覆盖该变量。没有模型设置的子代理运行在你的主模型上，除非设置了该变量。

每个子代理在自己的上下文窗口中运行并交回摘要，因此它的文件读取不会进入你的主对话。它仍然为自己的 token 付费，所以模型设置决定了这笔开销的成本。

权衡是：一个小模型如果误读搜索结果，会把主模型引向错误的文件，主模型就要为这次绕路付费。把小型模型留在错误容易被发现的工作上，比如查找文件、运行测试和阅读日志。

把判断性决策留给主模型。opusplan 别名以不同方式拆分工作：Opus 在 plan 模式下做计划，Sonnet 执行计划。这把代码编辑放在 Sonnet 上，与上面的建议相反。在把它设为默认之前，先在自己的任务上测量。

迁移时检查你的 prompt

为旧模型编写的指令可能会让 Opus 5.5 写更多内容并重复工具调用。在 Claude Code 中运行 /claude-api prompt-audit，检查你的 Claude Code 设置（例如你的 skills 和 CLAUDE.md 文件）是否存在这些 prompt 反模式。它还会检查你在 Claude 平台上构建的应用代码。

我们在从 Opus 4.8 迁移到 Opus 5.5 时测试了这一点，使用了一个包含 44 个工单的内部客户支持基准，这些工单的 prompt 包含几个此类模式。迁移到 Opus 5.5（低 effort）将基准成本降低了约 18%。运行 prompt-audit 又降低了 9%，比 Opus 4.8 的起点低约 25%。审计移除了那些让模型写更多内容并重复工具调用的仪式性指令：一个强制六步流程、一条草稿纸规则、一条二次验证规则，以及相互矛盾的指令。

图 D. 在客户支持基准上，从默认 effort 的 Opus 4.8 迁移到低 effort 的 Opus 5.5，并进行了 prompt-audit。

这个结果来自一个基准，所以请把它当作示例，而不是预期数字。运行审计，然后比较真实任务前后的 /usage（见“自己测量”）。

缓存与压缩

Claude Code 为你处理缓存和压缩。你运行会话的方式决定了它们能节省多少。

缓存如何工作

Claude Code 会缓存请求中重复的部分，例如系统 prompt、工具定义，以及当前对话。

在 Opus 5.5 上，一次缓存读取的成本是新输入 token 的 5%。写入缓存的成本高于新读取，按当前定价，五分钟缓存的写入价格是输入价格的 1.25 倍，一小时缓存是输入价格的 2 倍。每次命中都会免费重置有效期。

在 Claude Code 中，有效期取决于你的付费方式。在 Claude 订阅中，有效期为一小时。在 API key 或云服务商下，默认五分钟，一旦订阅开始使用用量积分，就会降至五分钟。

在 120K token 上下文下，Opus 5.5 上五分钟写入的成本约为 0.60 美元，读取约为 0.02 美元。一次写入的成本相当于 25 次读取。在 API key 下，六分钟的咖啡休息时间会把下一次 0.02 美元的读取变成 0.60 美元的写入。同样大小的一小时写入成本约 0.96 美元，在 API 上你可以支付这笔溢价来覆盖一天中的间隙。

会话形态与命中率

缓存存储的是前缀，因此只能复用请求中与上一次从头匹配的部分。

稳定的会话在每轮向对话末尾追加内容，并保持高命中率。任何改变请求较早部分的事情都会降低命中率。更改工具定义会清除整个缓存，而更改系统 prompt 会清除从更改点开始的所有内容，也就是几乎所有内容。

实践中，在以下情况会预期发生缓存写入：

- 你暂停的时间超过缓存有效期；
- 你更改 effort 或思考设置（见 effort 一节），这可能会清除缓存的对话；
- 你连接或断开 MCP 服务器，这可能会改变每次请求开始时加载的内容；
- 你切换模型，因为新模型从空缓存开始；以及
- 对话被压缩，这会重写缓存所匹配的历史。

所以，在会话开始时设置好这些，然后在会话运行期间不要动它们。

为什么长会话每轮成本更高

每一轮都会重新发送整个上下文，因此随着上下文增长，一轮的成本会增加，即使缓存是热的。在 20K token 上下文下，Opus 5.5 上一轮的缓存读取成本约为 0.004 美元。在 150K 时约为 0.03 美元，30 轮这种规模的会话仅读取就要花 0.90 美元。同样的 30 轮在 20K 下约 0.12 美元。在 Claude 4.6 及更高版本模型中，更大的上下文窗口不会改变每 token 的价格，因此成本完全来自重新发送对话。

这些上下文中有很多是之前工作留下来的：一小时前的堆栈跟踪、你已经处理完的文件、你后来已修复的测试运行输出。它们仍然在每一轮中被发送。

压缩、/compact 和 /clear

当会话接近其上下文限制时，Claude Code 会总结较早的历史，以便后面的轮次发送更少内容。运行 /autocompact 并指定 token 数量，可以改变触发这种情况前的上下文填充程度。

有两个命令可以让你自己做这件事。/clear 清空对话，不花费任何成本，所以当你转到无关工作时使用它。/compact 保持连续性，花费一次请求。它会读取它要总结的对话，你可以说明要保留什么，例如 /compact keep the failing test names and the schema change.

在 150K token 时压缩的大致价格约为 0.25 美元。这包括读取、几千个输出 token 的摘要，以及对较短上下文的一次新缓存写入。之后的每一轮在读取上节省约 0.025 美元，所以压缩在大约十轮内就能回本。在快要结束时进行压缩，花费会超过节省。

摘要也会丢失细节。在调试会话中途进行压缩，可能会丢掉重要的一行日志。在自然的间断点进行压缩，当下一步依赖某个具体内容时，在 /compact 指令中说明。

在你输入之前加载了什么

你的 CLAUDE.md 文件会在每个会话开始时加载到上下文中，因此其中的每一行都是每一轮重发内容的一部分。成本文档建议将其控制在 200 行以内。MCP 工具定义是延迟加载的。开始时只加载工具名称和服务器指令，完整定义在使用该工具时加载。运行 /mcp 查看哪些服务器已连接，关闭你不使用的服务器。

账单的其余部分

下表列出了影响 Claude Code 会话的其他计费规则，并附有文档链接（如有）。

自己测量

本文中的数字是示例。你的代码库、prompt 和习惯不同，所以请在你自己的任务上测量成本。下面是检查方法。

在会话中运行 /usage。/cost 的作用相同。Session 区块显示 token 使用量以及按标价估算的美元成本。prompt-cache 行显示你的输入中有多少来自缓存。在 Pro、Max、Team 或 Enterprise 套餐中，同一屏幕会显示你的套餐用量条。美元数字是在你机器上按标价计算的，因此在订阅套餐中，它是你做了多少工作的指南，而不是账单。

运行同一个任务两次。从你的待办事项中选择一个任务，而不是玩具示例。使用 /model 在 Opus 5 和 Opus 5.5 之间切换。记录每次运行的轮次、输出 token 和成本。在得出结论前做三到四个任务。

对于团队，使用用量和成本报告。Claude Code Analytics API 提供每个用户的估算成本。Usage and Cost API 按模型以及缓存与非缓存 token 细分花费。

尝试 effort 阶梯。在 medium 下运行一个困难任务，然后在 high 下运行。在 low 下运行一个机械任务。

阅读会话

在任务结束时，检查 /usage 中的三件事。

缓存占比。对于长会话，这应该很高。如果很低，查找长时间暂停、effort 或模型更改，或中途连接的 MCP 服务器。

输出与输入的比例。小更改却有很多输出，通常意味着 effort 级别对该任务来说太高，或者模型在重试。

总输入与对话大小的比例。如果总量是对话大小的许多倍，说明会话经历了很多轮次，值得阅读对话以找出循环重复的地方。

作为基准，Claude Code 成本文档给出的企业部署平均值约为每个活跃开发者每天 13 美元，90% 的用户每天低于 30 美元。一个成本远高于你自己正常水平的会话值得检查。

记住

对于范围明确的日常工作，使用 medium effort。

让模型能够检查自己的工作，并在 plan 模式下开始跨文件的更改。

当 medium 卡住时，将 effort 提高到 high。在间断点更改，因为更改可能会产生缓存写入。

如果 high 两次遇到同一个问题，切换到 Fable 5.1。问题解决后切回。

将搜索和日志读取的子代理放在 Sonnet 或 Haiku 上。将代码编辑保留在 Opus 5.5 上。

保持长会话持续进行，这样缓存保持热状态。

在不同任务之间使用 /clear，在间断点使用 /compact，并注明要保留的内容。

最重要的一点：在每个模型上运行一个真实任务，并比较 /usage 报告的结果。你自己得出的数字才是值得信任的。

希望这篇文章对你有所帮助。如果你的限额在 Opus 5.5 上没有比 Opus 5 更耐用，请通过 /feedback 告诉我们。

感谢 Michael Segner、Kacie Jenkins 和 Molly Vorwerck 的审阅。