本文部分内容由 AI 辅助整理，所有价格、数据均标注了出处；token 用量与任务消耗为公开统计 / 券商测算口径，速算脚本为本机真实运行并贴出原始输出。

8 月 6 日，DeepSeek 在开发者后台发了条公告：拟整体上调 API 服务定价，预计涨幅较大。但这已经不是第一家了——从年初到现在，智谱年内三次提价，Kimi 随新模型直接把输出价定到每百万 token 100 元（国产最高），豆包把免费版转成订阅，腾讯云也连涨两轮。曾经以「价格屠夫」著称的 DeepSeek 一起涨价，被业内普遍解读为国产大模型价格战的拐点。

但如果你只看到「厂商在涨价」，可能漏掉了真正在涨的东西。这篇想从另一头算这笔账：**这一波集体涨价的背后，是全国 token 用量两年涨了 1000 倍；而你的 AI 账单失控，通常不是单价涨了，是任务量涨了。**文末附一个速算工具，把任务类型、次数、单价代进去，几分钟看清你的账单贵在哪。

一、先看热点事实：这次是集体涨价，不止 DeepSeek 一家

把最近的调价信息排一下（均为公开报道口径，以各厂官方最新公告为准）：

• DeepSeek（8 月 6 日）：拟整体上调 API 服务定价，涨幅较大，细则与生效时间未公布。此前已执行峰谷分时计费——工作日 9:00-12:00、14:00-18:00 高峰时段全部计费项价格翻倍，深夜与周末为平峰原价。
• Kimi（月之暗面）（7 月 17 日随 K3 发布）：输入每百万 token 20 元、输出 100 元（缓存未命中口径），比上一代 K2.6 输入约涨 3 倍、输出涨近 4 倍，是目前国产模型里定价最高的。
• 智谱（年内三次提价）：一季度 API 累计提价 83%；7 月底 GLM Coding Plan 套餐大幅调价，Lite / Pro / Max 从 40 / 149 / 469 元涨到 118 / 538 / 1078 元，最低涨幅 130%、最高超 260%。
• 豆包：6 月底推出收费的专业版，从免费转向订阅制。
• 腾讯云：连续两次宣布涨价。

高盛把国产大模型厂商 2026 年末合计 ARR 预期从 100 亿美元上调到 130 亿美元。券商研报普遍认为，涨价是「行业从价格战回归理性定价」的信号——而价格的背后是算力成本，算力成本的背后是用量。

二、反常识一：涨价是结果，不是原因

厂商为什么敢集体涨价？一个常被忽略的背景数字：中国日均 token 调用量，从 2024 年初的约 1000 亿，涨到 2026 年 3 月的 140 万亿，两年增长超过 1000 倍。（中国信通院副院长魏亮在央视财经《中国经济大讲堂》的公开口径，国家统计局此前也公布过同一数字。）

单看豆包一家：日均使用量 3 个月翻倍到 120 万亿 token（2026 年 4 月公开报道）。这不是个别公司的增长，是行业级的需求爆炸。

推理需求爆炸 → 高端 GPU 供不应求 → 算力成本上升 → API 价格上调。所以涨价不是「厂商贪心」，更准确地说，是用量把这个行业的单价抬起来了。你越是用得多，行业越是涨——这个循环里，单个开发者改变不了单价，但可以改变「你的用量对应的成本结构」。

三、反常识二：一次 Agent 任务 = 上千次单轮对话

这才是这篇最想说的点：涨价涨的是单价，但你的账单大头往往是任务量。

券商测算（东吴证券口径）：单轮对话只消耗数百 token；而一个企业级智能体（Agent）完成一次复杂任务，往往需要数十万到数百万 token。按量级换算：

• 一个 40 万 token 的编码 Agent 任务 ≈ 800 次单轮对话；
• 一个 400 万 token 的企业级复杂任务 ≈ 8000 次单轮对话。

同样是「用 AI」，以前你点一下对话框是几百 token，现在 Agent 替你跑一个任务，背后是几十万到几百万 token。中金的测算更直观：在中等使用强度下，Agent 渗透率只要到 8%，它的总 token 消耗就与全部 Chatbot 相当。

所以「一次 Agent 任务 = 上千次对话」不是比喻，是量级事实。单价涨 3 倍，任务量涨 1000 倍，谁才是账单失控的原因，一目了然。

四、成本模型：账单 = 任务数 × 单任务 token × 单价

不搞复杂的模型，就三笔：

单任务 token = 输入 token + 输出 token
单任务成本 = 输入 token × 输入单价 + 输出 token × 输出单价
月账单 = 单任务成本 × 任务次数

三个变量里：

• 任务数：你的业务决定，Agent 化越深越大；
• 单任务 token：任务复杂度决定，这是最容易被忽略的「隐藏倍数」；
• 单价：模型决定，而且这一轮正在集体上涨。

