一篇文章说清楚，模型该如何选

一篇文章说清楚，模型该如何选

0. 先把这张表抄下来

飞算JavaAI 的模型选择框，这次被完整截了下来。17 行，5 个厂商，每一行都是「原价划掉 → 实收价」的格式，后面挂一个小小的角标。

把它抄成一张能算账的表：

#	模型	原价	实收	保留率	层级判定
1	DeepSeek-V4-Flash-0731	1.0×	0.2×	20%	轻量
2	DeepSeek-V4-Pro-0813	2.0×	1.2×	60%	旗舰
3	DeepSeek-V4-Pro-0813-低速	1.0×	0.5×	50%	旗舰·低速
4	DeepSeek-V4.1-Flash	1.0×	0.2×	20%	轻量（新）
5	GLM-5.2	2.0×	0.6×	30%	旗舰（旧）
6	GLM-5.3	2.0×	1.6×	80%	旗舰
7	GLM-5.3-Flash	1.0×	0.15×	15%	轻量
8	GLM-5.3-低速	1.5×	0.8×	53.3%	旗舰·低速
9	Kimi-K3	3.0×	1.2×	40%	旗舰（旧）
10	Kimi-K3-低速	1.5×	0.8×	53.3%	旗舰·低速
11	Kimi-K3.1-Pro	2.0×	1.5×	75%	旗舰（新）
12	MiMo-V2.6-Flash	1.0×	0.15×	15%	轻量
13	MiMo-V2.6-Pro	1.0×	0.5×	50%	旗舰
14	MiniMax-M3	1.0×	0.15×	15%	轻量
15	Qwen3.8-Max	1.0×	0.5×	50%	旗舰
16	Qwen3.8-Flash	1.0×	0.15×	15%	轻量
17	Step-5-Preview	1.0×	0.5×	50%	旗舰（预览）

先看三个一眼能看出来的东西。

第一，轻量层的折扣是"批发的"。 四个 0.15×（GLM-5.3-Flash、MiMo-V2.6-Flash、MiniMax-M3、Qwen3.8-Flash），两个 0.2×（两个 DeepSeek Flash），保留率清一色落在 15%–20%。这不是巧合，是标准定价策略——轻量层不靠折扣区分，谁打折都一样深。

第二，旗舰层的折扣是"零售的"。 保留率从 30% 一路铺到 80%：GLM-5.2 是 30%，Kimi-K3 是 40%，Step-5 和 MiMo-Pro 和 Qwen3.8-Max 都是 50%，DeepSeek-Pro 是 60%，Kimi-K3.1-Pro 是 75%，GLM-5.3 是 80%。旗舰层没有统一策略，只有逐个博弈。

第三，也是最容易被忽略的：有三个带「-低速」后缀的模型，它们的原价被单独标过。 DeepSeek 低速版原价 1.0×（标准版是 2.0×，正好一半），GLM 低速版原价 1.5×（标准版 2.0×，75%），Kimi 低速版原价 1.5×（标准版 3.0×，50%）。厂商给低速版单独设了标价，说明在它们的产品体系里，低速不是"降级"，是"另一个 SKU"。

这三个观察，会导出本篇的三个结论。而三个结论里，有两个和直觉相反。

---

1. 先说结论：这张表卖的是两种完全不同的东西

17 个模型看着杂乱，其实只卖两种东西：

第一种是「能力」。 你付钱，模型算得更准、想得更深、能干的活更复杂。买 GLM-5.3 而不是 GLM-5.3-Flash，买的就是能力。

第二种是「配额」。 能力一模一样，权重一个字节都没变，你付钱只是买"不用排队"。带「-低速」后缀的那三行，卖的全是这个。

这两种东西的风险结构完全相反：

	能力折扣	配额折扣
代表	Flash / 轻量 / 旧版本	「-低速」后缀
你付出的	结果质量下降	等待时间变长
代价是否可测	不可测（要跑才知道差多少）	可测（延迟是硬指标）
出错后果	代码错、要人重写	等一会儿
可逆性	不可逆（错的结果已经产出）	完全可逆（就是慢）

于是本篇的第一句话可以写死了：用配额换钱是纯赚，用能力换钱是赌。 而这张表里，只有三行（3、8、10）是纯赚的。

后面十一节，全部在证明这句话，以及证明另外十四行里，最便宜的那一行为什么是最贵的。

---

2. 先修一把尺子：倍率不能直接比

打开这张表的人，第一反应几乎都是"找最小的数字"。看到 0.15× 就觉得便宜，看到 1.6× 就觉得贵。这个反应是错的，而且错得很贵。

原因很简单：倍率是"平台价"，不是"能力价"。 一个模型卖 0.15× 但只能干 30 分的活，和一个模型卖 1.5× 能干 90 分的活，后者的单位能力价格其实只有前者的三分之一。

所以要引进一个中间量：

单位能力价格 = 实收倍率 ÷ 基准得分

这个量回答的问题是：“每买一个百分点的能力，要付多少倍率？” 它不完美（任何单一基准都不完美），但它能把"看起来便宜"和"实际上便宜"分开。

2.1 能用同一把尺子的六行

17 行里，能放在同一条 Terminal-Bench 4.0 上比的，只有六行。这个基准让模型在真实命令行环境里干活，按任务完成情况判分，是目前最接近"AI 编程实际交付"的公开基准之一。

模型	实收倍率	TB 4.0	单位能力价格（倍率/百分点）	相对最便宜
DeepSeek-V4.1-Flash-1017	0.2×	42.3%	0.00473	1.00×
Step-5-Preview	0.5×	33.3%	0.01502	3.18×
Kimi-K3.1-Pro	1.5×	65.7%	0.02283	4.83×
GLM-5.3	1.6×	41.9%	0.03819	8.08×
Kimi-K3	1.2×	13.0%	0.09231	19.5×
GLM-5.2	0.6×	1.0%	0.60000	126.9×

这张表一出来，三个"常识"当场碎掉。

碎掉的第一个：最便宜的 GLM-5.2 是全表最贵的。 它只要 0.6×，看起来是旗舰里的白菜价。但它 TB 4.0 只有 1.0%——这个分数意味着，在终端环境里给它一个真实软件工程任务，它基本上交不出东西。每买一个百分点能力，要付 0.60 倍率，是 DeepSeek-V4.1-Flash 的 127 倍。

碎掉的第二个：1.6× 的 GLM-5.3 比 0.6× 的 GLM-5.2 便宜 15.7 倍。 按倍率看，GLM-5.3 比 GLM-5.2 贵 2.67 倍（1.6÷0.6）。按能力算，GLM-5.3 每点 0.03819、GLM-5.2 每点 0.60000，GLM-5.3 的单位能力价格只有 GLM-5.2 的 1/15.7。同一个基座、同一家公司、同一张表，一行 0.6×、一行 1.6×，贵的那个反而是划算的那个。

碎掉的第三个：0.2× 的 DeepSeek-V4.1-Flash 和 1.6× 的 GLM-5.3 几乎同分。 42.3% vs 41.9%，差 0.4 个百分点。但价格差 8 倍。单位能力，DeepSeek 便宜 8.08 倍。

当然，这里必须马上踩一脚刹车，否则这篇文章就变成了"只看一个基准的数字游戏"——那正是我前七篇一直在骂的事。为什么不能只看这一张表？见第 3 节。

2.2 五条读表纪律（本篇版）

前七篇攒下来的读基准纪律，加上这张全景表暴露出来的新问题，合并成五条：

纪律一：先问这个基准测的是"能力"还是"环境覆盖度"。 Terminal-Bench 4.0 属于后者，证据在第 4 节——同一个基座，纯后训练，分数能涨 42 倍。这种基准排序排的是"谁更早投入后训练环境"，不是"谁更聪明"。

纪律二：版本号是量级单位，不是小数点。 TB 3.0、TB 4.0、TB 2.1 三套题不是同一件事的三种难度，是三种不同的任务分布。GLM-5.2 在 TB 4.0 上 1.0%，在 TB 3.0 上 4.6%——这两个数都"真"，但混着用就全错。

纪律三：自报和独立必须分栏。 Kimi 官方那张 14 项对比表，K3.1-Pro 赢了 Opus 5.5 九项；但那九项里，Kimi Code Bench 3.0 和 Kimi Hallu Bench Hard 都是月之暗面自己出的题。官方还主动注明"Claude 模型可能含 fallback、GPT 模型可能含 cyberguard"——厂商自己都承认不是受控对比。

