Mercury 3 把扩散语言模型推到 100 万 token 上下文：1,068 token/s 旁边，官方文档还停在上一代

一、官方在 2026-10-19 说了什么#

先划来源层级。这一天有两份官方材料：Inception 官方博客《Diffusion at Scale: Introducing Mercury 3》，以及同日的 BusinessWire 新闻稿。下面这几条属于厂商自述，没有独立验证：

• Mercury 3 是迄今最强的扩散式大语言模型（dLLM），在多项基准测试上优于 GPT-6 Luna 与 Claude Haiku 5.5，同时快 4–8 倍。
• 上下文窗口 100 万 token，上一代 Mercury 2.5 是 26 万 token。
• 规模比 Mercury 1 大 40 倍以上；官方口径的「intelligence」从 Mercury 1 (mini) 到 Mercury 3 提升 3 倍。
• Inception 的 LinkedIn 帖另称 Mercury 3 比 Mercury 2 智能高 40%——这条来自厂商社交渠道，属于单独一层，比博客与新闻稿都要弱，建议只当方向性参考。

速度这个数字要单独拿出来看，因为两份官方材料给的不一样：博客写 1,068 tokens/s（在 NVIDIA GPU 上），新闻稿只写「超过 1,000 tokens/s」。一个精确到个位，一个只给区间——同一家公司同一周的两份材料都留了余地，你就不该把 1,068 当成你机器上的预期值。

版本谱系也是官方给的：Mercury 1 发布于 2025 年 6 月，Mercury 3 是第四个模型版本；Mercury 2 引入了推理，Mercury 2.5 引入了可调推理与 26 万 token 上下文。也就是说这条产品线在一年多时间里走了四步，而前三步都在解决「推理能力」这件事，第四步才把上下文和规模一起推上去。

公司背景（官方公布）：Inception 位于 Redwood City，2025-11-06 宣布 5000 万美元融资，Menlo Ventures 领投，Mayfield、Innovation Endeavors、NVentures（英伟达风投）、M12（微软风投）、Snowflake Ventures、Databricks Investment 参与；个人投资者里有吴恩达、Andrej Karpathy、Eric Schmidt。这份名单解释了一件事：这家公司的赌注是被主流资本认可的，但被投资不等于技术指标被验证。

创始人 Stefano Ermon 在新闻稿里的原话值得抄下来：他说自 Mercury 1 以来最常被问到的问题是「扩散能不能 scale」，而 Mercury 3 大 40 倍以上、能力显著更强，仍然跑在 1,000 tokens/s 以上；他强调扩散模型的极限是算力与数据，不是算法层面的根本障碍；并称他们已经开始训练下一个模型。

二、机制：并行生成 token 是速度差的唯一来源#

官方给的解释很直白：自回归模型逐 token 串行生成，扩散模型可以并行生成多个 token，这是速度差异的根本来源。

这句话技术上没有争议，但它决定了一件事：扩散带来的速度优势，作用在单次生成的墙钟时间上，而不会减少 agent 任务的步数。一个 30 步的 agent 流程，改的是每一步生成得快不快，不是每一步要不要依赖上一步的真实工具返回。所以端到端时间大致等于「输出 token 总量 ÷ 吞吐」再加上「步数 × 每次首 token 等待」。我下面那段成本账就是按这个结构算的。

另外，官方提到的「极限是算力与数据」是一句立场声明而非研究成果——所有模型厂商都会这么说。真正可核查的是下一代的规模与延迟，官方只说已经在训练，没有给任何时间表。

三、定价：发布期五折的算术#

价格来自 Inception 官方 Models / Pricing 页，我 2026-10-26 核对；原文同时列出标准价与发布期五折价。

三个数字关系值得在纸上核一遍，因为它们很容易被读反：

第一，缓存折扣的表述。 官方博客写「缓存 token 为输入价的 9 折优惠」，指的是便宜 90%，不是打九折。对上表格：0.20 降到 0.02、发布期 0.10 降到 0.01，都是差一个数量级。中文里「9 折优惠」这种写法天然容易误读，所以我一直按绝对价格记：输入每百万 0.10 美元、缓存输入每百万 0.01 美元。

