能力与成本的解耦：Claude Opus 5.5深夜突袭与「能力×成本」复合博弈——Anthropic与OpenAI旗舰对决深度解析
引言：一场被压缩到90分钟的双雄对峙
2026年9月22日的美东之夜，注定要被写进大模型竞争史。Anthropic先发制人，在深夜发布Claude 5.5家族的首款模型Claude Opus 5.5，打出了「达到Fable 5.1水平、运行成本却比Opus 5低40%」的组合拳；仅仅90分钟后，OpenAI便以GPT-6 Sol与GPT-6 Luna应战，把API价格永久性地下调了50%，Luna的输入价一度压到每百万token 0.1美元，直抵前沿模型的地板价36氪。
这与以往「谁更强」的单一叙事不同。过去几个月，前线的竞争焦点明显从单点性能比拼，转向了一个更复杂、更贴近商业现实的目标——「能力×成本」的复合函数。各家不再只追问"谁的模型更聪明"，而是追问"在同一份预算下，谁能买到更多的智能、跑完更多的任务"。本文将以Claude Opus 5.5为主线，把它拆解为三个层次来分析：一是它究竟在哪些基准上领先、在哪些地方仍然落败；二是"降40%成本"这个说法的真实内核是什么，独立第三方Artificial Analysis的测算给出了哪些冷静的注释；三是这场深夜突袭与90分钟反击，折射出的大模型竞争范式变迁——能力与成本正在被解耦，而企业选型的心智模型也在从"每token单价"迁移到"单任务成本"。
一、Opus 5.5是什么：一次"半代升级"背后的代际提速
从版本号看，Opus 5.5只是从Opus 5往前走了半步；但从发布时间看，这一步走得异常之快。Opus 5在今年7月24日才发布，距Opus 5.5仅约两个月Anthropic Newsroom。Anthropic如此急迫，直接原因在于：三天前路透社已报道，随着GPT-6 Astra开始抢回企业市场，Anthropic正考虑提前推出一款新模型应战36氪。社区一度猜测会是Opus 5.2，最终Anthropic直接掀开了Claude 5.5这个新系列的盖子。
Opus 5.5被定位为"面向长时间编程Agent与知识工作的主力模型"。其核心规格如下：默认100万token上下文、最大12.8万输出、思考模式始终开启且不可关闭（无思考关断选项）、默认思考强度为medium，用户可在low到max之间调整，同时支持Fast mode（最高2.5倍吞吐，价格翻倍）。API模型名称为claude-opus-5-5，已上线Claude、Claude Code、Claude Platform，并同步登陆AWS、Google Cloud与Microsoft AzureAnthropic官方。
我们把5.5家族的整体布局画成一张文本架构图，这是整篇文章的第一张图：
图1：Claude 5.5 家族矩阵与定位
┌────────────────────────────────────────────────────────────────────┐
│ Claude 5.5 家族 │
├───────────────┬─────────────────┬──────────────────────────────────┤
│ 旗舰 Opus │ 中端 Sonnet │ 轻量 Haiku │
│ ★ 5.5已发布 │ ∘ 5.5几周内 │ ∘ 5.5几周内 │
│ │ │ │
│ 定位: 长时Agent│ 定位: 常规生产负载│ 定位: 高频轻量任务 │
│ 复杂编码/知识工│ 中等推理/工具调用 │ 低延迟/高吞吐/批量 │
│ 作主力 │ │ │
├───────────────┴─────────────────┴──────────────────────────────────┤
│ 三代能力对照： │
│ Opus 5.5(新) ≈ Fable 5.1(最先进) > Opus 5(上代) │
│ 成本: Opus 5.5 < Opus 5(典型负载≈-40%) │
└────────────────────────────────────────────────────────────────────┘
值得一提的是，Opus 5.5是Anthropic CEO Dario Amodei公开呼吁"为前沿AI减速"(Pacing the Frontier)之后发布的第一款模型。它在发布前接受了Frontier Design与METR等外部机构的评估，Anthropic还采用覆盖近2000个模拟场景的自动化行为审计来检查其越界、欺骗和高风险行为Anthropic官方。这一背景让Opus 5.5的"能力+安全+效率"三重叙事显得更有深意：在减速的同时加速，在追求性能的同时压低成本——这正是"能力×成本"复合博弈的表征之一。
二、基准表现：哪些领先、哪些仍落后
看一个模型不能只看厂商自测。我们把Anthropic官方、OpenAI官方以及独立第三方Artificial Analysis的数据交叉放在一起，就能得到一个相对完整的图谱爱范儿 THE DECODER。
在Agent化编程基准Terminal-Bench 4.0上，Opus 5.5在xhigh档拿到66.4%，超过OpenAI旗舰GPT-6 Astra的57.9%（约8.5个百分点）、超过Fable 5.1的55.8%、更远超Opus 5的52.3%。在CursorBench 4.0上，Opus 5.5达到57.8%，比GPT-6 Sol高约16.1个百分点（Sol为41.7%），比Opus 5的46.6%大幅提升。在FrontierCode v1.1上，Opus 5.5为54.4%，略高于GPT-6 Astra的53.3%。
在知识工作(GDPval-AA v2.1)上，Opus 5.5拿到1846 Elo，显著超过Fable 5.1的1735与Opus 5的1708，更超出GPT-6 Astra约300分。综合多方数据后，Opus 5.5在Artificial Analysis Intelligence Index上拿到58分，位居全球第一，领先于并列53分的Claude Fable 5.1与GPT-6 AstraArtificial Analysis。
但优势并非全覆盖。在AutomationBench上，Opus 5.5为40.0%，略低于GPT-6 Astra的41.4%；在Terminal-Bench-Science 0.1上，Opus 5.5为58.7%，仍落后于Astra的64.6%。这说明OpenAI在"企业业务流程自动化"与"科学推理"两条线上仍有其独到之处爱范儿。
我们把各大编程相关的基准整理成一张图谱：
图2：编程与Agent基准图谱（各模型最高档）
┌─────────────────────────────────────────────────────────────────────────┐
│ Benchmark Opus5.5 Fable5.1 Opus5 GPT6Astra GPT6Sol │
├─────────────────────────────────────────────────────────────────────────┤
│ Terminal-Bench4.0 66.4% 55.8% 52.3% 57.9% 37.3% ★ Opus5.5 │
│ FrontierCode v1.1 54.4% 50.3% 48.0% 53.3% 47.5% ★ Opus5.5 │
│ CursorBench 4.0 57.8% 51.8% 46.6% — 41.7% ★ Opus5.5 │
│ GDPval-AA v2.1(Elo) 1846 1735 1708 1542 1588 ★ Opus5.5 │
│ AutomationBench 40.0% 31.4% 26.9% 41.4% 28.8% ☆ Astra │
│ TB-Science 0.1 58.7% 52.6% 29.0% 64.6% 22.4% ☆ Astra │
├─────────────────────────────────────────────────────────────────────────┤
│ 结论: Opus5.5在程序化编码/知识工作占优; Astra在流程自动化/科研推理领先 │
└─────────────────────────────────────────────────────────────────────────┘
Anthropic自己也特别强调：在如此高的能力水平上，benchmark榜单之间的边际差异已经越来越不能反映真实工作中的体验。在公司内部使用中，Opus 5.5与Fable 5.1之间的差距，比部分评测结果所呈现的还要小Anthropic官方。这句话既是谦虚，也是暗示——真正能体现这次升级的，是那些持续数小时甚至十几个小时的长任务（详见下文实战案例）。
三、定价解构：“降40%“到底降在哪
这是本文最需要冷静对待的部分。Opus 5.5的官方定价确实大幅度下降：输入从Opus 5的每百万token 5美元降至4美元、输出从25美元降至20美元，降幅20%；缓存读取价格从0.50美元降至0.20美元，降幅高达60%Anthropic官方定价页。Fast mode定价为输入8美元、输出40美元，可换取最高2.5倍的输出速度。
但官方口中"典型工作负载运行成本较Opus 5低约40%“这个数字，并不是单纯的单价下降，而是"单价下降×token用量下降"的乘积。Anthropic称，Opus 5.5在同样的Agent化编码任务上，用约一半的轮次、时间和输出token就追平了Opus 5的质量，从而把该工作负载的成本削减了40%到50%Anthropic官方。早前测试中，“在VS Code里解决终端任务的步数不到Opus 5的一半”。
换句话说，“更低的token单价"与"更省token的推理策略"是两把同时落下的刀。这也是为什么OpenAI与Anthropic都在反复劝你关注"单任务成本"而非"每token单价”。
然而，独立分析平台Artificial Analysis给出了一个重要的冷静注释：在最高的推理/努力档位（如max effort）下，Opus 5.5每任务产生的输出token大约达到Opus 5的1.6倍，其中"推理思考token"占了很大比重；虽然单价更低，但由于token用量明显上升，单任务的绝对成本其实与Opus 5大致持平——官方"降40%“的说法，更多是建立在默认/典型工作负载与适中推理档位的前提之上，并不能无条件地推广到所有推理强度场景THE DECODER。
我们把这层关系画成一张"单任务成本测算"图：
图3：单任务成本测算 — 官方口径 vs 独立测算
┌────────────────────────────────────────────────────────────────────────┐
│ 成本驱动 = 单价 × 单任务token用量 │
├────────────────────────────────────────────────────────────────────────┤
│ 定价对比(每百万token): │
│ 模型 输入 输出 缓存读取 Fast模式(输入/输出) │
│ Opus5.5 $4 $20 $0.20 $8 / $40 (≈2.5x吞吐) │
│ Opus5 $5 $25 $0.50 $10 / $50 │
│ 降幅 20% 20% 60% │
├────────────────────────────────────────────────────────────────────────┤
│ 典型负载(官方): token用量下降≈一半 ⇒ 运行成本≈ -40% │
│ 最高推理档(AA): 输出token≈Opus5的1.6倍 ⇒ 单任务成本≈与Opus5持平 │
│ (推理思考token占比高) │
└────────────────────────────────────────────────────────────────────────┘
这个"官方说法在特定前提下方才成立"的细节，恰恰是理解本轮竞争的关键钥匙：厂商用"典型负载40%降价"抢占心智，但聪明的中大型团队一定会结合自己的推理档位分布、缓存命中率和上下文长度，重算一遍真实账单。选型逻辑已经从"每token单价"切换为"单任务成本"的加权求和相关决策。
四、实战案例：数字背后的工程红利
基准和定价是纸面参数，真正的说服力来自真实工程。Anthropic官方与多家早期合作方披露了几个非常硬核的案例爱范儿 Anthropic官方：
- 68万行代码迁移：早期测试者用Opus 5.5在不到一天内完成了一次涉及68万行代码的迁移工作。
- HAProxy的C→Rust重写：Anthropic让Opus 5.5与Fable 5.1分别把HAProxy从C语言重写为Rust，两者都通过了绝大多数回归测试；Opus 5.5用时9.5小时，而Fable 5.1用了12小时，前者成本低了51%。
- 20万行代码库审计：Opus 5.5在不到3小时内完成了一项对20万行代码库的审计与修复，而Opus 5完成同类任务耗时超过20小时，token消耗约为前者的2.5倍。
- 季度业绩报告：在一项只能从一份较难检索的网页副本中取数、任何虚构数字或引语都会判定失败的知识工作测试中，Opus 5.5在不同思考强度下提交的18份报告中有16份过关，而Fable 5.1和Opus 5没有一次达到同一标准；与Opus 5得出相同结论时，完成时间从93分钟缩短到63分钟，成本降低一半。
工程侧的外部声音也印证了这些数字：Box的VP of AI产品称，Opus 5.5只用了Opus 5三分之一的token，答案冗长度降低40%且不损准确性；Factory工程师表示Opus 5.5是第一款可以在medium档就默认采用的模型，用20%-25%更少的输出token就追平了Opus 5在high档的表现Anthropic官方。
下面这一段是可以直接落地的「前沿模型单位经济学」工程代码：把单个token单价、推理思考token放大、缓存命中率与Batch折扣全部折叠进单任务成本，并对Opus 5.5 / Opus 5 / GPT-6 Sol / Luna做跨档位的成本对比与混合路由。
import json
from dataclasses import dataclass
from itertools import product
from typing import List, Tuple
@dataclass
class Tier:
name: str
p_in: float
p_out: float
p_cache: float
effort: float
cpu: float
CAT: List[Tier] = [
Tier("opus-5", 5.0, 25.0, 0.50, 1.0, 1.00),
Tier("opus-5.5", 4.0, 20.0, 0.20, 1.6, 0.65),
Tier("gpt6-sol", 2.0, 10.0, 0.20, 1.3, 0.90),
Tier("gpt6-luna", 0.1, 0.5, 0.01, 1.0, 0.35),
]
BATCH_DISC = 0.5
def task_cost(t: Tier, i: int, o: int, c: int, batch: bool) -> float:
m = (1 - BATCH_DISC) if batch else 1.0
iv = i / 1e6 * t.p_in
ov = o / 1e6 * t.p_out * t.effort
cv = c / 1e6 * t.p_cache
return (iv + ov + cv) * m
def rank(tasks, batch=False) -> List[Tuple[str, float, float, float]]:
out = []
for t in CAT:
cost = sum(task_cost(t, *x, batch) for x in tasks)
comp = sum(x[0] + x[1] + x[2] for x in tasks) * t.cpu
out.append((t.name, round(cost, 4), round(comp / 1e6, 4), t.effort))
return sorted(out, key=lambda r: r[1])
FLOWS = [
(200_000, 60_000, 400_000),
(120_000, 35_000, 500_000),
( 60_000, 18_000, 240_000),
]
if __name__ == "__main__":
print(json.dumps(rank(FLOWS, batch=True), indent=2))
package main
import (
"container/heap"
"fmt"
"sort"
)
type model struct {
name string
cost float64
eff float64
quota int
used int
}
type hh []*model
func (h hh) Len() int { return len(h) }
func (h hh) Less(i, j int) bool { return h[i].cost < h[j].cost }
func (h hh) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *hh) Push(x interface{}) { *h = append(*h, x.(*model)) }
func (h *hh) Pop() interface{} {
old := *h
n := len(old)
x := old[n-1]
*h = old[:n-1]
return x
}
func unit(m *model, in, out, cache int) float64 {
cv := float64(cache) * 0.05
return (float64(in)*m.cost + float64(out)*m.cost*m.eff + cv) / 1e6
}
type flow struct{ in, out, cache int }
func dispatch(ms []*model, streams []flow) []string {
sort.Slice(ms, func(i, j int) bool { return ms[i].cost < ms[j].cost })
h := &hh{}
for _, m := range ms {
heap.Push(h, m)
}
res := make([]string, 0, len(streams))
for _, f := range streams {
p := (*h)[0]
if p.used >= p.quota {
heap.Pop(h)
}
if len(*h) == 0 {
res = append(res, "backoff")
continue
}
p = (*h)[0]
res = append(res, p.name)
p.used++
fmt.Printf("flow(%d,%d,%d)->%s cost=%.4f\n", f.in, f.out, f.cache, p.name, unit(p, f.in, f.out, f.cache))
}
return res
}
func main() {
ms := []*model{
{name: "gpt6-luna", cost: 0.1, eff: 1.0, quota: 60},
{name: "gpt6-sol", cost: 2.0, eff: 1.3, quota: 40},
{name: "opus-5.5", cost: 4.0, eff: 1.6, quota: 20},
}
streams := []flow{
{200_000, 60_000, 400_000},
{60_000, 18_000, 240_000},
{4000, 900, 16000},
}
dispatch(ms, streams)
}
import csv
import math
def load_flows(path):
rows = []
with open(path, newline="") as fh:
for r in csv.DictReader(fh):
rows.append((int(r["in"]), int(r["out"]), int(r["cache"])))
return rows
def monthly_tco(flows, daily=300):
res = {}
for t in CAT:
payg = sum(task_cost(t, *f, False) for f in flows) * daily
batch = sum(task_cost(t, *f, True) for f in flows) * daily
res[t.name] = {"payg": round(payg, 2), "batch": round(batch, 2)}
return res
def sensitivity(flows, budget):
out = []
for t in CAT:
for amp in [0.25, 0.5, 1.0, 1.6, 2.0]:
c = sum((f[0] * t.p_in + f[1] * t.p_out * amp + f[2] * t.p_cache) / 1e6 for f in flows)
out.append((t.name, amp, round(c, 4), c <= budget))
return sorted(out, key=lambda x: x[1])
if __name__ == "__main__":
print(monthly_tco(FLOWS))
print(sensitivity(FLOWS, 50)[:4])
package main
import (
"log"
"sync"
"time"
)
type bucket struct {
mu sync.Mutex
limit int
used int
}
func (b *bucket) take() bool {
b.mu.Lock()
defer b.mu.Unlock()
if b.used >= b.limit {
return false
}
b.used++
return true
}
func refill(bs []*bucket, every time.Duration) {
go func() {
t := time.NewTicker(every)
for range t.C {
for _, b := range bs {
b.mu.Lock()
b.used = 0
b.mu.Unlock()
}
}
}()
}
func emit(streams []flow, bs []*bucket, names []string) {
for _, f := range streams {
handled := false
for i, b := range bs {
if b.take() {
log.Printf("route(%d,%d,%d)->%s", f.in, f.out, f.cache, names[i])
handled = true
break
}
}
if !handled {
log.Printf("backoff(%d,%d,%d)", f.in, f.out, f.cache)
}
}
}
func main() {
bs := []*bucket{{limit: 50}, {limit: 40}, {limit: 20}}
ns := []string{"gpt6-luna", "gpt6-sol", "opus-5.5"}
ss := []flow{{100, 30, 200}, {200, 60, 400}, {80, 20, 150}}
refill(bs, time.Minute)
emit(ss, bs, ns)
}
import json
from math import inf
def pareto(tasks, budgets):
front = []
for t in CAT:
for b in budgets:
tot = sum(task_cost(t, *f, False) for f in tasks)
if tot <= b:
front.append((t.name, round(tot, 4), b))
seen = {}
for name, c, b in front:
if name not in seen or c < seen[name]:
seen[name] = c
return sorted(seen.items(), key=lambda kv: kv[1])
def budget_alloc(tasks, total, min_step=0.05):
best = None
cur = {t.name: 0.0 for t in CAT}
for k in range(1, 401):
f = {}
budget = k * min_step
for t in CAT:
share = max(budget / len(CAT), budget * (t.p_in / 5.0))
f[t.name] = round(share / budget, 3)
if best is None or budget < best.get("budget", inf):
best = {"budget": round(budget, 3), "split": f}
return best
if __name__ == "__main__":
print(json.dumps(pareto(FLOWS, [10, 25, 50, 80]), ensure_ascii=False))
print(json.dumps(budget_alloc(FLOWS, 50.0), ensure_ascii=False))
package main
import (
"fmt"
"math"
"time"
)
type lane struct {
name string
cost float64
fast bool
}
func pickLane(ls []lane, qoe float64) string {
best := ""
m := math.Inf(1)
for _, l := range ls {
eff := l.cost
if l.fast {
eff = eff * 1.0 / 2.5
}
if eff < m || (eff == m && l.fast) {
m = eff
best = l.name
}
}
_ = qoe
return best
}
func retry(ls []lane, n int) {
for i := 0; i < n; i++ {
chosen := pickLane(ls, float64(i))
fmt.Printf("req %d -> %s t=%s\n", i, chosen, time.Duration(i)*time.Millisecond)
}
}
func main() {
ls := []lane{
{name: "standard", cost: 20.0, fast: false},
{name: "fast", cost: 40.0, fast: true},
}
retry(ls, 5)
}
这两段代码的行为与官方披露的「按任务定价」口径同构：把每token单价、推理思考token放大、缓存折扣三条成本曲线叠加后求最优点。团队只需把真实流量聚合成上述张量结构，就能在多个模型档位之间做成本最优且可解释的混合路由；这正是「能力×成本复合博弈」在一线工程里的落点。
五、能力×成本解耦：更强的能力正在以更低成本交付
把Opus 5.5放在更长的产业坐标里看，有一个更结构性的信号值得单独拎出来：**能力在上升，而交付成本在下降，两条曲线正在快速解耦。**这不是RSI式的"模型自我进化"叙事，而是一个关于生产与经营逻辑的观察。
Anthropic自己的工程事实是一个有力的注脚：这家公司内部代码库中，已有超过80%的代码由Claude撰写，AI深度介入了AI自身的研发与测试流程THE DECODER。社区亦有大量分析认为，Opus 5.5在多数任务上达到Fable 5.1水平、成本却大幅下降的根源，很可能在于它由内部更强的"教师模型”（这也是Model 2蒸馏策略的延续）蒸馏而来——用更小、更省算力的serving路径，交付接近顶级的能力。这从Anthropic官方"Opus 5.5比Opus 5需要更少的推理算力"的表态中也能得到侧面印证Anthropic官方。
也就是说，**“更强的能力正以更低的成本交付"不再是口号，而是正在成为可复制的工程方法。**一旦A主能力模型可以被蒸馏/压缩为B经济模型而不显著掉点，那么市场上的"能力天花板"与"价格地板"就会同时上移/下移，把中间的空白越拉越大——这正是OpenAI的Sol/Luna（把Astra的能力"下放"到更便宜档位）与Anthropic的Opus 5.5在同一个夜晚做的是同一件事36氪。
我们用一张帕累托前沿图来刻画这一变化：
图4：能力×成本 帕累托前沿（示意）
智能指数(横轴: 成本) ┃ 高
┃
58┃ ★Opus5.5(max,自适应) ← 新的前沿顶点
57│ ╱
56│ ★×★Opus5.5(多档)
53│ ★Fable5.1 ★GPT6Astra
48│ ★GPT6Sol
37│ ★GPT6Luna
┃____________________________________________
$0.07 $1.06 高 单任务成本→
(La速/OToken) (Sol) (Opus5.5 max档与Opus5持平)
─ 结论: 过去"最贵的=最强"的单一前沿,正被拆解为多条可权衡的曲线 ─
这张图的含义在于：过去我们习惯"贵=强"的一元前沿，如今每个模型家族内部都出现了"能力档位×推理档位×价格"的多个组合点，用户在同一个供应商内部就能做出"花更多钱换更强能力、或花更少钱换足够用的能力"的权衡。竞争的地形从"一条线"变成了"一片前沿”。这，就是"能力×成本复合博弈"的实质。
六、安全与对齐：能力上升时护城河如何跟进
能力的快速上升必然带来安全与对齐层面的新问题。Anthropic在此次发布中展示了一套相当完整的"安全路由护栏"逻辑Anthropic官方 爱范儿：
- 外部前置评估：发布前经Frontier Design与METR等外部机构评估，并使用覆盖近2000个模拟场景的自动化行为审计检查越界、欺骗与高风险行为。
- 对齐改善：在一项专门测试"模型跨越遏制边界倾向"的新评测中，Opus 5.5尝试突破边界的频率较Opus 5与Claude Mythos 5.1降低约85%，且其每次尝试都被自报为低严重事件。
- 能力降级路由：由于Opus 5.5在生物与网络安全能力上已接近Mythos 5.1，Anthropic为其启用了与Fable 5.1相近的安全措施——大部分网络安全请求会被路由到能力较低的Opus 4.8处理；只有通过验证的安全研究人员和生命科学机构，才能获得更完整的能力。
- 反蒸馏保护：Opus 5.5沿用Fable 5.1引入的"preserved thinking”（保留推理）反蒸馏机制，对2026年8月31日之后创建的API账号生效Anthropic官方。
我们把这套护栏机制画成一张路由图：
图5：Opus 5.5 安全路由护栏
┌────────────┐ ┌──────────────────────────────┐
│ 开发者请求 │──▶│ Opus 5.5 前置防护检查(Cyber/?BIO) │
└────────────┘ └───────────────┬──────────────┘
│
┌──────────────────┼──────────────────┐
▼ ▼ ▼
┌────────────────┐ ┌───────────────┐ ┌────────────────┐
│ 通过验证的机构 │ │ 一般业务请求 │ │ 高危网络安全 │
│ (安全/生命科学) │ │ (直接回答) │ │ (回退路由) │
└───────┬────────┘ └───────┬───────┘ └───────┬────────┘
│ │ │
▼ ▼ ▼
Opus5.5完整能力 Opus5.5常规能力 Opus 4.8(能力降级)
(完整生物/网络安全能力) (阻断高风险能力外溢)
─ 尝试越界频率较Opus5/Mythos5.1 降低≈85%，且低严重、自报 ─
这套路由的意义在于：它承认了"更强的模型同时也更危险”，因此通过"能力按需发放"来对冲风险——而不是一刀切地禁用。这与Anthropic一贯的"能力分级+验证准入"思路一脉相承，也是前沿模型在商业化与安全之间寻找平衡的新范式。
七、90分钟的OpenAI反击：从"性能对决"到"卡位定价”
真正的戏肉，在于Opus 5.5发布90分钟后OpenAI的闪电反击。OpenAI一口气端出GPT-6系列的另外两档：GPT-6 Sol与GPT-6 Luna，与旗舰GPT-6 Astra组成三档产品矩阵36氪 i黑马：
- GPT-6 Astra（旗舰）：输入10美元、输出50美元/百万token，面向必须做任何能力妥协的严肃任务。
- GPT-6 Sol（中端主力）：输入2美元、输出10美元，仅Opus 5.5的一半、Astra的五分之一，面向复杂Coding与Agent工作流。对比基准：在AutomationBench上Sol得分33.2%（低于Opus 5.5的40.0%），但单任务成本仅0.27美元。
- GPT-6 Luna（高频轻量）：输入0.1美元、输出0.5美元，缓存读取低至0.01美元，砍到Astra的1%，对标高频、大规模、任务集中的批量化工作。Artificial Analysis给Luna的智能指数为37分，甚至低于DeepSeek V4.1 Flash的39分——便宜到极致，但天花板也确实下移。
三档模型均支持105万token上下文、12.8万最大输出，且都支持文本与图片输入、网页搜索、文件搜索、代码解释器、Computer Use、MCP、Skills等工具；推理档位比Astra多一个none（可完全关闭推理）。OpenAI强调，这是永久降价，不玩限时促销——相对GPT-5.6促销价下调50%；若对比原价，实际降幅接近60%36氪。
我们把两家在同一个夜晚的旗舰对峙格局画成一张矩阵：
图6：两阵营旗舰对峙格局（2026-09-22 / 美东）
┌──────────────────────┬──────────────────────────────────────────────┐
│ Anthropic │ OpenAI │
├──────────────────────┼──────────────────────────────────────────────┤
│ 旗舰: Opus5.5 │ 旗舰: GPT-6 Astra $10/$50 │
│ $4/$20 (典型负载-40%)│ │
│ 智能指数58(全球第1) │ │
│ 中端: Sonnet5.5(几周) │ 中端: GPT-6 Sol $2/$10 (Astra能力下放) │
│ 轻量: Haiku5.5(几周) │ 轻量: GPT-6 Luna $0.1/$0.5 (地板价) │
├──────────────────────┴──────────────────────────────────────────────┤
│ 同一个主题: 把旗舰能力/效率成果"下放"到更便宜的档位, 铺满全预算层级 │
│ 价格战阶段: 从"成本下降让利" → "卡位定价(占住默认选项)" │
│ OpenAI口径: 永久降价50%(锚=GPT5.6促销价; 实际≈60% vs 原价) │
└───────────────────────────────────────────────────────────────────┘
但OpenAI这一招也并不是没有代价。首先是口径上的花招：官方对比图只出现Opus 5与Fable 5，刻意回避了同日发布的Opus 5.5（官方解释为"无分项数据时以Fable 5顶替"）36氪。第三方测试让三款GPT-6模型跑同一组构建任务，排序为Astra全胜、Sol次之、Luna再次，与价格严格一致，便宜档速度快两到六倍但成品均有可见瑕疵。除此之外，Sol的OSWorld 2.0分数从上代GPT-5.6 Sol的65.7%回退到60.5%，DeepSWE v1.1的最高分68.8%也低于上代的72.7%——“峰值分数回退、对比对象选择性选取"意味着"升级"二字在峰值维度并不完全成立。
然而从商业逻辑看，这正是"能力×成本复合博弈"的精髓：**对每天要跑几千次Agent调用的团队而言，单任务成本比峰值分数重要得多。**OpenAI把"性价比曲线"整体往左移，主动让出峰值，靠走量吃下长尾需求。Sol在AutomationBench上的单任务成本仅0.27美元、得分却高于Opus 5且成本只有其9%；Luna在DeepSWE上接近Opus 5与Fable 5的中档水平，单任务成本却分别低93%和96%36氪。
两个阵营在同一天，用不同的产品排布，指向了同一个判断：**大模型的竞争，已经从"谁的分数最高"演变为"在每个预算档位，谁能提供最划算的智能”。**这是一场关于开发者心智默认选项的卡位战。
八、市场与产业：价格战焊死在哪条曲线上
把两家新模型放进更宏观的市场坐标，能看清这不是孤立事件，而是一条已经走了半年的下行曲线新浪财经/格隆汇：
- 市场统计显示，OpenAI、Anthropic及更广泛市场的每百万token混合价格，在2026年3月初见顶于1.40美元以上，到9月已落到0.50至0.80美元区间；Ramp口径更直接，9月有效价0.68美元，比3月峰值1.15美元低了四成。
- 价格下降后，智能体、长上下文、高频生产循环这些过去被成本"按住"的需求会成倍铺开——总需求并没有被价格赶走，而是被释放出来，锁进算力管道里。
- 算力侧的回应同样清晰：全球已部署AI算力对应的电力规模，预计从2025年约18吉瓦增至2028年约115吉瓦；OpenAI与Anthropic两家实验室的占比将从约五分之一升至三分之一以上。模型越便宜，请求越密集，电力账本上的数字就越硬。
9月23日的资本市场上，这一逻辑已经先行定价：纳斯达克指数上涨0.45%报27244.28点创历史新高，费城半导体指数涨2.06%连续第六个交易日收高；周二A股算力硬件与存储芯片板块指数已居涨幅前列，CPU与半导体链条整体飘红。不过，这条链条上的乐观预期已被交易掉相当一部分——半导体这轮涨的是订单能见度，当下的利润率尚未同步抬升，“价减量增"之下谁的收入能真金白银落地，要等接下来几个季度的报表与资本开支指引新浪财经/格隆汇。
我们用一张图来刻画整个市场的价格下行路径与需求释放：
图7：混合token价格下行与需求释放（2026年3月-9月）
$1.40 ┤ M(3月峰值)
$1.15 ┤ Ramp 3月峰值
$1.00 ┤
$0.80 ┤ ◄── 9月市场区间上沿
$0.68 ┤ Ramp 9月有效价
$0.50 ┤ ◄── 9月市场区间下沿 / GPT6Luna地板价(0.01~0.1量级)
─────┴────────────────────────────────────────────►
Mar Apr May Jun Jul Aug Sep
推论: 单价↓ → 需求释放 → 请求量↑ → 电力/算力账本变硬
电力规模: 2025≈18GW → 2028≈115GW(新兴两巨头占比1/5→1/3+)
这张图说明，“能力×成本复合博弈"最终会传导到整个AI产业的基础设施层：模型的降价不是终点，而是撬动更大规模算力与电力需求的杠杆。谁在供给端——芯片、存储、电力、数据中心——能够承接住"更便宜→更密集"的需求曲线，谁就吃到了模型价格战最大的外溢红利。
九、对开发者的启示：把选型逻辑换挡
最后，我们把这场博弈对一线开发者与架构师的启示收束为几点可执行的建议：
**1. 从"每token单价"切换到"单任务成本”。**Opus 5.5在最高推理档的单任务成本与Opus 5持平（readback来自Artificial Analysis），但在典型负载下大幅更优。选型时务必要结合自己的推理档位分布、缓存命中率、上下文长度与任务类型，用真实的token谱系重算账单——不要被单一的数字（无论是40%还是50%）带节奏。
**2. 用"能力×成本"的帕累托前沿做容量规划。**随着每个厂商都推出"旗舰/中端/轻量"多档矩阵，你可以在同一供应商内部做"花更多钱换更强能力、或更少钱换足够用能力"的组合，而不是在不同厂商之间反复迁移。混合路由——简单任务走轻量档、复杂长任务走旗舰档——将成为常态化的成本优化手段。
**3. 留意"能力下放"带来的红利窗口。**Opus 5.5由更强教师模型蒸馏而来、Sonnet 5.5与Haiku 5.5几周内铺齐；OpenAI把Astra的能力下放到Sol/Luna。当"更强的能力正以更低成本交付"成为可复制的工程方法时，过去因为成本而不敢用前端模型的生产场景，将迎来一轮集体放量——这既是机会，也意味着更激烈的同质化竞争。
**4. 安全与信任是新的差异化。**当各家能力趋近、价格趋同，安全路由、可验证性、数据驻留（如US-only 1.1x）、零留存承诺会成为B端决策从"能不能用"到"敢不敢用"的隐性门槛。Opus 5.5那套"生物/网络安全能力按验证准入发放"的护栏，正是这一趋势的示范。
十、结语：深夜突袭之后，竞争进入多变量时代
Claude Opus 5.5在美东深夜的发布，以及90分钟后OpenAI GPT-6 Sol/Luna的应战，其实共同宣告了一件事：**大模型竞争已从一个变量（能力）进入两个变量（能力×成本）甚至更多变量（能力×成本×安全×生态）的复合博弈阶段。**Anthropic用"性能达到Fable 5.1、成本降40%“证明了自己在"省着变强"上的工程能力；OpenAI用"Sol/Luna三档矩阵+永久降价50%“证明了自己在"把旗舰能力铺向全预算层级"上的商业纵深。两者都在做同一件事——让"更强的能力"与"更低的成本"解耦，然后重新焊进每条产品线。
正如Anthropic自己反复强调的，benchmark的边际差距已经越来越难以说明真实世界的差异。真正决定牌局的，是单项任务成本、长任务稳定性、安全可信度，以及谁先在开发者心智里占住"默认选项”。从Opus 5到Opus 5.5只有两个月，从Astra到Sol/Luna可能更短——在这场以"能力×成本"为坐标系的新竞争里，唯一不变的是：每一次深夜发布，都会在次日变成别人第二天就必须回应的靶心。
这，就是大模型进入"能力×成本"复合博弈时代最真实的注脚。