BroadRouter
开始使用

AI 编程智能体跑一次要花多少钱:步数、上下文增长与缓存

BroadNet Inference 团队 · 阅读约 7 分钟 · 发布于

智能体每一步都会重发全部上下文,所以输入随步数的平方增长:60 步的输入约为 30 步的 3.5 倍。账单的大头由缓存决定;如果历史记录只追加不修改,超过 90% 的输入可以按缓存价格计费。用单次运行成本乘以每月运行次数,再和固定价格会话比较。

编程智能体不是按任务付费,而是按步骤付费,而且每一步都会重发到目前为止的全部对话。这使得一次运行的成本,更多取决于它走了多少步、上下文有多少被缓存,而不是每 token 的价格。本文用这些要素,带着具体数字,算出一次运行的成本,并说明固定价格会话何时比按 token 付费更划算。

每次调用里的 token 从哪里来(工具 schema、读取的文件、历史记录),参见智能体循环的 token 花在哪里。本文讲的是一整次运行的算术。

智能体运行过程中,上下文是怎样增长的?

每次调用都包含:

  • 每次调用都会发送的基础上下文:系统提示词、工具定义、规则文件、仓库地图;
  • 之前各步新增的全部内容:模型的回复和工具调用、文件内容和命令输出;
  • 新的指令或工具结果。

把基础上下文记为 B,每一步新增的 token 记为 g。第 1 步发送 B。第 2 步发送 B + g。第 n 步发送 B + (n − 1) × g。把它们加起来,一次 n 步的运行总共发送:

总输入 = n × B + g × n × (n − 1) ÷ 2

第二项随步数的平方增长。这就是长时间运行常常让人吃惊的原因:60 步运行的最后一步远比第一步大,而中间的每一步都要为之前所有内容再付一次钱。

一个计算示例是什么样的?

假设一个智能体的基础上下文为 15,000 token(系统提示词、十几个工具和一份仓库地图)。每一步新增 3,000 token:一个文件或测试日志,加上模型自己的回复。每一步输出 800 token,含思考部分。

步数 总输入 输出 最大单次调用
10 285,000 8,000 42,000
30 1,755,000 24,000 102,000
60 6,210,000 48,000 192,000

从 30 步到 60 步,工作量翻倍,输入却变成约 3.5 倍。输出只是翻倍。在这几次运行中,输入是输出的 36 到 130 倍,所以对智能体来说,输入价格以及缓存输入价格最为关键。

最大的那次调用还必须装得进上下文窗口。192,000 token 能装进 DeepSeek V4.1 Flash 和 GLM 5.3(各 1,048,576 token)以及 Qwen3.8 27B(262,144),但装不进 Gemma 4 VL 26B(32,768):在这个示例中,第七次调用就已经超出了。

缓存能让账单变化多少?

服务商对重复的提示词前缀按更低的缓存输入价格计费。只往历史记录末尾追加内容的智能体,每次发送的都是相同的前缀再加上一点新内容,所以在最佳情况下,只有上次调用之后新增的 token 是新输入:

新输入(最佳情况)= B + (n − 1) × g

其余全部命中缓存。运行越长,缓存输入的占比越高:

步数 新输入,最佳情况 缓存占比
10 42,000 85%
30 102,000 94%
60 192,000 97%

真实的智能体很少能达到最佳情况,所以最好算三种情形。按 BroadNet 的 DeepSeek V4.1 Flash 价格(每 1M token 输入 $0.175、缓存 $0.0055、输出 $0.52,公布于 2026-11-14),以 30 步最佳情况为基准,各次运行的相对成本如下:

步数 最佳缓存 80% 缓存 无缓存
10 0.33× 0.39× 1.37×
30 1× 2.07× 8.11×
60 2.33× 6.84× 28.2×

有两点值得注意。没有缓存时,一次 60 步运行的成本是缓存良好的 30 步运行的 28 倍。而且运行越长,缓存越重要。在 30 步最佳情况下,输出约占成本的三分之一,新输入不到一半,缓存输入不到四分之一,所以在做好缓存之后,下一个可省的地方就是输出。