第二，单位换算。 $0.10 / 百万 token 等于每 10 万 token 花 0.01 美元，等于每 1000 token 花 0.0001 美元。输出是输入的 3.5 倍（0.35 比 0.10）——所以只优化输入、不优化输出长度的做法，在这个价目表上省不到大头。不过注意，我这个 30 步负载里输出只占 24000 token，输入累计 579000 token，输入仍然是大头，具体看你的负载形状。

第三，Decide 是完全不同的计价模型。它输出计 0 美元、只按输入计费，官方称在 JevBench 与 LegalBench 上优于 Jev（这两个基准与对比对象官方只给了名字，没有公开细节，我这里不展开）。这条产品需要联系销售，不是自助开通，所以它对你的意义是「可以谈」，不是「可以用」。

顺带一条对存量用户更重要的信息：官方 Models 页脚注写明 Mercury 2 与 Mercury 2.5 不再对新用户开放；2026-10-19 之前已有用量的客户可以保留访问到 2026-11-15。这是「厂商自己平台停售」的口径，记住这个词，下面会出现矛盾。

四、第三方渠道核对：挂牌价对得上，但停售对不上#

我在 2026-10-26 亲手拉了一次 OpenRouter 的公开模型列表 API（https://openrouter.ai/api/v1/models，当时一共 467 个模型），这几条是可复现的：

• inception/mercury-3 已经在列：上下文长度 1,000,000，单次最大输出 131,072。
• 定价：每 token 0.0000001（输入）= 每百万 0.10 美元；每 token 0.00000035（输出）= 每百万 0.35 美元；缓存读取每百万 0.01 美元——与官方发布期五折价完全一致。
• 该渠道声明支持的参数集包含：reasoning_effort、reasoning、include_reasoning、tools、tool_choice、structured_outputs、response_format、temperature、stop、max_tokens。这对做 agent 的人来说是实质性信息：工具调用与结构化输出都在这张清单里。

但同一份列表里还有两组不该出现的东西：**inception/mercury-2.5（26 万上下文、每百万输入 0.04 ／输出 0.15 美元）**与 inception/mercury-2（12.8 万上下文、每百万 0.25 ／ 0.75 美元）——这正是官方说「不再对新用户开放」的两个型号。

这两件事不冲突，但必须分开说清楚：官方平台停售指的是 Inception 自己不再给新用户开这两个型号；第三方网关仍在服务指的是路由平台手上的存量接入还在跑。你从 OpenRouter 走，今天可能还能调 mercury-2.5；你从 Inception 平台走，新账号调不到。同一句「停售」，在两个入口上含义不同。写选型文档时，别只写「已下线」，要写「在哪个入口下线」。

顺带注意价格阶梯：mercury-2.5 的输入价 0.04 美元比 Mercury 3 的发布期价 0.10 美元更低。也就是说升级到 Mercury 3，单价并不是不变的——发布期结束后，你的输入成本会变成 0.20 美元，是旧的 2.5 的五倍。这条对比在官方任何材料里都不会被强调。

五、官方文档的滞后：头牌换了，示例没换#

我在 2026-10-26 抓取了 https://docs.inceptionlabs.ai/get-started/get-started，这页 Quick Start 里的模型名仍然全是 mercury-2，覆盖以下八个位置：

cURL、Python（inceptionai SDK）、TypeScript、AISuite、LiteLLM、LangChain、OpenAI SDK、Vercel AI SDK。

而官方 Models 页的头牌已经是 Mercury 3。示例里出现的参数还是 reasoning_effort: "medium"、temperature: 0.75、max_tokens: 8192。

文档里确认存在的接口事实也一并记下来，这些是照着写代码要用的：API 兼容 OpenAI，base_url 为 https://api.inceptionlabs.ai/v1；SDK 包名是 inceptionai，用法是 from inceptionai import Inception，密钥从环境变量 INCEPTION_API_KEY 读。新 API key 送 1 亿免费 token。可用渠道包括 Inception API 平台、OpenRouter、Baseten、Vercel。企业版支持独占容量、自动扩缩、合规控制与可配置数据保留。

这条滞后对你的实际影响很具体：照着 Quick Start 复制粘贴，你会拿到上一代模型。要跑 Mercury 3，你得自己把模型名换成 mercury-3，而换掉之后，文档里没有对应的参数取值说明——比如 reasoning_effort 在 Mercury 3 上支持哪些档位，官方文档并未说明。