纪律四：注意"同基座后训练"这个变量。 GLM-5.2 和 GLM-5.3 总参 744B、激活 40B，架构一字未改，全部提升来自后训练。这类模型对"同门比较"极其敏感，但对"跨厂商比较"要格外小心——因为你不知道对方的基座和后训练投入比例。

纪律五（新增）：查一下基准环境有没有泄漏。 本篇有一条硬证据：Vals AI 报告，小米为 MiMo v2.6 发布的编码环境里，三分之二的答案在任务 Git 历史里还能读到，而模型找到了。这不是说 MiMo 差，是说任何"自家环境 + 自家评测"的组合，都要先问一句"答案在哪"。

五条纪律，每一条都能让上面那张漂亮表的一个数字失去意义。但它们合起来，能让你不被任何一个数字骗。

---

3. 最贵的那行：0.6× 的 GLM-5.2

单独拿一节讲 GLM-5.2，因为它值得。它是这张表上最容易被选中的陷阱——理由充分、数字好看、还有人记得它当年很强。

3.1 陷阱是怎么长出来的

GLM-5.2 是 2026 年 6 月 16 日发布的。那一代的主打点是"把 1M 上下文从’有’做成’能用’“，官方叫它"Solid 1M 无损上下文”，专门针对长程 Coding Agent 做了数月强化训练。在当时的宣传里，它能在一次连续长程任务中累计处理超过 85 万 token，接近用满窗口，完成从需求到多端可部署产物的完整链路。Code Arena 上拿过全球可用模型第一，FrontierSWE / SWE-Marathon / PostTrainBench 上整体介于 Claude Opus 4.7 与 4.8 之间。

按 2026 年 6 月的标准，它确实很强。

于是它现在挂 0.6×。它便宜，是因为它旧，不是因为它划算。

3.2 和 GLM-5.3 的差距，全都来自后训练

GLM-5.3 是 8 月 14 日发布的。智谱说得很直白：两者共享同一基座，总参 744B，激活 40B，MoE 架构，上下文行为一致，架构没有变化。所有能力提升都来自后训练阶段的规模化投入——数十倍的长程任务环境、更丰富多样的环境类型、显著延长的强化学习时间。

这是一个非常干净的对照实验：唯一变量是后训练，架构成、参数量、上下文全部锁死。

结果：

基准	GLM-5.2	GLM-5.3	倍数
Terminal-Bench 4.0	1.0%	41.9%	41.9×
DeepSWE v1.1	46.2%	66.9%	1.45×
SWE-Marathon	19.4%	42.5%	2.19×
Agents’ Last Exam (CLI)	23.8%	28.5%	1.20×
AutomationBench	28.4%	62.2%	2.19×
GDPval (Elo)	1371	1651	+280
Humanity’s Last Exam	41.1%	42.3%	+1.2
AA 智能指数	34	45	+11

看第一行和最后一行。

Terminal-Bench 4.0：1.0% → 41.9%。涨了 41.9 倍。
Humanity’s Last Exam：41.1% → 42.3%。涨了 1.2 个百分点。

同一次后训练，同一个基座。在"专家级学科难题"上几乎没动，在"终端环境里干活"上翻了 42 倍。

这个对比说明什么？说明 TB 4.0 这个基准，绝大部分分数不是"智商"贡献的，是"环境覆盖度"贡献的。 GLM-5.2 不是不会写代码——它 HLE 41.1%、DeepSWE 46.2%，代码功底扎实。它是没在"终端里连续操作几十步、每步都要读输出、错了要自己回退"这种环境里练过。

所以当你在选型表里看到 TB 4.0 的分数时，你实际在看的指标是：

这个模型被训练去做"长链路终端任务"的投入有多少。

这对选型意味着一个非常实际的判断：如果你的工作流是"一次性写一个函数"，TB 4.0 分数对你基本没有意义；如果你的工作流是"Agent 自己跑十几轮、每轮改文件、跑测试、看报错、再改"，那 TB 4.0 是最接近的预测指标，而且 1.0% 和 41.9% 之间的差距不是"体验差一点"，是"能不能用"。

3.3 算三笔账，把它钉死

第一笔：倍率账。 GLM-5.2 是 0.6×，GLM-5.3 是 1.6×。你选 5.2，省 62.5%。

第二笔：能力账。 TB 4.0 是 1.0% vs 41.9%。你选 5.2，能力剩 1/41.9，也就是 2.4%。

第三笔：单位能力账。 0.6÷1.0 = 0.60000；1.6÷41.9 = 0.03819。你选 5.2，每点能力贵 15.7 倍。

三笔账放一起，结论是：你用 37.5% 的钱，买了 2.4% 的能力，单位能力成本涨到 15.7 倍。

3.4 还有一个反向的坑：GLM-5.3 也不省 token

到这里很容易得出"那就选 GLM-5.3"的结论。但如果只看到这一步，你还是会踩第二个坑。

Artificial Analysis 的独立测试给出了一个非常关键的补充：GLM-5.3 和 GLM-5.2 的 API 定价相同，但 GLM-5.3 消耗更多 token，导致每项评测任务的平均成本从 1.47 美元涨到 2.01 美元。

拆开看更清楚：

消耗指标	GLM-5.2	GLM-5.3	变化
输入 token 总量（跑完整套评测）	20 亿	54 亿	2.7×
输出 token 总量	1.8 亿	2.1 亿	1.17×
每任务平均成本	$1.47	$2.01	+36.7%

输入涨 2.7 倍、输出只涨 1.17 倍——这说明 GLM-5.3 在长程任务里读得更多（反复读文件、反复看上下文），但说得没多多少。这是"更会干活"的典型特征：干活要多看，不是多说。

所以完整的账应该是：

GLM-5.3 每任务成本是 GLM-5.2 的 1.37 倍，但 TB 4.0 是它的 41.9 倍。便宜到几乎不用算。

反过来说，这也提醒了一件事：看倍率的时候，永远要问"这个模型的 token 消耗是几倍"。 倍率是同 token 的单价，每任务成本 = 单价 × token 数。GLM-5.3 这个故事里，单价没变（都是 1M 统一价，输入 8 元/百万、输出 28 元/百万、缓存 2 元/百万），但每任务成本涨了 37%——光看单价你会得出"两代一样贵"的错误结论。

---

4. 同基座后训练的第二次证明：Kimi K3 → K3.1 Pro

如果 GLM 那组数据是孤例，你可以说"智谱特例"。但它不是。

Kimi K3.1 Pro 于 2026 年 10 月 23 日发布。月之暗面说得很明确：K3.1 Pro 不是从头训练的新底座，而是在 K3 的基础上砸了多得多的后训练算力——RL 框架、长文本推理、沙箱环境、任务调度整条链路重做，让模型能在数百个领域同时做大规模强化学习。

参数锁死：总参 2.8 万亿，激活 1040 亿（约 3.7%），上下文 100 万 token，只支持思考模式（不能关），推理强度分 low / high / max 三档。

结果：

基准	Kimi K3	Kimi K3.1 Pro	倍数
Terminal-Bench 4.0	13%	65.7%	5.05×
Kimi Code Bench 3.0 Long-horizon	55.95%	61.2%	1.09×
Kimi Hallu Bench Hard（幻觉率，越低越好）	23.4%	8.3%	降至 35%
财务建模（内部）	50.4	57.6	+7.2
金融研究（内部）	58.8	70.4	+11.6
模拟企业经营（内部）	8.9	37.0	4.16×
AA 智能指数	—	55（全球第 4 / 215 个模型）	—

TB 4.0 从 13% 到 65.7%，5 倍。 同一个基座，同参数，同上下文。

这和 GLM 那组是同一个故事的两个样本。合起来看：

厂商	旧版 TB 4.0	新版 TB 4.0	倍数	参数是否变化
智谱	GLM-5.2 1.0%	GLM-5.3 41.9%	41.9×	未变（744B/40B）
月之暗面	Kimi K3 13%	K3.1-Pro 65.7%	5.05×	未变（2.8T/104B）

两家独立的厂商，两次纯粹的后训练，在同一个基准上分别涨了 42 倍和 5 倍，参数一个都没动。