缓存不是一个开关。它取决于服务商是否保留前缀,以及你的智能体是否不去改动它。OpenAI 的指南描述的是精确的前缀匹配,并有最小可缓存长度。DeepSeek 自己的 API 会在每个请求的输入和输出末尾存储缓存单元,所以延续上一个请求的后续请求可以命中。BroadNet 的价格页面说缓存输入无需任何设置,其文档会在模型提供时,通过 usage.prompt_tokens_details.cached_tokens 报告命中情况。BroadNet 的模型目录把 DeepSeek V4.1 Flash 列在“models we never ran on our hardware”(译文:我们从未在自己硬件上运行过的模型)之中,其条款(§7.3)涵盖的是“when partner-hosted”(译文:由合作方托管时)的该模型,所以在 BroadNet 上,它是通过合作方提供的。请实际测量你的命中率,不要照搬 DeepSeek 官方的数字。把前缀写成可以被缓存的样子:参见为缓存组织提示词结构。

怎样估算你自己的一次运行?

下面的脚本从 BroadNet 公开的 pricing.json 读取当前价格,所以永远不会过时,并按每种缓存情形输出 token 总量和单次运行成本:

import json, urllib.request

PRICES = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in PRICES["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
p_in, p_cached, p_out = m["input_per_m"], m["cached_input_per_m"], m["output_per_m"]

def run_tokens(steps, base=15_000, growth=3_000, out_per_step=800, cache_rate=None):
    total_in = steps * base + growth * steps * (steps - 1) // 2
    if cache_rate is None:                      # best case: only new tokens miss
        new_in = base + (steps - 1) * growth
    else:
        new_in = round(total_in * (1 - cache_rate))
    return total_in, new_in, steps * out_per_step

def run_cost(total_in, new_in, out):
    return ((new_in * p_in) + (total_in - new_in) * p_cached + out * p_out) / 1e6

for steps in (10, 30, 60):
    for label, rate in (("best", None), ("80%", 0.8), ("none", 0.0)):
        t, n, o = run_tokens(steps, cache_rate=rate)
        print(f"{steps:>3} steps  cache {label:>4}  input {t:>9,}  new {n:>9,}  "
              f"output {o:>6,}  cost/run {run_cost(t, n, o):.4f} USD")

把默认值换成你自己的数字。不要靠猜,从一次真实运行中读取:

  1. 像智能体 token 预算一文那样,记录每次调用的 prompt_tokens、prompt_tokens_details.cached_tokens 和 completion_tokens。
  2. B 是第一次调用的 prompt_tokens。g 是相邻两次调用之间 prompt_tokens 的平均增量。
  3. 每步输出是 completion_tokens 的平均值。它包含思考 token,按输出计费。
  4. 你真实的缓存率是 cached_tokens 之和除以 prompt_tokens 之和。

免费的智能体运行成本估算器在浏览器中执行同样的计算,你不用写代码就能试算其他步数、增长率和缓存率。

哪些因素会让实际成本超出估算?

  • 重试。 一次失败的工具调用或一次 429 重试,都是又一次携带完整上下文的调用。把它们算作步骤。
  • 改动前缀。 系统提示词里的时间戳、换了顺序的工具列表,或者运行中途被编辑的规则文件,都会让从改动处开始的缓存输入重新变成新输入。
  • 压缩。 对历史记录做摘要会缩小上下文,减少之后的输入,但新的历史从未被缓存过,所以下一次调用要付全额输入价格。压缩要少做,而且一次做足;何时压缩,参见长时间运行智能体的上下文管理。
  • 庞大的工具输出。 第 5 步加入的一份 20,000 行测试日志,会跟着之后的每一步一起发送。在公式中,它会增加 20,000 × (剩余步数) 个输入 token。
  • 思考强度。 高强度思考可能让每步输出成倍增加。常规编辑请把 reasoning_effort 设为 low。
  • 走弯路。 一个用 60 步完成 30 步任务的智能体,付出的是平方而不是两倍的代价。步数上限就是成本上限。降低编程智能体成本的十个方法介绍了这些手段。

固定价格会话什么时候比按 token 计费更划算?

把单次运行成本换算成每月数字:每月成本 = 单次运行成本 × 每月运行次数。然后与固定价格套餐比较。在 BroadNet 上,套餐覆盖 DeepSeek V4.1 Flash 且不计 token:Full Moon 每月 $60,Orbit 每周 $15,Meteor 每小时 $1,均按会话计。

盈亏平衡的每月运行次数 = 套餐价格 ÷ 单次运行成本。

有两点让这个比较没有看上去那么简单:

  1. 你的缓存率决定按 token 一侧的成本。 缓存率高时,Flash 按 token 计费很便宜,要跑很多次才能超过 $60。缓存率低时,很快就会超过。固定价格一文把盈亏平衡点表示为每月用量:在 80% 缓存时,约为 9.17亿 输入 token 和 4,600万 输出 token(参见盈亏平衡的计算)。
  2. 时间决定固定价格一侧的上限。 一个会话同一时间处理一个请求。如果一次调用平均耗时 20 秒(预填充、按 约每秒 100 个 token 生成约 800 个输出 token,再加上工具耗时),一次 30 步运行大约需要 10 分钟。这样一个会话每小时最多只能完成约六次运行。更多并行智能体需要更多会话。

对于短时间的突发使用,Meteor 的道理相同,只是规模更小:如果一小时能完成六次运行,每次的成本就是 $1 ÷ 6。把它与脚本算出的单次按 token 成本比较。想试算你自己的用量,请使用固定价格 vs 按 token 计费计算器。

你的使用模式 通常更便宜的是
每天几次短运行 按 token
长时间运行且缓存差 固定价格会话
智能体在大部分工作时间运行 固定价格会话
多个智能体全天并行 每个智能体一个固定价格会话
在 BroadNet 上需要原生工具调用 在 GLM 5.3 或 Qwen3.8 27B 上按 token

BroadNet Inference 适合什么场景

BroadNet 在 usage 块中报告缓存 token 和思考 token,所以上面的每个数字都可以从你自己的运行中测得。DeepSeek V4.1 Flash 缓存输入价格低,上下文为 1,048,576 token,不限量套餐还去掉了它的 token 计量;参见会话如何运作。

先确认一个限制。BroadNet 的文档只为 GLM 5.3 和 Qwen3.8 27B 列出了工具调用,而这两个都不在固定价格套餐中。像 Aider 这样通过文本编辑的智能体,不需要原生工具调用。如果你的智能体需要,请在购买套餐之前先用你的智能体测试 DeepSeek V4.1 Flash,或者按 token 为 GLM 或 Qwen 做预算。另外,如果你的智能体只是偶尔运行,按 token 付费通常比任何固定价格套餐都便宜。

常见问题

AI 编程智能体跑一次要花多少钱?

先数 token,再算价格。在本文的示例中,一次 30 步的运行,基础上下文 15,000 token,每步新增 3,000 token,总共发送 1,755,000 个输入 token 和 24,000 个输出 token。具体花多少,主要取决于有多少输入按缓存价格计费。

为什么智能体运行越长,成本增长得越不成比例?

每一步都会重发之前的全部内容。每一步的输入呈直线增长,所以整次运行的总量随步数的平方增长。在计算示例中,把一次运行从 30 步加倍到 60 步,输入会变成约 3.5 倍。

编程智能体的缓存命中率大概能有多少?

这取决于智能体和服务商。如果历史记录严格只追加,只有最新的 token 会未命中,在我们的示例中是 85% 到 97%。修改历史、在系统提示词里放时间戳、长时间停顿都会拉低命中率。请用 prompt_tokens_details.cached_tokens 来测量。

对智能体来说,固定价格会话什么时候比按 token 计费便宜?

当单次运行成本 × 每月运行次数超过套餐价格时。在 BroadNet 上,DeepSeek V4.1 Flash 的 Full Moon 套餐每个会话每月 $60。轻度或偶尔使用,通常按 token 计费更便宜。

思考 token 会改变估算结果吗?

会。它们按输出计费,而输出每 token 比输入更贵。把你测得的思考量计入每步的输出。在 BroadNet 上,如果模型提供,completion_tokens_details.reasoning_tokens 会报告这个数值。

以 Markdown 格式阅读问 ChatGPT问 Claude问 Perplexity