大多数人的账单失控，发生在第二个变量——单任务 token 从几百涨到几十万，你还没意识到。文末的脚本就是帮你把这个隐藏倍数显形。

五、本地部署的产能：我们实测的账

算本地这笔账之前，先确认产能。我们在这套环境上实测过：2 台 DGX Spark 直连（TP=2，合计 256 GB 统一内存），跑 deepseek-v4-flash-0731，官方 FP8 权重，没有自行量化。都是我们自己机器上实测的，只代表这一套环境、这一个模型版本、这一组参数，不是行业通用值。

• 单并发 84.89 tok/s，八并发合计 284.80 tok/s（decode 阶段）；
• deepseek-v4-flash-0731 是稀疏 MoE 模型，总参 2840 亿、每次只激活 130 亿（公开资料口径），所以两台 256GB 装得下、桌面机器跑得动；
• 本次实测是两台 Spark 之间网线直连，没有经过存储 / 调度中枢——机器再多，才需要它。

本地部署的成本结构是「一次性硬件 + 电费运维」，跟 API 单价无关；你的 Agent 任务在本地跑，token 不按个计费。这对「任务量大、单价又在涨」的场景是结构性的优势——而这正是前面算出来的账单大头。

六、速算工具：Agent 任务 token 消耗速算脚本

把上面的账固化成脚本（零依赖，Python 3 标准库即可运行）。预置了 5 档任务类型的 token 量级（行业公开测算量级，非本机实测），输入任务类型、次数、单价，输出单次与总成本、量级换算、以及本地折算时长。脚本与本文档中的真实运行输出逐字一致。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Agent 任务 token 消耗速算脚本：按任务类型估单次消耗，乘单价算成本，对比本地生成时长。

背景：全国日均 token 调用量两年从约 1000 亿涨到 140 万亿（信通院/统计局口径）。
一个企业级 Agent 任务的 token 消耗量级是单轮对话的上千倍（券商测算口径）。
本脚本把「任务类型 -> token 量级 -> 单价 -> 成本 -> 本地折算」串起来，帮你看清
你的账单到底贵在单价还是贵在任务量。

⚠️ 口径声明：
  1. 任务 token 量级 = 行业公开测算量级（信通院/券商口径，非本机实测），只用于量级感受。
  2. 单价 = 你自己传入，默认 V4 Flash 平峰价（输入 1 / 输出 2 元每百万token），
     价格以各厂商官方最新公告为准。
  3. 本地折算时长 = 我方实测生成速度的纯 decode 上限换算（不含任务调度/多轮推理），
     真实任务只会更慢。

用法示例：
  python3 h22_agent_token_bench.py --task coding --times 100
  python3 h22_agent_token_bench.py --task enterprise --times 1000 --in-price 20 --out-price 100
  python3 h22_agent_token_bench.py --task coding --times -1   # 非法参数，退出码 2