这已经不叫"发现"，这叫"规律"。

规律的表述是：

Terminal-Bench 4.0 主要测"后训练环境的覆盖度"，不是"模型智商"。它在 2026 年下半年的所有暴涨，几乎全部来自厂商开始搭真实终端环境跑 RL。

这条规律对选型有三个直接推论，每一个都能立刻用。

推论一：TB 4.0 分数是"保鲜期"指标。 一个模型在 TB 4.0 上分数低，不代表它永远低——它可能只是还没练。反过来，分数高的模型，说明厂商在"Agent 落地"这件事上真投了钱。你要判断的不是"现在谁强"，是"这家厂商会不会在半年内把这块补上"。

推论二：同门升级的收益远大于跨门选择。 GLM-5.3 相对 5.2 涨 42 倍，而跨门挑一个"更贵的模型"最多涨几十分。如果你的主力模型有新一代，先升版，再考虑换门。

推论三：不要用 TB 4.0 给"单点代码能力"排序。 一个模型 TB 4.0 只有 13%，但它 DeepSWE v1.1 可能 75%——这两件事测的不是一个东西。短平快的代码补全看 DeepSWE / SWE-bench，长链路 Agent 看 TB 4.0。

---

5. 唯一无风险套利：「-低速」后缀

现在讲这张表里我最想讲的三行：3、8、10。

模型	标准版实收	低速版实收	低速省下	权重是否相同
DeepSeek-V4-Pro-0813	1.2×	0.5×	58.3%	相同
GLM-5.3	1.6×	0.8×	50.0%	相同
Kimi-K3	1.2×	0.8×	33.3%	相同

三家平均省 47.2%。接近一半的钱。

5.1 为什么这是套利，而不是打折

关键在"权重是否相同"这一列。

Flash 类模型便宜，是因为它是另一个模型——GLM-5.3-Flash 是 320B/18B 激活，GLM-5.3 是 744B/40B。参数不同、训练不同、能力不同。你省钱，代价是换了个更笨的脑子。

「-低速」不是。它是同一个权重，跑在更低的调度优先级上。模型本身的输出和标准版完全一致，区别只在"你的请求在队列里排第几"。

腾讯云混元系列早期公开过这个机制的产品定义，大体一致：低优先级版本 = 相同的模型、相同的精度、相同的能力，但使用更宽松的算力配额，代价是更高的排队延迟和更低的并发上限。 表上那个独立的"原价"（1.0× / 1.5× / 1.5×）就是这个 SKU 的标价，不是标准版的折扣。

所以：

	你付的	你得到的	你失去的
选 Flash	0.15×	320B 的脑子	能力（不可测、不可逆）
选低速	0.8×	744B 的脑子	时间（可测、可逆）

这就是"用配额换钱"和"用能力换钱"的分界线。

5.2 但低速有一个致命的使用边界

不能无条件推荐。低速版的问题不是"质量"，是"延迟分布"。

标准版的尾延迟（P95/P99）可能是 3–8 秒，低速版可能是 30–120 秒，而且方差极大——因为你是排在别人的请求后面，队列长度你控制不了。

这带来一条非常清晰的判据：

场景特征	能否用低速	原因
夜间全量回归、批量补单测	必用	无人等待，延迟完全可吸收
CI/CD 里的自动修复	必用	流水线本来就有几分钟到几十分钟
批量生成文档、注释、API 描述	必用	纯吞吐任务
大批量代码迁移（几百个文件）	必用	总量大、单次可等
单轮对话式补全（Tab 补全、inline chat）	禁用	你在等，延迟直接毁体验
Agent 多轮循环（每轮 5–20 秒 × 10–30 轮）	禁用	延迟会累乘
实时改错、边写边看	禁用	同上

注意倒数第三行——这是最容易犯的错。很多人会觉得"Agent 是自动跑的，我不需要盯着，所以可以用低速"。这是错的。

Agent 的时间是串行累乘的。一个任务 20 轮，标准版每轮 8 秒 → 160 秒。低速版每轮 45 秒 → 900 秒，也就是 15 分钟。而且 Agent 循环通常还有超时设置（很多框架默认 5–10 分钟单任务超时），低速版会直接把你的 Agent 打成超时失败。

但同一件事，放到"夜间批量 500 个文件"上，结论就反过来了：标准版 500 × 8 秒 = 67 分钟，低速版 500 × 45 秒 = 6.25 小时——反正都是夜里跑，6 小时和 1 小时对你没区别，但省了 50% 的钱。

5.3 一个具体的配置方案

在飞算JavaAI 里，这可以直接落成"两条通道"：

通道 A（交互，绝不降级）
  需求分析、设计评审、对话式改代码
  → 标准版 / 高速版，effort=high
  → 延迟预算：单轮 < 15s

通道 B（批处理，全部低速）
  夜间全量回归、批量补单测、批量加注释、
  批量迁移、批量生成文档
  → 「-低速」后缀，effort=medium
  → 延迟预算：单任务 < 30min

按这个切法，如果批处理任务占总 token 的 50%，整体成本直接降 23.6%（47.2% × 50%），而交互体验一个字都不会变。

这是这张表上唯一能做到"什么都不损失"的省钱方式。

---

6. 折扣深度不是性价比信号，是厂商处境信号

这一节讲一个读表的高级技巧：保留率能读出厂商的处境。

先看一组对比：

模型	原价	实收	保留率	客观能力信号
Kimi-K3.1-Pro	2.0×	1.5×	75%	AA 指数 55，全球第 4 / 215
GLM-5.3	2.0×	1.6×	80%	AA 指数 45，TB 4.0 41.9%
DeepSeek-V4-Pro-0813	2.0×	1.2×	60%	未公开 TB 4.0
Kimi-K3	3.0×	1.2×	40%	TB 4.0 仅 13%
GLM-5.2	2.0×	0.6×	30%	TB 4.0 仅 1.0%
MiMo-V2.6-Pro	1.0×	0.5×	50%	SuperCLUE 中文 Agent 编程 第 1（64.65）

发现规律了吗？

折得最浅的两个（75%、80%），正好是当前能力最强的两个。
折得最深的两个（40%、30%），正好是被新一代淘汰的旧旗舰。

这不是巧合，是供需。

• Kimi-K3.1-Pro 只让 25%，因为它 AA 指数 55、全球第 4，不缺客户。它的目标不是抢份额，是把"最贵的一档"卖出去。
• GLM-5.3 只让 20%，因为它刚完成一次 42 倍的后训练跃迁，这是它今年最好的一张牌，没有理由打折。
• GLM-5.2 让 70%，因为它唯一的价值就是"便宜"，除了降价没有第二个卖点。
• Kimi-K3 让 60%，同理。

于是这条规律可以写死了：

保留率 ≈ 厂商对这个模型的定价信心。折得浅 = 它还能卖贵；折得深 = 它只能用价格换。

6.1 但有一条反例，而且反例最值钱

MiMo-V2.6-Pro 只让 50%（1.0× → 0.5×），保留率和 Qwen3.8-Max、Step-5-Preview 一样。但它的能力信号非常强：

SuperCLUE 智能体终端编程中文测评榜（2026 年 10 月 9 日发布，固定用 Claude Code 作为智能体框架，考察中文需求理解、任务规划、工具调用、文件修改、错误排查、最终交付）：

模型	得分	单题成本	每分成本
MiMo-V2.6-Pro	64.65	1.52 元	0.0235 元/分
Hy4-Preview (high)	55.56	11.61 元	0.2090 元/分
MiMo-V2.6-Flash	53.54	0.67 元	0.0125 元/分
DeepSeek-V4.1-Flash (max)	50.51	1.86 元	0.0368 元/分

Kimi、GLM、Hy4 分列 2–4 名，MiMo-V2.6-Flash 第五。

MiMo-V2.6-Pro 拿第一，价格 0.5×，是 Kimi-K3.1-Pro（1.5×）的三分之一。

这就是反例的价值：折得浅不等于强，折得深也不等于弱——折扣只告诉你"厂商怎么想"，不告诉你"模型多能干"。两者都对的时候，才是真便宜。

MiMo-Pro 在中文 Agent 编程这个特定场景下，就是"两者都对"的那一行。