六、代码一：流式调用，自己量首 token 时间与吞吐#

官方给的是 1,068 tokens/s，你机器上的真实值取决于网络往返、排队、你的 prompt 长度和输出长度。所以第一段代码只做一件事：流式接收，自己数首 token 时间（TTFT）与整体吞吐。它需要 INCEPTION_API_KEY 与 pip install openai。

# mercury3_stream_bench.py —— 流式调用 mercury-3，自己量 TTFT 与 tokens/s
# 需要：pip install openai，并在环境变量里放好 INCEPTION_API_KEY
import os
import time

from openai import OpenAI

client = OpenAI(
    base_url="https://api.inceptionlabs.ai/v1",   # 官方声明兼容 OpenAI 协议
    api_key=os.environ["INCEPTION_API_KEY"],      # 新 key 送 1 亿免费 token
)

PROMPT = "用 200 字解释扩散语言模型和自回归语言模型在生成方式上的区别。"

start = time.perf_counter()
ttft = None          # 首 token 时间
chars = 0            # 收到的字符数（流式接口不返回 token 计数，只能粗估）

stream = client.chat.completions.create(
    model="mercury-3",                 # 注意：官方文档示例里这里还写着 mercury-2
    messages=[{"role": "user", "content": PROMPT}],
    stream=True,
    temperature=0.75,                  # 按官方 Quick Start 示例口径
    max_tokens=8192,
    # reasoning_effort="medium",       # 可调推理档位；Mercury 3 支持哪些取值官方未说明
)

for chunk in stream:
    if not chunk.choices:              # 某些分片只带 usage / 审计字段，没有 choices
        continue
    delta = chunk.choices[0].delta
    text = getattr(delta, "content", None) or ""
    if not text:
        continue                       # 推理过程或空分片，跳过
    if ttft is None:
        ttft = time.perf_counter() - start      # 第一个可见字符的时间
    chars += len(text)
    print(text, end="", flush=True)             # 边收边打，避免整段等待

elapsed = time.perf_counter() - start