"""
import argparse
import sys

# 任务类型 -> 单次总 token（输入+输出）量级。input/output 按 0.7/0.3 拆分。
# 量级来源：东吴证券等券商口径「单轮对话数百 token；企业级智能体单次复杂任务数十万至数百万 token」。
TASKS = {
    'chat':        {'total': 500,      'label': '单轮对话'},
    'summary':     {'total': 10_000,   'label': '长文档总结'},
    'code_review': {'total': 50_000,   'label': '代码审查 / 补全'},
    'coding':      {'total': 400_000,  'label': '多步编码 Agent'},
    'enterprise':  {'total': 4_000_000, 'label': '企业级复杂任务'},
}


def fmt_num(n):
    if n >= 1e8:
        return '%.1f 亿' % (n / 1e8)
    if n >= 1e4:
        return '%.1f 万' % (n / 1e4)
    return str(int(n))


def fmt_dur(seconds):
    if seconds >= 3600:
        return '%.1f 小时' % (seconds / 3600)
    return '%.1f 分钟' % (seconds / 60)


def run(task_key, times, in_price, out_price, out_ratio, local_tps, quiet=False):
    if task_key not in TASKS:
        sys.stderr.write('未知任务类型: %s，可选 %s\n' % (task_key, '/'.join(sorted(TASKS))))
        sys.exit(2)
    if times < 1:
        sys.stderr.write('次数必须 >= 1，收到 %s\n' % times)
        sys.exit(2)
    if in_price < 0 or out_price < 0:
        sys.stderr.write('单价不能为负\n')
        sys.exit(2)
    if not (0 < out_ratio < 1):
        sys.stderr.write('输出占比必须在 (0,1)，收到 %s\n' % out_ratio)
        sys.exit(2)
    if local_tps <= 0:
        sys.stderr.write('本地生成速度必须 > 0\n')
        sys.exit(2)

    t = TASKS[task_key]
    total = t['total']
    out_tok = int(total * out_ratio)
    in_tok = total - out_tok
    per_cost = (in_tok * in_price + out_tok * out_price) / 1e6
    total_cost = per_cost * times
    chat_equiv = total / TASKS['chat']['total']
    # 本地折算：仅输出 token 的纯 decode 时长上限（我方实测速度）
    local_sec = out_tok / local_tps
    local_total_sec = local_sec * times

    if not quiet:
        print('=' * 58)
        print('任务类型 : %s（单次 %s token）' % (t['label'], fmt_num(total)))
        print('执行次数 : %d 次' % times)
        print('单价     : 输入 %.2f 元 / 输出 %.2f 元（每百万 token）' % (in_price, out_price))
        print('-' * 58)
        print('单次拆解 : 输入 %s token + 输出 %s token' % (fmt_num(in_tok), fmt_num(out_tok)))
        print('单次成本 : %.4f 元' % per_cost)
        print('总成本   : %.2f 元（%d 次）' % (total_cost, times))
        print('量级换算 : 一次任务 ≈ %d 次单轮对话' % round(chat_equiv))
        print('-' * 58)
        print('本地折算 : 输出 %s token，按我方实测 %s tok/s 生成约需 %s（纯 decode 上限，'
              '实际含任务调度只会更慢）' % (fmt_num(out_tok * times), local_tps, fmt_dur(local_total_sec)))
        print('=' * 58)
    return {'task': task_key, 'label': t['label'], 'times': times,
            'total_tok': total, 'in_tok': in_tok, 'out_tok': out_tok,
            'per_cost': per_cost, 'total_cost': total_cost, 'chat_equiv': chat_equiv,
            'local_total_sec': local_total_sec}


def main():
    ap = argparse.ArgumentParser(description='Agent 任务 token 消耗速算')
    ap.add_argument('--task', default='coding', help='任务类型: %s' % '/'.join(sorted(TASKS)))
    ap.add_argument('--times', type=int, default=100, help='任务次数，默认 100')
    ap.add_argument('--in-price', type=float, default=1.0, help='输入单价 元/百万token，默认 1')
    ap.add_argument('--out-price', type=float, default=2.0, help='输出单价 元/百万token，默认 2')
    ap.add_argument('--out-ratio', type=float, default=0.3, help='输出 token 占比，默认 0.3')
    ap.add_argument('--local-tps', type=float, default=84.89, help='本地生成速度 tok/s，默认 84.89（我方单并发实测）')
    ap.add_argument('--demo', action='store_true', help='跑内置两画像对比（正文用）')
    args = ap.parse_args()

    if args.demo:
        print('『画像 A』个人开发者：多步编码 Agent x 100 次，V4 Flash 平峰价')
        run('coding', 100, 1.0, 2.0, 0.3, 84.89)
        print()
        print('『画像 B』企业级任务：Kimi K3 定价 x 1000 次')
        run('enterprise', 1000, 20.0, 100.0, 0.3, 84.89)
        return 0
    run(args.task, args.times, args.in_price, args.out_price, args.out_ratio, args.local_tps)
    return 0


if __name__ == '__main__':
    sys.exit(main())

本机真跑三个用例（第三个是非法参数拦截）：

python3 h22_agent_token_bench.py --task coding --times 100
python3 h22_agent_token_bench.py --task enterprise --times 1000 --in-price 20 --out-price 100
python3 h22_agent_token_bench.py --task coding --times -1   # 次数不能为负，退出码 2

七、真跑：同一把尺子量三张账单

下面是脚本在本机真跑的输出，原文贴入，未修改。

画像 A——个人开发者，100 次多步编码 Agent，按 DeepSeek V4 Flash 平峰价（输入 1 / 输出 2 元每百万 token）：

『画像 A』个人开发者：多步编码 Agent x 100 次，V4 Flash 平峰价
==========================================================
任务类型 : 多步编码 Agent（单次 40.0 万 token）
执行次数 : 100 次
单价     : 输入 1.00 元 / 输出 2.00 元（每百万 token）
----------------------------------------------------------
单次拆解 : 输入 28.0 万 token + 输出 12.0 万 token
单次成本 : 0.5200 元
总成本   : 52.00 元（100 次）
量级换算 : 一次任务 ≈ 800 次单轮对话
----------------------------------------------------------
本地折算 : 输出 1200.0 万 token，按我方实测 84.89 tok/s 生成约需 39.3 小时（纯 decode 上限，实际含任务调度只会更慢）
==========================================================

画像 B——同一个 1000 次企业级任务量，按 Kimi K3 定价（输入 20 / 输出 100 元每百万 token）：

『画像 B』企业级任务：Kimi K3 定价 x 1000 次
==========================================================
任务类型 : 企业级复杂任务（单次 400.0 万 token）
执行次数 : 1000 次
单价     : 输入 20.00 元 / 输出 100.00 元（每百万 token）
----------------------------------------------------------
单次拆解 : 输入 280.0 万 token + 输出 120.0 万 token
单次成本 : 176.0000 元
总成本   : 176000.00 元（1000 次）
量级换算 : 一次任务 ≈ 8000 次单轮对话
----------------------------------------------------------
本地折算 : 输出 12.0 亿 token，按我方实测 84.89 tok/s 生成约需 3926.7 小时（纯 decode 上限，实际含任务调度只会更慢）
==========================================================

画像 C——同一个 1000 次企业级任务量，改按 V4 Flash 平峰价：

==========================================================
任务类型 : 企业级复杂任务（单次 400.0 万 token）
执行次数 : 1000 次
单价     : 输入 1.00 元 / 输出 2.00 元（每百万 token）
----------------------------------------------------------
单次拆解 : 输入 280.0 万 token + 输出 120.0 万 token
单次成本 : 5.2000 元
总成本   : 5200.00 元（1000 次）
量级换算 : 一次任务 ≈ 8000 次单轮对话
----------------------------------------------------------
本地折算 : 输出 12.0 亿 token，按我方实测 84.89 tok/s 生成约需 3926.7 小时（纯 decode 上限，实际含任务调度只会更慢）
==========================================================

对比 A / B / C 能读出三层：

• 任务量从聊天级到 Agent 级，单次成本上升 800 到 8000 倍——单价没变，是任务量在放大账单；
• B 和 C 是同一个任务量，只换单价，月账单从 176000 元变成 5200 元——同任务量下，单价差约 34 倍；
• 本地折算那一行是纯 decode 上限（不含任务调度）。个人开发者的 100 次编码任务，本地按单并发估约 39 小时——它是「生成速度」折出来的上限，实际含任务调度只会更慢，说明本地适合「中等任务量 + 私有化」的需求，不是拿来顶无限量的。

八、2026 年 8 月国产模型定价速查表（平峰口径）

模型 / 套餐	输入（缓存未命中）	输出	备注
DeepSeek V4 Flash	1 元	2 元	高峰时段 ×2；8 月 6 日已预告整体涨价
DeepSeek V4 Pro	3 元	6 元	高峰时段 ×2
Kimi K3	20 元	100 元	比 K2.6 输入约涨 3 倍、输出涨近 4 倍
智谱 GLM-5.2	约 K3 的一半	约 K3 的 1/3	美元报道口径：输入 1.4 / 输出 4.4 美元
豆包	转订阅制	—	6 月底专业版起收费

单位：元 / 每百万 token，平峰价；DeepSeek 高峰时段全部计费项 ×2。以上为 2026-08-08 前后媒体公开报道口径，价格随时可能调整，以各厂官方最新公告为准。表中 GLM-5.2 用「相对 K3 的倍数」是避免按美元汇率自行换算引入误差——报道给出的是美元价，直接用倍数更稳。

九、行动建议：你的用量画像决定该用 API 还是本地

• 用量小、突发、任务类型简单：API 平峰调度（把重活挪到深夜或周末），单价最低时跑，不用上本地。
• 用量中、Agent 化深、任务量大：这是单价最敏感的区间——先把速算工具里的任务量代进去算一遍，再决定。单价上涨（正在发生）只会让本地更划算的临界用量点下降。
• 隐私、断网或合规要求：数据不能出内网，本地是唯一解，这时算的不是省多少钱，是能不能做。
• 用量极大（每天几十亿 token 那种）：本地也顶不住，按需选型，不要硬上。

十、如果你也想本地跑 Agent，又不想自己折腾部署

这一节是判断，不是实测。

前面算下来，本地部署的优势集中在「任务量大 + 单价涨 + 数据要私有」这三个条件的交集。但要提醒一句：完全没必要为了省 API 钱这一层，把自己从开发者变成运维——自己攒机器、装框架、调显存、扛故障，这套工程量对多数团队不值当。

如果你想本地跑 deepseek-v4-flash-0731 这类模型，又不想自己折腾部署，我们的做法是把机器、模型、环境全部装好调通，交付的是开箱即用的状态——拿到手就能直接用本地的模型跑你的 Agent 任务，token 不按个计费，数据不出内网。

（如果你只是想算账，删掉这一节就行，全文结论一字不变。）

小结

这一轮集体涨价，看单家是「厂商策略」，看全行业是「用量把单价抬起来了」——token 用量两年 1000 倍，算力成本迟早传导到 API 价格。而你的账单里，真正的大头往往不是单价，是任务量：一次 Agent 任务等于上千次单轮对话，这个倍数才是账单失控的地方。先看清自己的用量画像，再决定用什么形态跑——这篇的速算工具和定价速查表，就是帮你做这个判断的。