6.2 一个必须打的补丁：MiMo 的基准污染疑云

但同一条证据链里，还有一个必须说的东西。

Vals AI 报告：小米为 MiMo v2.6 发布的编码环境里，三分之二的答案在任务的 Git 历史里还能读到，而模型找到了。

这句话的含义不是"MiMo 作弊"。厂商搭评测环境时把参考答案留在了仓库历史里，是很常见的工程疏漏。但它的后果很实在：任何基于"自家环境"的分数，都要先问"答案在哪"。

同一份来源里还有一个交叉验证：在 Forge 2.0 这个没有参考实现、没有网络可查的独立任务上（一个真实 app 的升级），DeepSeek V4.1 Flash 中位得分 0.334，MiMo V2.6 Flash 0.528——MiMo 仍然领先，说明它的能力是真的，只是在"能看 Git 历史"的环境里可能被高估了。

这就是"读分五纪律"为什么必须存在。 一条漂亮的分数，可能来自一个泄漏的环境；一条难看的分数，可能来自一个没练过的环境。两个方向都会骗你。

---

7. 第三条反直觉：单价 1/8，每成品成本一样

前面三节都在讲"单位能力"。这一节讲一个更狠的：单价便宜 8 倍，每完成一个交付物的成本却一样。

这是第三方实测数据，账单精确到分。

模型	列表价（输入/输出，每百万 token）	完成 cost（build 1）	模型请求数	耗时
Claude Opus 5.5	$4.00 / $20.00	$20.71	—	134 分钟
Claude Sonnet 5.5	$2.00 / $10.00	$6.26	—	74 分钟
GPT-6.1 Sol	$2.00 / $10.00	$1.15	47	20 分钟
DeepSeek V4.1 Flash	$0.30 / $1.20	$1.63	261	99 分钟
GPT-6 Luna	$0.10 / $0.50	$0.88	42	42 分钟
MiMo V2.6 Flash	$0.14 / $0.28	$0.31	31	31 分钟
Qwen3.8 Omni Flash	$0.15 / $0.47	$1.52	91	91 分钟

看 GPT-6.1 Sol 和 DeepSeek V4.1 Flash 这两行。

• 输出单价：Sol 是 $10.00，DeepSeek 是 $1.20。DeepSeek 便宜 8.33 倍。
• 每成品成本：Sol 是 $1.15，DeepSeek 是 $1.63。DeepSeek 贵 1.42 倍。

单价便宜 8 倍，每成品反而贵 1.4 倍。为什么？

请求数：Sol 用了 47 次，DeepSeek 用了 261 次。差 5.55 倍。

原因是 Agent 每发一次请求，都要把整个对话重新发一遍。DeepSeek 试错 261 次，build 1 一共推了 1.01 亿 prompt token 进 API。96.3% 是缓存读取，把成本压到了每百万 1–2 美分——如果没有缓存，这个账单会是几十美元，而不是 1.63 美元。

这条数据导出的判断，是整篇文章里最实用的一条：

看倍率只能算出"单价"，算不出"账单"。账单 = 单价 × token 数 × 请求数。而后两个因子，由模型"一次能不能做对"决定。

换成一个更直白的说法：一个便宜但啰嗦的模型，比一个贵但一次做对的模型，更容易让你破产。

这也是第 3 节 GLM-5.3 那个"token 涨 2.7 倍"的同一件事——只不过这次是 5.55 倍。

7.1 三档模型的三条账单路径

把上面的东西合成三个可执行的配置，用同一套任务（一个 3 万行的中型 Java 项目，一个月）：

路径 A：全旗舰

• 主模型：Kimi-K3.1-Pro（1.5×）或 GLM-5.3（1.6×）
• 月成本：100（基准）
• 交付质量：最高，TB 4.0 41.9%–65.7%
• 适合：核心交付期、要出客户可验收产物

路径 B：全轻量

• 主模型：GLM-5.3-Flash（0.15×）或 MiMo-V2.6-Flash（0.15×）
• 月成本：约 9–10（因为 Flash 通常 token 消耗更低，实际可能是 8）
• 交付质量：中等，适合改动密集的小任务
• 适合：日常迭代、补测试、改样式、加日志

路径 C：分层 + 低速（本篇推荐）

• 分析层：Kimi-K3.1-Pro（1.5×），只用于需求分析和设计评审，占总 token 5%
• 实现层：DeepSeek-V4.1-Flash（0.2×）或 MiMo-V2.6-Pro（0.5×），占 45%
• 批处理层：低速版（0.5×–0.8×），占 50%
• 月成本：约 40–45
• 交付质量：接近路径 A（分析层用了最好的）
• 适合：稳定产出的团队

路径 C 比路径 A 省 55%–60%，而关键产出（需求理解、架构决策）用的是同一档模型。

这个账能成立，只有一个前提：你得愿意把"排队"和"能力"分开定价。 这正是第 5 节做的事。

---

8. 五个厂商，各自擅长什么（能力剖面）

17 行摊开，五个厂商（DeepSeek / 智谱 / 月之暗面 / 小米 / 阿里 + MiniMax + 阶跃）各自的位置其实很清楚。前七篇已经单篇写透了 MiniMax-M3、Qwen3.8、Step-5-Preview，这里只补本篇新增的五个。

8.1 DeepSeek：终端与代码工程的"暴力解"

指标	DeepSeek-V4.1-Flash-1017
列表价	$0.30 / $1.20（每百万 token）
上下文	1,048,576
LLM Stats 综合	51.2（#15）
Coding 分项	39.3（#14）
Agents 分项	38.7（#8）
CodeForces	100.0%
GPQA	90.9%
Terminal-Bench 2.1	90.6%
CyberGym	88.1%
TB 4.0	42.3%
DeepSWE v1.1	77.0%
Kimi Hallu Bench Hard（幻觉率）	23.3%（差）

强项：算法题（CodeForces 满分）、终端单步（TB 2.1 90.6%）、长程软件工程（DeepSWE 77.0%，比 Kimi K3.1-Pro 的 75.5% 还高）、Agents 分项全表 #8。
弱项：幻觉。Kimi Hallu Bench Hard 上 23.3%，比 Kimi 的 8.3% 差近 3 倍。以及"一次做对"能力弱（261 次请求 vs Sol 47 次）。

结论：用它写"有测试可验证"的代码，别用它做"没有标准答案"的技术决策。

8.2 智谱 GLM：后训练跃迁最猛

指标	GLM-5.3	GLM-5.3-Flash
参数	744B / 40B 激活	320B / 18B 激活
上下文 / 输出	1M / 128K	1M
思考模式	always on（low/high/max）	always on
价格（Z.ai）	$1.40 / $4.40	约 1/10
缓存输入	$0.26	—
TB 4.0	41.9%	—
Z.ai Code Bench v1.0	34.5%（max effort）	29.0%
安全能力	白盒审查累计发现 2436 个漏洞，其中 1097 个中高危	—

强项：后训练投入（TB 42×）、安全审计（这是全表独一份的能力，和多个安全团队合作实测）、Coding Plan 生态（和主流编程工具深度集成）。
弱项：token 消耗大（输入 2.7×）、原生多模态只有 Flash 有。

结论：如果任务里有"找漏洞"这一项，GLM-5.3 是这张表上唯一有公开实证的。纯写代码，它的单位能力价格（0.03819）不如 DeepSeek Flash（0.00473）。

8.3 月之暗面 Kimi：长程 agent + 最低幻觉

指标	Kimi-K3.1-Pro
参数	2.8T / 104B 激活（3.7%）
上下文 / 最大输出	1M / 131K 默认，最高 1M
模态	文本 + 图像 + 视频
思考模式	always on（low/high/max，默认 max）
价格	$2.00 / $10.00，缓存 $0.20
高速版	2–3× 速度，2× 价格
AA 智能指数	55（全球 #4）
TB 4.0	65.7%
SWE-Marathon v1.1	51.7%
DeepSWE v1.1	75.5%
GDPval-AA Elo	1846
幻觉率（Hallu Bench Hard）	8.3%（全表最好）
Terminal-Bench Science	38.1%（差，Opus 5.5 是 63.3%）