# 粗估：按 4 字符/token 折算。生产里请用响应里的 usage 字段，或接本地 tokenizer 精确计。
approx_tokens = max(1, chars // 4)
print()
print(f"TTFT       {ttft:.3f}s" if ttft else "TTFT       超时，未收到任何分片")
print(f"总时长     {elapsed:.3f}s")
print(f"输出字符   {chars}")
print(f"约合 token {approx_tokens}")
print(f"整体吞吐   {approx_tokens / elapsed:.1f} tokens/s")

三个使用上的坑先写在这里：流式分片不一定每个都带 choices，有些只带用量或审计字段，不判断就会 IndexError；推理模型的思维链可能走单独字段（OpenRouter 的参数集里有 reasoning 与 include_reasoning），用 delta.content 取值就不会把思维链当正文输出；最后，流式接口通常不返回 token 计数，上面按 4 字符折算 token 只是量级估计，要精确计费口径得接 tokenizer。

七、代码二：30 步 agent 负载的时间与成本账#

这段不依赖任何 API key，只用标准库，我在本机跑通了，下面的输出是从终端直接粘的，没有改动。它回答的问题是：同一个 agent 负载，换成 1,068 tokens/s 的扩散模型，到底省下什么。

负载设定（都写在脚本里）：一次任务 30 步，每步生成 800 token；系统提示与工具定义 1500 token，第 1 步写入后一直命中缓存；每步工具返回 400 token。单价用官方发布期五折价：输入每百万 0.10 美元、输出每百万 0.35 美元、缓存输入每百万 0.01 美元。对比对象用一个假设的 150 tokens/s（这是假设值，不是任何实测，只为演示速度优化型前沿模型与 dLLM 的差距）。脚本只算生成时间，不含首 token 等待、网络往返和排队——这三项我在本机测不到。

#!/usr/bin/env python3
"""agent_throughput_budget.py —— 同一份 agent 负载下，串行速度型前沿模型 vs Mercury 3 的端到端时间与成本账。

口径（写在脚本里，避免读者猜）：
- Mercury 3 生成速度 = 1,068 tokens/s（Inception 官方博客口径，NVIDIA GPU 上）；新闻稿只写「超过 1,000 tokens/s」。
- 对比模型 = 150 tokens/s，**假设值**，不是实测。
- 单价：输入 $0.10 / 百万 token，输出 $0.35 / 百万 token，缓存输入 $0.01 / 百万 token（官方发布期五折价）。
- 只算生成时间：不含首 token 等待、网络往返、排队。
"""

STEPS = 30                # 一次 agent 任务 30 步
OUT_PER_STEP = 800        # 每步生成 800 token
SYSTEM_TOKENS = 1500      # 系统提示 + 工具定义，第一步写入，之后一直命中缓存
TOOL_TOKENS = 400         # 每步工具返回值（新写入缓存的部分）

PRICE_IN = 0.10 / 1e6
PRICE_OUT = 0.35 / 1e6
PRICE_CACHE_IN = 0.01 / 1e6

TPS_DLLM = 1068           # Mercury 3，官方口径
TPS_SERIAL = 150          # 假设值：速度优化型前沿模型


def input_tokens(step):
    """第 step 步（从 1 开始）送进去的输入 token 总数。"""
    return SYSTEM_TOKENS + TOOL_TOKENS * step + OUT_PER_STEP * (step - 1)


def new_tokens(step):
    """该步输入里「新写入」的部分：第一步是系统块 + 工具返回，之后只有工具返回。"""
    return SYSTEM_TOKENS + TOOL_TOKENS if step == 1 else TOOL_TOKENS


def step_cost(step, output=OUT_PER_STEP):
    full = input_tokens(step)
    fresh = new_tokens(step)
    cached = full - fresh
    return (fresh * PRICE_IN + cached * PRICE_CACHE_IN + output * PRICE_OUT, full, fresh, cached)


def main():
    print("== 负载设定 ==")
    print(f"步数 {STEPS}，每步生成 {OUT_PER_STEP} token，"
          f"系统块 {SYSTEM_TOKENS} token，每步工具返回 {TOOL_TOKENS} token")
    print(f"生成速度：Mercury 3 = {TPS_DLLM} tokens/s（官方口径）；"
          f"对比串行模型 = {TPS_SERIAL} tokens/s（假设值，非实测）")
    print()

    print("== 逐步账单（挑几步打印，含缓存命中率）==")
    print(f"{'步':>3} {'输入token':>10} {'新写入':>8} {'命中缓存':>9} {'缓存占比':>8} "
          f"{'Mercury3耗时':>12} {'串行耗时':>10} {'该步成本':>10}")
    total_in = total_fresh = total_cached = total_out = 0
    cost_cached = cost_uncached = 0.0
    t_dllm = t_serial = 0.0
    show = {1, 5, 10, 15, 20, 25, 30}
    for step in range(1, STEPS + 1):
        c, full, fresh, cached = step_cost(step)
        d_dllm = OUT_PER_STEP / TPS_DLLM
        d_serial = OUT_PER_STEP / TPS_SERIAL
        t_dllm += d_dllm
        t_serial += d_serial
        total_in += full
        total_fresh += fresh
        total_cached += cached
        total_out += OUT_PER_STEP
        cost_cached += c
        cost_uncached += full * PRICE_IN + OUT_PER_STEP * PRICE_OUT
        if step in show:
            print(f"{step:>3} {full:>10,} {fresh:>8,} {cached:>9,} {cached/full:>7.1%} "
                  f"{d_dllm:>11.2f}s {d_serial:>9.2f}s {c:>9.5f}美元")
    print()

    print("== 整任务汇总 ==")
    print(f"累计输入 {total_in:,} token（其中新写入 {total_fresh:,}，命中缓存 {total_cached:,}，"
          f"整体缓存率 {total_cached/total_in:.1%}）")
    print(f"累计输出 {total_out:,} token")
    print(f"生成耗时：Mercury 3 {t_dllm:.2f}s（{t_dllm/60:.2f} 分钟） vs "
          f"串行模型 {t_serial:.2f}s（{t_serial/60:.2f} 分钟），比值 {t_serial/t_dllm:.2f}x")
    print(f"总成本（含缓存）：{cost_cached:.5f} 美元")
    print(f"总成本（若全部按标准输入价）：{cost_uncached:.5f} 美元")
    print(f"缓存省下：{cost_uncached - cost_cached:.5f} 美元，占比 "
          f"{(cost_uncached - cost_cached)/cost_uncached:.1%}")
    print()

    print("== 关键结论：成本一样，差别在单位时间能跑完多少任务 ==")
    per_task_tokens = total_in + total_out
    print(f"两种模型 token 用量完全相同：{per_task_tokens:,} token/任务 → "
          f"单价一样，成本一样，都是 {cost_cached:.5f} 美元/任务")
    for name, t in (("Mercury 3", t_dllm), ("串行模型", t_serial)):
        print(f"  {name:<10} 单任务 {t:>6.2f}s → 单流每小时可交付 {3600/t:>6.1f} 个任务 → "
              f"每任务成本 {cost_cached:.5f} 美元 → 跑满一小时的 token 支出 "
              f"{cost_cached*3600/t:.4f} 美元（花得多是因为干得多，不是单价贵）")
    print(f"同一张卡、同样顺序跑，Mercury 3 每小时能交付的任务数是串行模型的 "
          f"{(t_serial/t_dllm):.2f} 倍；token 账单不会因此变便宜，变便宜的是"
          f"「排队时间」和「你需要几张卡」。")
    print(f"反过来算：如果业务要求每小时交付 100 个任务，Mercury 3 需要 "
          f"{100/(3600/t_dllm):.2f} 条并发流，串行模型需要 {100/(3600/t_serial):.2f} 条。")

    print()
    print("== 敏感性：假设吞吐从 150 改成 400 tokens/s ==")
    for tps in (150, 400):
        t = total_out / tps
        print(f"  串行模型 {tps:>4} tokens/s → 整任务 {t:>6.2f}s，"
              f"相对 Mercury 3（{t_dllm:.2f}s）慢 {t/t_dllm:.2f}x")


if __name__ == "__main__":
    main()

本机真实输出（2026-10-26，Python 3.13）：

== 负载设定 ==
步数 30，每步生成 800 token，系统块 1500 token，每步工具返回 400 token
生成速度：Mercury 3 = 1068 tokens/s（官方口径）；对比串行模型 = 150 tokens/s（假设值，非实测）

== 逐步账单（挑几步打印，含缓存命中率）==
  步    输入token      新写入      命中缓存     缓存占比   Mercury3耗时       串行耗时       该步成本
  1      1,900    1,900         0    0.0%        0.75s      5.33s   0.00047美元
  5      6,700      400     6,300   94.0%        0.75s      5.33s   0.00038美元
 10     12,700      400    12,300   96.9%        0.75s      5.33s   0.00044美元
 15     18,700      400    18,300   97.9%        0.75s      5.33s   0.00050美元
 20     24,700      400    24,300   98.4%        0.75s      5.33s   0.00056美元
 25     30,700      400    30,300   98.7%        0.75s      5.33s   0.00062美元
 30     36,700      400    36,300   98.9%        0.75s      5.33s   0.00068美元

== 整任务汇总 ==
累计输入 579,000 token（其中新写入 13,500，命中缓存 565,500，整体缓存率 97.7%）
累计输出 24,000 token
生成耗时：Mercury 3 22.47s（0.37 分钟） vs 串行模型 160.00s（2.67 分钟），比值 7.12x
总成本（含缓存）：0.01540 美元
总成本（若全部按标准输入价）：0.06630 美元
缓存省下：0.05090 美元，占比 76.8%

== 关键结论：成本一样，差别在单位时间能跑完多少任务 ==
两种模型 token 用量完全相同：603,000 token/任务 → 单价一样，成本一样，都是 0.01540 美元/任务
  Mercury 3  单任务  22.47s → 单流每小时可交付  160.2 个任务 → 每任务成本 0.01540 美元 → 跑满一小时的 token 支出 2.4679 美元（花得多是因为干得多，不是单价贵）
  串行模型       单任务 160.00s → 单流每小时可交付   22.5 个任务 → 每任务成本 0.01540 美元 → 跑满一小时的 token 支出 0.3466 美元（花得多是因为干得多，不是单价贵）
同一张卡、同样顺序跑，Mercury 3 每小时能交付的任务数是串行模型的 7.12 倍；token 账单不会因此变便宜，变便宜的是「排队时间」和「你需要几张卡」。
反过来算：如果业务要求每小时交付 100 个任务，Mercury 3 需要 0.62 条并发流，串行模型需要 4.44 条。

== 敏感性：假设吞吐从 150 改成 400 tokens/s ==
  串行模型  150 tokens/s → 整任务 160.00s，相对 Mercury 3（22.47s）慢 7.12x
  串行模型  400 tokens/s → 整任务  60.00s，相对 Mercury 3（22.47s）慢 2.67x

这张输出里有四个可以直接拿去用的结论。

第一，缓存率会随会话变长趋近饱和。 第 1 步缓存占比是 0，第 5 步已经 94.0%，第 30 步 98.9%，整任务整体 97.7%。这意味着长会话 agent 的成本几乎完全由「首次写入的那部分输入」和「输出」决定——而这个负载里输入累计 579,000 token，其中真正按标准价计费的只有 13,500 token。

第二，缓存的省钱幅度是 76.8%。 同一个任务，全部按标准输入价算是 0.06630 美元，走缓存是 0.01540 美元，省下 0.05090 美元。这是我在上一篇里没强调过的一句：输入价和缓存价差一个数量级时，缓存配置不是优化项，是成本结构的主要变量。

第三，速度差 7.12 倍，而且它落在 4–8 倍这个官方区间里。 官方说 Mercury 3 比对手快 4–8 倍；我这里用的假设吞吐 150 tokens/s 算出来是 7.12 倍，假设改成 400 tokens/s 就掉到 2.67 倍。换句话说，官方那个「快 4–8 倍」的宣称，等价于「对手大约在 130 到 270 tokens/s 之间」——如果你的对手模型实测跑到 400 tokens/s 以上，这个倍数就不成立。这是我读这类宣称时最常用的反推法：把倍数换算成对手的速度区间，再看你实际用的模型落在哪里。

第四，速度不改变 token 账单。 两种模型 token 用量完全相同（603,000 token/任务），单价一样，所以每任务成本都是 0.01540 美元。跑满一小时，Mercury 3 花了 2.4679 美元、串行模型花了 0.3466 美元——前者花得多，是因为它完成了 160.2 个任务、后者只完成 22.5 个。扩散模型在这里卖的不是折扣，是单位时间交付量。如果业务要求每小时交付 100 个任务，Mercury 3 只要 0.62 条并发流，串行模型需要 4.44 条——这才是 1,068 tokens/s 真正的商业含义。

八、合作方数据：全部是厂商新闻稿里的自述#

新闻稿里附了四家合作方的话，这些都属于「厂商自述、未经独立验证」，我一条都没有独立复现过：

• TinyFish AI：在他们的生产 web-agent harness 上跑 50 个 Mind2Web 实时导航任务，Mercury 3 完成了 50%，按他们的说法「显著多于 GPT-6.1-Sol」，而且 token 量与 agent 步数相同、单 token 成本只是零头。
• Octen AI：Sense API 测试中搜索约 80 毫秒、模型生成中位 0.9 秒、端到端中位 2.2 秒；称在智能眼镜上 5 秒的答案「感觉是坏的」。
• RevisionDojo（General Learning）：提示、批改、释义约 1 秒返回，质量不低于此前模型。
• Lorikeet（面向受监管行业）：早期测试中 Mercury 3 延迟更低、评测与生产表现更好。

读这三组数字有个技巧：Octen 那三个数分别是三个不同层次——80 毫秒是检索耗时，0.9 秒是模型生成中位，2.2 秒是端到端中位。转述时把它们混成一句「Mercury 3 只要 80 毫秒」，就不是读错，而是换了事实。

至于 TinyFish 那条，最值得注意的不是 50%，而是「完成 50%」这个绝对数——也就是说另外 25 个实时导航任务没有完成。厂商挑这个数出来讲，是因为它比对手高；但任何人在选型前都该问一句：剩下那一半失败的任务，失败在哪里。

九、要试的话，先看这八条#

1. 模型名。 写 mercury-3，别照抄文档里的 mercury-2。这是今天最常见的坑。
2. 入口决定价格和可用性。 官方平台、OpenRouter、Baseten、Vercel 四个渠道，价格虽然对上了，但「停售」这件事在官方平台与第三方网关上的状态不一样。
3. 缓存配置是成本主变量。 输入价比缓存价贵 10 倍，我那个负载里缓存把总成本压掉 76.8%。
4. 输出比输入贵 3.5 倍。 发布期 0.35 比 0.10、标准价 0.70 比 0.20，倍数一样；所以控制输出长度和把前缀喂进缓存，这两件事的收益要分开算。
5. 发布期五折会结束。 结束之后 Mercury 3 的输入价是 0.20 美元，比在售的 mercury-2.5（0.04 美元）贵五倍。预算模型要按标准价写。
6. reasoning_effort 的可用取值，官方文档没说。 Mercury 2.5 才引入可调推理，示例里写的是 medium；Mercury 3 支持哪些档位属于「官方未说明」，自己实测的时候记得把发现记下来。
7. Mercury Decide 不是自助商品。 输出计 0 美元、按输入计费，但需要联系销售。
8. 免费额度够你做第一轮实测。 新 key 送 1 亿免费 token——先在你自己机器上量 TTFT 和输出吞吐，再决定要不要把「1,068 tokens/s」写进方案文档。

总结#

把这次发布拆成四句话：

1. 官方确认的都是「能力主张」，不是可复现的数字。 100 万 token 上下文、40 倍规模、3 倍智能提升、4–8 倍速度，全部来自官方博客与同日新闻稿；能自己量的是 TTFT、吞吐和你负载上的端到端时间，上面第六节那段脚本就是干这个的。
2. 价格算术比宣传更实用。 发布期输入 $0.10、输出 $0.35、缓存输入 $0.01；输出是输入的 3.5 倍，输入与缓存差 10 倍。我在 OpenRouter 上核到的挂牌价与之完全一致——这是我这次唯一拿到手的、可复核的第三方证据。
3. 第三方渠道与官方口径有一处矛盾，而且它不影响使用。 官方说 Mercury 2 / 2.5 不再对新用户开放（存量用户到 2026-11-15），OpenRouter 上两个旧型号仍在列。这是「平台停售」与「网关仍服务」的差别，按你的入口判断，别写成「已下线」。
4. 扩散模型卖的不是便宜，是单位时间交付量。 30 步、每步 800 token 的负载里，成本两种模型一样（0.01540 美元/任务），差别在端到端 22.47 秒 vs 160 秒，在每小时 160.2 个 vs 22.5 个任务，在每小时 100 个任务只需要 0.62 条并发流 vs 4.44 条。

最后一句留给我自己的核对习惯：读这类发布，先把「官方博客」「同日新闻稿」「厂商社交渠道」「合作方自述」四层分开放，再去找第三方挂牌价这种能复核的硬证据。这篇文章里能复核的部分，我只找到 OpenRouter 那一份。

参考与致谢#

• Inception 官方博客《Diffusion at Scale: Introducing Mercury 3》，2026-10-19（1,068 tokens/s、40 倍规模、3 倍智能、100 万上下文、机制说明；本文只核到标题、日期与上述数字）
• BusinessWire 同日新闻稿，2026-10-19（Ermon 原话、合作方自述、公司背景与融资）
• Inception 官方 Models / Pricing 页，2026-10-26 核对（三档价目表、Mercury 2 / 2.5 停售脚注、Mercury Decide 需联系销售）；同页另有 Mercury Voice 的 TTFT 低于 170 毫秒说法
• Inception 官方文档 Quick Start：https://docs.inceptionlabs.ai/get-started/get-started，2026-10-26 抓取（八个示例仍写 mercury-2；base_url、SDK 包名 inceptionai、INCEPTION_API_KEY、1 亿免费 token、渠道与企业版能力）
• Inception API 入口：https://api.inceptionlabs.ai/v1（兼容 OpenAI 协议）
• OpenRouter 公开模型列表 API：https://openrouter.ai/api/v1/models，2026-10-26 本机实测（共 467 个模型；mercury-3 的上下文、最大输出、三项定价与参数集）
• 披露：本文不含推广链接，与 Inception、OpenRouter 无利益关系。第七节的脚本与输出均为本机实测；第六节代码需要你自己的 API key，本文未运行。厂商自述、社交渠道说法与合作方数据在文中已分层标注，请勿混用。