强项：长程 agent（SWE-Marathon 51.7%，比 Opus 5.5 的 46.3% 高）、幻觉率 8.3% 全表最低、视频输入、四个原生模态。
弱项：最贵（1.5×，是 MiMo-Pro 的 3 倍）、科学推理弱（TB-Science 38.1% vs 63.3%）、只能开思考模式（关不掉，每次回答都烧思考 token）。

结论：用它做"没人看着、自己跑几十轮、最后要给结论"的任务。它的低幻觉 + 长程是组合优势——Agent 跑 20 轮，每轮 5% 的幻觉率会累积成 64% 的出错概率；Kimi 的 8.3% 累积 20 轮是 82%……等等，这个算法不对，幻觉不是独立事件，每轮会自我纠正。但方向是对的：长任务里，幻觉率是第一杀手。

8.4 小米 MiMo：中文 Agent 编程的黑马

指标	MiMo-V2.6-Pro	MiMo-V2.6-Flash
价格	$按 0.5× 档	$0.14 / $0.28
上下文	1M	1M
SuperCLUE 中文 Agent 编程	64.65（第 1）	53.54（第 5）
单题成本	1.52 元	0.67 元（全场最低）
CyberGym（Flash）	—	95.1%
TB 2.1（Flash）	—	87.6%
OSWorld-Verified（Flash）	—	80.8%
Toolathlon-Verified（Flash）	—	73.6%

强项：中文需求理解（这是国内团队最容易低估的一项——SuperCLUE 明确说"不少海外大模型对中文指令理解偏弱"）、CyberGym 95.1%（比 DeepSeek 的 88.1% 还高）、单题成本全表最低。
弱项：基准污染疑云（2/3 环境答案可在 Git 历史找到）、国际评测覆盖少。

结论：中文技术栈 + 中文需求文档的团队，这是性价比最优的一行。但任何分数都要打折看，最好自己跑 30 题。

8.5 一张横向对照表

厂商	代表行	倍率	单位能力价格	最突出的一项	最该避开的一项
DeepSeek	V4.1-Flash	0.2×	0.00473	单位能力全表最低；CodeForces 100%	幻觉 23.3%
小米	MiMo-V2.6-Pro	0.5×	—	中文 Agent 编程第一	基准污染疑云
阶跃	Step-5-Preview	0.5×	0.01502	续航（1M 输出、CyberGym 84.7%）	Preview 有保质期
月之暗面	Kimi-K3.1-Pro	1.5×	0.02283	幻觉 8.3%；SWE-Marathon 51.7%	价格是 MiMo 的 3 倍
智谱	GLM-5.3	1.6×	0.03819	后训练跃迁 42×；漏洞发现 2436 个	token 消耗 2.7×
智谱	GLM-5.2	0.6×	0.60000	便宜	TB 4.0 只有 1.0%

---

9. 飞算JavaAI 落地：17 个模型 × 6 个阶段的配置矩阵

到这里所有分析都齐了，现在把它变成一张能直接用的表。

飞算JavaAI 的智能会话走四个阶段：需求分析 → 前后端设计 → 前端开发 → 后端开发。加上工程实践里必须有的两个阶段（代码审查、写单测），一共六个。

9.1 配置矩阵

阶段	主选	备选	effort	为什么是这个
需求分析	Kimi-K3.1-Pro 1.5×	GLM-5.3 1.6×	high	上游错误成本指数级。这一阶段读的是模糊的中文需求，幻觉是第一杀手，Kimi 的 8.3% 是全表最低
前后端设计	GLM-5.3 1.6×	DeepSeek-V4-Pro-0813 1.2×	high	结构化输出为主，需要长期一致性。GLM 的 1M 上下文 + 128K 输出能把整个设计文档放进同一条链路
前端开发	Qwen3.8-Flash 0.15×	GLM-5.3-Flash 0.15×	medium	组件化、可即时预览、错了改得快。前端错误成本最低，用最便宜的就够
后端开发	DeepSeek-V4.1-Flash 0.2×	MiMo-V2.6-Pro 0.5×	medium	有单测可验证，幻觉风险被测试兜住。CodeForces 100% + TB 2.1 90.6% 适合写"逻辑明确"的代码
代码审查	Kimi-K3.1-Pro 1.5×	GLM-5.3 1.6×	high	审查需要"独立视角 + 低幻觉"，这两项 Kimi 都是第一
写单测	MiniMax-M3 0.15×	MiMo-V2.6-Flash 0.15×	low	量大、模板化、对错有客观标准（编译 + 覆盖）
夜间批量回归 / 批量迁移	任一「-低速」	—	medium	延迟可吸收，省 33%–58%

这张表的关键不在"选了谁"，在**“为什么每个阶段选的不一样”**。

三个判断原则：

原则一：越靠上游，越要买贵的。 需求分析错一句话，后面四个阶段全白干。这一阶段的 token 占比通常不到 5%，但决定了 95% 的返工量。在最贵的地方省 5%，是在最便宜的地方浪费 95%。

原则二：越靠下游、越有客观验证，越可以买便宜的。 后端代码有单测、前端有预览、单测有覆盖率——这些环节的"对错"有自动裁判，模型的幻觉会被立刻打回。有裁判的地方，可以放心用便宜模型。

原则三：无人在场的任务，优先考虑低速。 夜间跑的东西，慢 5 倍没人知道，但省一半钱所有人都知道。

9.2 在飞算JavaAI 里怎么操作

飞算JavaAI 的模型下拉框就是截图里这 17 行。切换模型的粒度可以细到"当前这次会话"，所以实际操作是按任务类型开不同会话，而不是在一个会话里反复切：

1. 需求分析会话：模型选 Kimi-K3.1-Pro，把 PRD、会议纪要、竞品截图全丢进去，让它输出需求清单 + 歧义点清单 + 验收标准。
2. 设计会话：模型选 GLM-5.3，输入第 1 步的需求清单，输出表结构、接口定义、模块划分。
3. 实现会话：模型切到 DeepSeek-V4.1-Flash，输入设计文档的单个模块切片（不是全量），逐模块实现。每个模块必须有对应单测。
4. 审查会话：模型切回 Kimi-K3.1-Pro，输入 diff，让它做"只看这个 diff 的独立审查"——不要给它前面实现过程的上下文，否则它会为自己的选择辩护。
5. 批量补齐会话：模型切到任一 -低速，晚上跑，批量补注释、补测试、补文档。

这个流程有一个隐藏收益：每个阶段换了模型，等于换了一双眼睛。 同一个模型自己设计、自己实现、自己审查，会系统性地看不见自己的盲区——这不是模型的问题，是任何单一视角的问题。

---

9.3 12 个典型任务 × 推荐模型（速查表）

矩阵是原则，这张表是日常翻的那一页。12 个最常见的 AI 编程任务，直接给答案。

#	任务	推荐模型	备选	effort	有无裁判	关键理由
1	读 PRD 输出需求清单 + 歧义点	Kimi-K3.1-Pro 1.5×	GLM-5.3 1.6×	high	无	幻觉 8.3% 全表最低；上游错一句话后面全白干
2	技术方案选型（要权衡取舍）	Kimi-K3.1-Pro 1.5×	GLM-5.3 1.6×	high	无	无标准答案的任务只能用最好的
3	表结构设计 / 接口定义	GLM-5.3 1.6×	DeepSeek-V4-Pro-0813 1.2×	high	半	1M 上下文 + 128K 输出，能把整个 schema 放一条链
4	单文件函数实现	DeepSeek-V4.1-Flash 0.2×	MiMo-V2.6-Pro 0.5×	medium	有	CodeForces 100%，逻辑明确的代码是它的主场
5	跨 3+ 文件重构	Kimi-K3.1-Pro 1.5×	GLM-5.3 1.6×	high	有（编译）	TB 4.0 65.7% 直接测这个能力，别省
6	补单测（追覆盖率）	MiniMax-M3 0.15×	MiMo-V2.6-Flash 0.15×	low	有（覆盖）	有裁判 + 量大，用最便宜的
7	修编译错误 / 修测试失败	DeepSeek-V4.1-Flash 0.2×	Qwen3.8-Max 0.5×	medium	有	错误信息明确，任务边界清楚
8	代码审查（只看 diff）	Kimi-K3.1-Pro 1.5×	GLM-5.3 1.6×	high	半	要独立视角 + 低幻觉；必须给"不带实现上下文"的干净 diff
9	安全漏洞扫描	GLM-5.3 1.6×	Kimi-K3.1-Pro 1.5×	high	半	全表唯一有公开实证的（2436 个漏洞 / 1097 中高危）
10	设计稿截图转页面	Kimi-K3.1-Pro 1.5×	GLM-5.3-Flash 0.15×	medium	有（预览）	必须原生多模态；Kimi 支持图+视频，GLM-Flash 便宜 10 倍
11	夜间全量回归 + 自动修复	任一「-低速」	—	medium	有	延迟可吸收，省 33%–58%
12	批量加注释 / 补文档 / 批量迁移	任一「-低速」	MiniMax-M3 0.15×	low	半	纯吞吐任务，慢没人知道

读这张表的方法：先看"有无裁判"那一列。 有裁判的（4、6、7、11、12）全部可以买便宜；无裁判的（1、2）必须买最贵；半裁判的（3、5、8、9、10）看任务链长度——链路越长越要买贵。

三条容易买错的：

• 第 5 项（跨文件重构）是最容易省错钱的地方。 它看起来"只是改代码"，实际是 TB 4.0 测的那个能力。用 0.2× 的模型做，最可能的结果是改到一半编译不过，你花两小时收拾。
• 第 8 项（代码审查）最容易被"顺手"做错。 很多人会让实现它的那个模型自己审查——它会为自己的选择辩护。换模型 + 只给 diff，才是真审查。
• 第 10 项最容易被"便宜"骗。 这张表上明确支持图像输入的只有 Kimi K3.1 Pro（图+视频）、GLM-5.3-Flash（原生图+视频）、Step-5-Preview（图）。其它模型你喂截图，它只是在猜。

10. 三段 prompt：让便宜模型也能交差

模型选对只是开始。同一张表里，同一个模型，prompt 差一句，产出能差一个档次。这三个模板是按"这张表暴露的具体毛病"写的。

10.1 给分析型模型（Kimi / GLM，治"过度自信"）

这两个模型能力强，毛病是"答得太顺"，会把不确定的东西说得像确定的。

# 角色
你是需求分析工程师。你的产出会被直接用于拆解开发任务。

# 硬约束
1. 输出必须分为三段：【确定】【推测】【未知】
2. 【推测】段的每一条，必须标注：如果这条错了，会导致哪个模块返工
3. 【未知】段不允许留空。如果你认为没有未知项，说明你没读够，回去重读
4. 任何数字（性能指标、并发量、数据量）如果需求里没写，一律进【未知】，
   禁止自行假设一个"合理值"
5. 禁止使用"一般来说""通常情况下""建议考虑"这类模糊表述

# 输出格式
## 【确定】
- <需求原文摘录> → <技术含义>
## 【推测】
- <推测内容> | 置信度: 高/中/低 | 若错误影响: <模块名>
## 【未知】
- <缺失信息> | 需要谁确认 | 阻塞哪些任务

关键在第 4 条和第 5 条。第 4 条挡住幻觉（DeepSeek 幻觉 23.3% 的根源就是"自行补全合理值"），第 5 条挡住废话。

10.2 给实现型模型（DeepSeek Flash / MiMo，治"试错太多"）

第 7 节那个"261 次请求 vs 47 次请求"的教训，本质是模型在盲试。这个模板的目的是把它变成"先想清楚再动手"。

# 任务
实现以下模块。你有且仅有一次机会提交完整实现。

# 动手前必须先输出（不许省略）
1. 这个模块的输入 / 输出 / 副作用，各列一遍
2. 边界条件清单（空值、超长、并发、幂等、失败重试），至少 8 条
3. 你打算怎么验证？写出具体的测试用例名 + 预期断言
4. 你可能写错的地方：列 3 个最可能出错的位置及原因

# 实现约束
- 只允许修改指定的文件，其它文件一律不动
- 每个 public 方法必须有对应的单测，测试文件放在 src/test/java 同包路径
- 不允许引入新的第三方依赖
- 不允许 catch 后吞掉异常；必须记录或以受检异常抛出
- 遇到不确定的业务规则，写 `// TODO(需确认): <具体问题>`，禁止自行假设

# 提交前自检
- [ ] 全部单测通过
- [ ] 无新增 TODO 之外的硬编码值
- [ ] 边界条件清单里每一条都有对应测试

“动手前必须先输出"这一段是核心。它把模型的思考成本从"多轮试错"挪到"单轮想清楚”——对按 token 计费的场景，这一步几乎总是省钱的，因为想清楚只要几百 token，试错要几百万。

10.3 给批处理模型（低速版，治"上下文丢失"）

低速版会跑很久，长任务里约束容易"漂移"。这个模板强制它每轮回写状态。

# 任务
批量处理 <N> 个文件，逐个执行 <具体操作>。

# 每完成一个文件，必须回写五行摘要
1. 已完成：<文件名> — <做了什么>
2. 未完成：<剩余文件数>
3. 关键假设：<本次做了什么假设>
4. 风险：<发现的可能问题>
5. 下一步：<下一个文件是什么>

# 约束重述（每 10 个文件重读一次，不要依赖记忆）
- <约束 1>
- <约束 2>
- <约束 3>

# 失败处理
单个文件失败不要终止整批。记录失败原因，继续下一个。
全部完成后统一输出失败清单：文件名 | 失败原因 | 建议处理方式

“每 10 个文件重读一次约束"这一句，专门对付长任务里最常见的失效模式：跑到第 200 个文件时，模型已经忘了第 1 条约束。 它不是忘了，是那个约束已经滑出上下文窗口了。强制重读，等于给约束"续命”。

---

11. 四个真实场景：怎么按场景切模型

前面讲的是阶段。但实际工作里，任务往往跨阶段。这四个场景是按"任务形态"切的分法，可以直接套。

11.1 场景：跨 8 个文件的接口重构

任务特征：改动面广、依赖关系复杂、必须一次改完否则编译不过。

模型选择：Kimi-K3.1-Pro（1.5×）或 GLM-5.3（1.6×）。不要省钱。

理由：这是典型的"长链路、无中间验证点"任务。改到第 5 个文件时发现第 2 个文件的假设错了，必须回退——这种能力在两个模型的 TB 4.0 分数（65.7% / 41.9%）里被直接测量。用 0.2× 的模型做这件事，最可能的结果是改到一半编译不过、然后你花两小时人工收拾。

成本对比：假设这个任务标准版花 20 万 token（$3），Flash 花 40 万 token（$0.6）但失败要重来 3 次 + 人工 2 小时。人工按 200 元/小时算，Flash 方案的总成本是 400 元 + 3.6 元，旗舰方案是 21 元。

11.2 场景：给 120 个已有类补单测

任务特征：高度模板化、有客观验收（编译 + 覆盖率）、量大。

模型选择：MiniMax-M3（0.15×）或 MiMo-V2.6-Flash（0.15×）。

理由：这是"有裁判"任务的教科书案例。单测写错了，mvn test 立刻告诉你。模型的幻觉在这个环节没有生存空间。而且量大——120 个类，用 1.5× 的模型做这件事纯属浪费。

降本技巧：把这批任务挪到夜间，切到 -低速。0.15× 再省 50% → 实际成本约 0.075×。

11.3 场景：夜间全量回归 + 自动修复

任务特征：无人等待、失败可重跑、耗时无上限。

模型选择：必须是「-低速」。DeepSeek-V4-Pro-0813-低速（0.5×）或 GLM-5.3-低速（0.8×）。

理由：这是本篇的核心论点最好的落地场景。整个团队下班了，跑 6 小时和跑 1 小时没有任何区别，但省 50%。

注意：不要把低速版放进"开发者在等"的链路。比如"提交代码后自动跑回归并给建议"这种场景，如果开发者还在看着屏幕等结果，低速版会让他等 15 分钟——这时候省下的钱不值一提。

11.4 场景：把设计稿截图转成页面

任务特征：多模态输入、输出是前端代码、有即时视觉验证。

模型选择：Kimi-K3.1-Pro（原生图像 + 视频输入）或 GLM-5.3-Flash（原生多模态 + 线性注意力，成本约旗舰的 1/10）。

理由：这张表上，明确支持图像输入的有 Kimi K3.1 Pro、GLM-5.3-Flash（原生图像和视频）、Step-5-Preview（文本 + 图像）。其它模型多数是纯文本——你不能指望一个纯文本模型看懂你的 Figma 截图。

这条最容易踩坑：很多人会拿最便宜的那个 0.15× 模型去截图转页面，然后发现它根本不支持图片，或者把中文标注全认错了。多模态能力不是"便宜就能有"的，得先确认它在不在。

---

12. 选型 SOP：五步、30 题、一个脚本

前面十一节是分析。这一节把它压缩成一个能重复执行的流程。

12.1 五步

第一步：按"有没有裁判"给任务分类。

• 有裁判（编译/测试/覆盖率/预览）→ 可以买便宜
• 无裁判（需求分析、架构决策、技术方案）→ 必须买贵

第二步：按"有没有人在等"给任务分类。

• 没人等（夜间/批处理/CI）→ 优先低速
• 有人在等（对话/补全/实时改）→ 标准版，且延迟预算写死

第三步：查同门有没有新一代。
先看这张表里有没有你的主模型的升级版（GLM-5.2→5.3、Kimi-K3→K3.1-Pro、DeepSeek-V4→V4.1）。同门升级的收益（42×、5×）通常远大于跨门挑选。

第四步：算单位能力价格，不算倍率。
用你能找到的最接近的基准，算 倍率 ÷ 得分。这一步专门用来抓"看起来很便宜"的陷阱（GLM-5.2 的 0.60000）。

第五步：跑 30 题自己的 eval。

12.2 30 题的设计

别抄公开基准。公开基准已经被训练过了。30 题要满足：

维度	题数	要求
从你自己的 git 历史里捞真实 bug 修复	8	必须有原始 PR 和最终合并版本
从你自己的 code review 意见里捞"该改没改"	6	有明确的"应该怎么改"
跨文件重构（3 个文件以上）	5	有客观验收：编译通过 + 测试通过
补单测（给一个类，要 80% 覆盖）	5	有客观验收：覆盖率数字
中文需求理解（模糊 PRD → 可执行任务）	4	人工评分，看歧义识别
长链路 Agent（10 轮以上自己跑完）	2	只看"能不能跑完"

评分只看三件事：能不能编译、测试过不过、人工改几行。不看"代码写得好不好看"——那是最后一个维度，前三个不过关时谈美观没有意义。

12.3 一个可以直接用的脚本

#!/usr/bin/env python3
# eval_roster.py —— 17 行模型表的横向评测框架
# 用法: python eval_roster.py --models config.yaml --tasks tasks.jsonl
import json, time, statistics, argparse
from pathlib import Path

TASKS = [
    # (id, 类型, 提示词, 验收函数名)
    ("bug-01",  "bugfix",   "修复 OrderService.java 第 142 行的空指针...", "compile_and_test"),
    ("refac-01", "refactor", "把 PaymentGateway 的三处重复校验合并...", "compile_and_test"),
    ("test-01",  "unittest", "为 CouponCalculator 补单测，覆盖率达到 80%", "coverage"),
    ("req-01",   "analyze",  "这份 PRD 里有几处歧义？逐条列出", "human"),
]

def run_one(client, model, task, effort="medium"):
    """单题单模型执行。返回结构化结果，不做任何"美化"。"""
    t0 = time.time()
    resp = client.chat(
        model=model,
        reasoning_effort=effort,
        messages=[{"role": "user", "content": task[2]}],
        max_tokens=16384,
    )
    wall = time.time() - t0
    return {
        "task": task[0],
        "type": task[1],
        "ok": None,                      # 由验收器填
        "wall_sec": round(wall, 1),
        "in_tok": resp.usage.prompt_tokens,
        "out_tok": resp.usage.completion_tokens,
        "req_cnt": getattr(resp, "request_count", 1),
        "diff_lines": None,              # 人工改动行数，事后填
    }

def score(rows):
    """三个硬指标 + 一个软指标。不做加权总分——加权会掩盖短板。"""
    by_model = {}
    for r in rows:
        by_model.setdefault(r["model"], []).append(r)

    table = []
    for m, rs in by_model.items():
        passed = sum(1 for r in rs if r["ok"])
        table.append({
            "model": m,
            "pass_rate": round(passed / len(rs) * 100, 1),
            "avg_wall": round(statistics.mean(r["wall_sec"] for r in rs), 1),
            "p95_wall": round(sorted(r["wall_sec"] for r in rs)[int(len(rs) * 0.95)], 1),
            "avg_req": round(statistics.mean(r["req_cnt"] for r in rs), 1),
            "out_tok_per_task": int(statistics.mean(r["out_tok"] for r in rs)),
        })
    return table

def unit_cost(table, ratio_map):
    """单位能力价格 = 实收倍率 / 通过率。本篇 §2 的核心指标。"""
    out = []
    for row in table:
        ratio = ratio_map.get(row["model"])
        if ratio and row["pass_rate"] > 0:
            out.append({**row, "ratio": ratio,
                        "unit_cost": round(ratio / row["pass_rate"], 5)})
    return sorted(out, key=lambda x: x["unit_cost"])

if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--models", required=True, help="模型→倍率映射 yaml")
    ap.add_argument("--tasks", required=True, help="任务 jsonl")
    args = ap.parse_args()

    import yaml
    ratio_map = yaml.safe_load(Path(args.models).read_text(encoding="utf-8"))
    tasks = [tuple(json.loads(l).values()) for l in Path(args.tasks).read_text(encoding="utf-8").splitlines() if l.strip()]

    client = None  # 换成你实际用的 SDK 客户端
    rows = []
    for model in ratio_map:
        for task in tasks:
            r = run_one(client, model, task)
            r["model"] = model
            r["ok"] = run_validator(task[3], r)   # compile_and_test / coverage / human
            rows.append(r)

    table = score(rows)
    print("\n=== 通过率 / 延迟 / 请求数 ===")
    for row in table:
        print(f'{row["model"]:28s} pass={row["pass_rate"]:>5}%  '
              f'p95={row["p95_wall"]:>6}s  req={row["avg_req"]:>5}')

    print("\n=== 单位能力价格（倍率/通过率，越低越好）===")
    for row in unit_cost(table, ratio_map):
        print(f'{row["model"]:28s} {row["ratio"]:>4}x  -> {row["unit_cost"]:.5f}')

这个脚本最重要的设计决策是：不做加权总分。 加权会把"高通过率 + 高延迟"和"低通过率 + 低延迟"算成一样的分。选型要的是"短板在哪"，不是"综合几分"。所以只输出四个独立指标，让短板自己暴露。

---

13. 六个误区

误区一：倍率越低越划算。

反例就在这张表第一行以下是 GLM-5.2——0.6×，全表旗舰里最便宜，但单位能力价格 0.60000，是 DeepSeek-V4.1-Flash 的 127 倍。便宜的前提是"能干活"。

误区二：同一家的新一代一定更贵，所以更不划算。

GLM-5.3（1.6×）比 GLM-5.2（0.6×）贵 2.67 倍，但 TB 4.0 是 41.9 倍。而且 GLM-5.3 每任务成本只涨 37%，不是 2.67 倍——因为你要完成一个任务，5.2 需要的轮次远多于 5.3。贵的是单价，便宜的是账单。

误区三：低速版质量差。

低速版是同一个权重，输出和标准版一致。它差的只有延迟和并发上限。把"慢"和"笨"混为一谈，会让你白白多付 33%–58% 的钱。但反过来，把低速版放进交互链路，会让你等 15 分钟——这两件事必须分清。

误区四：折得深说明性价比高。

折扣深度是厂商处境信号。Kimi-K3.1-Pro 只让 25%，因为它 AA 指数 55 排全球第 4；GLM-5.2 让 70%，因为它除了便宜没别的卖点。折得浅可能是真好，折得深可能是真差。

误区五：拿 TB 2.1 的分数和 TB 4.0 比。

DeepSeek-V4.1-Flash 的 TB 2.1 是 90.6%，TB 4.0 是 42.3%。这两个数不是同一个基准的两种难度，是两套完全不同的任务。拿来横比会得出荒谬结论。同理：GLM-5.2 在 TB 3.0 上是 4.6%，在 TB 4.0 上是 1.0%——都是真的，不能混用。

误区六：忽略基准环境泄漏。

Vals AI 那条证据很硬：小米为 MiMo v2.6 发布的编码环境里，2/3 的答案能在 Git 历史里读到。这不是说 MiMo 不行（在无参考实现的 Forge 2.0 上它仍然领先），是说任何"自家环境 + 自家评测"的分数，都要先查环境。 你自己搭 eval 的时候也要注意：别把答案留在 git 历史里。

---

14. 结论：三句话

第一句：这张表卖两种东西，「能力」和「配额」，17 行里只有三行（3、8、10）卖的是配额。

用配额换钱是纯赚——能力一个字节没变，只多了排队时间，而排队时间可以被"夜间批处理"这个场景完全吸收。用能力换钱是赌——你没法在付钱前知道损失了多少，只能事后重写。先分清这两种，再谈性价比。

第二句：最便宜的那行最贵，因为便宜的是旧权重，不是性价比。

GLM-5.2 的 0.6× 比 GLM-5.3 的 1.6× 便宜 2.67 倍，单位能力却贵 15.7 倍。同一基座、同一厂商、同一张表，贵的那个反而是划算的那个。这条规律可以推广：当你看到"某个旗舰突然大幅降价"，先问它是不是被新一代取代了；如果答案是，那个价格不是折扣，是清仓。

第三句：单价只能算出一半的账，另一半在"一次能不能做对"。

DeepSeek V4.1 Flash 的输出价是 GPT-6.1 Sol 的 1/8.33，但每完成一个 app 的成本是它的 1.42 倍——因为前者用了 261 次请求，后者用了 47 次。倍率决定单价，通过率决定账单。 选型的顺序应该是：先用 30 题测通过率，再用倍率算成本，而不是反过来。

---

15. 在飞算JavaAI 里怎么开始

如果只记三件事：

1. 打开模型框，先把三行「-低速」标黄。 它们是这张表上唯一"不损失能力"的省钱方式，留给夜间批处理。
2. 把 GLM-5.2 那一行忘掉。 0.6× 看起来很香，但 TB 4.0 只有 1.0%。省下的 62.5% 会在返工里三倍还回去。
3. 分析层买最贵，实现层买最便宜，中间用"有没有裁判"划线。 需求分析阶段占 token 不到 5%，却决定 95% 的返工；后端实现有单测兜底，用 0.2× 就够了。

飞算JavaAI 的模型框是这 17 行，但它不替你做这个判断。表是厂商给的，账要自己算。

---

16. 数据来源与说明

16.1 一手来源（厂商官方）

• 智谱 GLM-5.3 发布（2026-08-14）：同基座 744B/40B、Terminal-Bench 4.0 41.9%、DeepSWE v1.1 66.9%、SWE-Marathon 42.5%、Coding 体感 +50%、累计发现 2436 个漏洞（1097 中高危）、价格输入 8 元/输出 28 元/缓存 2 元每百万、1M 上下文 / 128K 输出、effort 三档。
• 智谱 GLM-5.3-Flash：320B/18B 激活、原生图像+视频、线性注意力+稀疏注意力混合、Z.ai Code Bench v1.0 29.0%、价格约为旗舰 1/10。
• 月之暗面 Kimi K3.1 Pro 发布（2026-10-23）：2.8T/104B 激活、1M 上下文、最大输出 131K（可至 1M）、文本+图像+视频、thinking-only、effort low/high/max、Terminal-Bench 4.0 65.7%、SWE-Marathon v1.1 51.7%、DeepSWE v1.1 75.5%、GDPval-AA Elo 1846、Hallu Bench Hard 23.4%→8.3%、Kimi Code Bench 3.0 61.2%（K3 为 55.95%）、价格 $2/$10、缓存 $0.20、高速版 2–3× 速度 2× 价格。
• Kimi K3 Hugging Face 模型卡：2.8T 总参 / 104B 激活、MoE。
• DeepSeek 官方定价页：V4.1-Flash $0.30/$1.20、1M 上下文；V4-Pro 闲时缓存命中 0.15 元/百万。

16.2 独立第三方

• Artificial Analysis：GLM-5.2 综合指数 34、GLM-5.3 45；每任务平均成本 $1.47→$2.01；输入 token 20 亿→54 亿、输出 1.8 亿→2.1 亿；Kimi K3.1 Pro 智能指数 55（全球第 4 / 215 模型）。
• SuperCLUE 智能体终端编程中文测评榜（2026-10-09，固定 Claude Code 框架）：MiMo-V2.6-Pro 64.65 分 / 1.52 元每题（第 1）、MiMo-V2.6-Flash 53.54 分 / 0.67 元（第 5，成本最低）、DeepSeek-V4.1-Flash(max) 50.51 分 / 1.86 元、Hy4-Preview(high) 55.56 分 / 11.61 元；Kimi、GLM、Hy4 分列 2–4 名。
• LLM Stats：DeepSeek-V4.1-Flash-1017 综合 51.2（#15）、Coding 39.3（#14）、Agents 38.7（#8）、CodeForces 100%、GPQA 90.9%、TB 2.1 90.6%、CyberGym 88.1%、DeepSWE v1.1 77.0%；MiMo-V2.6-Flash 综合 44.8（#45）、CyberGym 95.1%、TB 2.1 87.6%、OSWorld-Verified 80.8%、Toolathlon-Verified 73.6%。
• Vals AI：小米 MiMo v2.6 发布的编码环境中，约三分之二的答案可从任务 Git 历史读取；MiMo V2.6 Flash 在 Gauntlet 7.2（支付 app）得 0.7909，落后 Opus 5.5 仅 0.0017。
• Forge 2.0 独立实测（leanzero，账单精确到分）：Claude Opus 5.5 $20.71 / Sonnet 5.5 $6.26 / GPT-6.1 Sol $1.15（47 次请求）/ DeepSeek V4.1 Flash $1.63（261 次请求，1.01 亿 prompt token 中 96.3% 为缓存）/ GPT-6 Luna $0.88 / MiMo V2.6 Flash $0.31 / Qwen3.8 Omni Flash $1.52。

16.3 口径冲突与不确定项（8 条）

1. GLM-5.3 的 TB 4.0 有两个数：41.9%（Artificial Analysis 转引）与 41.8%（Kimi K3.1 Pro 对比图）。差 0.1 个百分点，本文用 41.9%，不影响任何结论。
2. GLM-5.3 的 GDPval 有两个数：1651（AA 口径）与 1769（Z.ai 口径）。本文用 1651 做保守估计。
3. GLM-5.3 在 TB 3.0 上是 28.3%，与 TB 4.0 的 41.9% 不是同一基准。文中凡出现两个数，均已标注版本。
4. Kimi K3.1 Pro 参数有两种说法：官方称"3T 级"，Hugging Face 模型卡与多家第三方称 2.8T/104B。本文采用 2.8T/104B。
5. Kimi K3.1 Pro 的开源状态：官方承诺 11 月 4 日前放出完整权重，许可证未公布。截至本文写作时尚未开源，文中按"将开源"表述。
6. Kimi K3.1 Pro 的单价有两套：官方开放平台人民币价（缓存命中 1.3 元 / 未命中 13 元 / 输出 68 元每百万）与第三方折算美元价（$2/$10）。本文用美元价做横向比较，两者比例不完全一致，属正常汇率与口径差。
7. 「-低速」的机制未获厂商正式文档确认。本文依据"同权重、同能力、更低调度优先级"这一产品定义推理得出，业界同类产品（腾讯云混元低优先级版本）的公开说明与之吻合。若平台实际实现与此不同（例如低速版在并发极高时被降低精度），第 5 节结论需重算。
8. 平台 1.0× 的货币含义未公开。本文所有"倍率"只作相对比较，不与任何货币价格直接换算。实际账单请以飞算JavaAI 结算页为准。

16.4 系列说明

本文是「飞算JavaAI 外部模型选型」系列第八篇。前七篇分别覆盖 DeepSeek-V4 四模型、GLM 三型号、Kimi 三型号、MiMo 双型号、MiniMax-M3 单模型、Qwen3.8 双型号、Step-5-Preview 单模型。本篇为全景篇，不重复单模型的深度参数，只在需要处交叉引用。

---

一句话收尾：这张表上有 17 个数字，但只有一件事值得先想清楚——你付钱是为了让模型更聪明，还是为了让自己的请求不必排队。 前者要挑，后者只要等。