GPT-5.6 Sol 对比 Claude Opus 4.8：Ploy 生产迁移的 4 个工程教训（附 CLIProxyAPI 与 Sonnet 5）

2026 年 6 月 26 日，OpenAI 发布了 GPT-5.6 家族——三个能力档位 Sol、Terra、Luna，每 token 价格与 GPT-5.5 完全一致。发布头 10 天里，公开了两次从 Claude Opus 4.8 出走的生产迁移：

• Ploy.ai —— 6 月 26 日当天把默认 agent 模型从 Opus 4.8 切到 GPT-5.6 Sol。在那之前的 4 个月里，Opus（先是 4.7 后是 4.8）一直占着默认槽位，没有任何模型能在 Ploy 的工作负载上打败它。
• CLIProxyAPI（Tibo Sottiaux） —— 通过自托管代理把 Claude Code 的后端指向 GPT-5.6 Sol，不需要重写客户端代码。

两个团队都公开了数据。两个都在生产环境跑通了。两个都踩到了 Sol vs Opus 纸面比较看不出来的坑。本文是它们的工程复盘——每个团队实际改了什么、推翻决定的价格/缓存数学、以及 Sol 在哪些工作负载上仍然输给 Opus。

如果你正在评估用 GPT-5.6 Sol 替换生产 agent 里的 Claude Opus 4.8，这就是把迁移做对、不破坏你的 eval harness、prompt cache、工具调用层的操作指南。

TL;DR

• Ploy 自家 agent eval 套件的实测结果（n=10 对 n=11）：GPT-5.6 Sol 把构建时间压到 2.2 倍（3m 42s vs 8m 00s），成本下降 27%（$2.22 vs $3.06），视觉评分反而更高（0.970 vs 0.936）。输出 token 数砍掉大约一半。
• 决定不是"Sol 更好"，而是"Sol 在这个具体工作上赢了"。Ploy 的 agent 负责构建、编辑、截图、发布真实的营销网站。Opus 之所以能占默认槽位 4 个月，是因为这 4 个月里没有任何东西在那个工作负载上打败它。
• 迁移需要 4 个工程修复成本数据才说得通。Ploy 必须重写 eval harness、修复 Sol"填满每个参数"习惯的工具 schema、围绕 GPT-5.6 的 key-分区缓存节点重建 prompt caching、让 Responses API 的推理重放变成自包含的。
• Tibo / CLIProxyAPI 走的是另一条路：5 分钟装一个代理，让现有的 Claude Code 或 Codex 客户端指向 Sol，不需要改代码。适合没有 Ploy 那种 SDK 级访问权限的独立开发者。
• Opus 4.8 仍然赢的 3 类工作负载：每次调用推理质量比吞吐更重要的短生成、Opus 字号更克制的设计任务、以及任何依赖 Anthropic 组织级共享缓存的架构（GPT-5.6 按设计就无法跨 workspace 共享静态前缀）。
• 如果你在迁移中只谨慎做一件事，重建你的 prompt caching。Ploy 修复前的 Sol 看起来比 Opus 贵 50%，纯粹是缓存配置问题。修完之后，在同一套件上反而比 Opus 更便宜。他们盯着看的每一美元差距都是缓存配置，不是模型定价。

为什么这不是普通的"Model A vs Model B"对比

标准的 Opus vs Sol 文章都是 benchmark 混战：Terminal-Bench 分数、GPQA、MMLU、合成 prompt 上的延迟。但 Ploy 这件事不是 benchmark——他们跑的是自己的生产 eval 套件——几百个"从零构建首页"到"这个克隆请求是否安全可执行"的真实案例，在他们的具体工作负载上得到了一个清晰的答案。同一个模型能在 Ploy 的套件上赢，在你的套件上输。两个原因让 Ploy 的数字值得认真读：

1. harness 是为在位模型调的，Ploy 自己没意识到。他们的工具调用预算按 Opus 的串行风格设计；Sol 会扇出并行调用，在 Sol 实际答对的案例上反而触发预算上限。他们的 eval executor 不支持批量读文件，Opus 几乎不用，Sol 经常用。修复前首次跨模型运行中，大约三分之一的失败源自 harness 假设，不是模型行为，而且这些失败在两个模型上的分布严重不均。Ploy 的教训：在你信任通过率之前先 trace 分类。
2. 赢的那个反而更便宜。2026 年的模型发布常见模式是：新旗舰更贵、稍微更好，你把它用于高端工作负载。Ploy 的案例正好相反：Sol 跟 Opus 同价（$5/$30），因为 token 效率问题让单次任务成本下降 27%，然后缓存配置修对之后进一步降低。这让这次迁移变成一次成本博弈，而不是能力博弈——正好是那种因为媒体报道把它框定为"质量对比"而被跳过的决策。

本文剩下的部分是这 4 步工程复盘。如果你只读一节，读第 2 步（prompt caching）——它是任何 OpenAI-to-Anthropic 或 Anthropic-to-OpenAI 迁移中最大的成本意外源。

Ploy 的数字，修复前和修复后

来自 Ploy 的公开迁移文章（2026 年 6 月 26 日），在重设计套件上比较 Claude Opus 4.8 与 GPT-5.6 Sol，agent 根据参考设计重建一个品牌的首页：

已完成构建的平均值，不是最佳值。Sol 跑平均 4 分钟以内完成一次构建，Opus 在同一套件上要 8 分钟。视觉评分来自一个跑 10 个 yes/no 问题的二元检查判定器（"hero 是全幅照片场景"、"主要 CTA 是圆角矩形不是 pill"），加上内容检查、工具轨迹检查和文件断言。成本是 OpenAI 的实际账单，不是计算估算。

一个有代表性的对比：Opus 产出了一个 17,957 字符的 globals.css，带 174 个 CSS 变量（完整色板，大多没用）。GPT-5.6 写了 2,508 字符，45 个变量，在可比的（有时更好看的）渲染页面上。Sol 写的是精简代码，不只是更快。

但有个坑：这些数字是修复后的。修复前，Sol 在同一工作负载上贵 50%，纯粹是 prompt cache 配置错。在你信任任何跨厂商的 benchmark 价目比较之前，请读第 2 步。

第 0 步：在信任任何数字之前先修你的 eval harness

这是没人想写博客的部分，因为它让前几周的模型评估看起来很傻。Ploy 在两个模型上跑他们的套件，发现首次跨模型运行中大约三分之一的失败源自 harness 假设，不是模型行为——而且失败在两个模型上的分布严重不均。

文章里给的两个具体例子：

• 工具调用预算按 Opus 的串行风格设计。Sol 会扇出并行调用。在 Sol 实际答对的案例上，它会超过这个从 Opus 继承来的预算。Ploy 的 harness 在触发一个为不同模型设计的上限时，把合法的 Sol 跑标记为失败。
• eval executor 不支持批量读文件。Opus 几乎不用批量读。Sol 经常用。harness 把每次文件读当成单独的工具调用，超过单步预算。

还有一个被继承下来的默认值默默改变了 pass/fail 结果：视觉判定器上 1.0 的 minScore 阈值意味着 Sol 评 0.98 的 hero 被标"失败"，而 Opus 跑过的每个单项检查都过、却也被同一个阈值"失败"了。一个看不见的阈值，两种不同的模型行为，没有一个是模型真的错了。

结论：在宣布一个模型"赢"之前先 trace 分类。如果你不分类，你就是在用"新模型有多像旧模型"来打分。重要的数字不是为在位模型调过的 harness 上的通过率——是在 harness 已经审计过那些"在位模型吸收、挑战者暴露"的假设之后的通过率。

第 1 步：Sol 每次都发送每个工具参数

这是在 Ploy 发现之前一直默默腐化结果的那一个。Ploy 的 agent 代码工具有 25 个顶层参数，一个必填（action），其余可选。Opus 发送它用到的那两三个，省略其余。Sol 每次都发 25 个，为它不需要的那些编造看似合理的值：offset: 0、timeout: 120000、siteId: "00000000-0000-0000-0000-000000000000"。

Ploy 对三天生产 trace 的测量：

问题不是冗长。是编造的值与真实的值无法区分。 offset: 0 看起来像一个真参数。Ploy 的文件读实现把它当真，结果 Sol 的 52% 到 64% 的文件读返回空。工具在两种情况下都返回 success: true，所以模型没有方法知道它读到的是空白文件。它只是把工作做得更糟，用了更多调用。

提示工程修不了这个。Ploy 试过：

• 工具描述指令"省略未使用的参数"：仍然 25/25。
• 每个属性加"OPTIONAL, omit if unused"提示：仍然 25/25。
• OpenAI 的 strict 模式：行为完全一致；而且打开它会迫使他们从每个 schema 上剥掉 pattern、format、数组边界校验。

这是烤进模型如何发射 function call 的方式里的。你无法用提示工程把它赶走；你只能在它周围设计。

真正起作用的修复是在 provider 边界做 schema 转换。仅对 OpenAI 家族模型，Ploy 把每个可选属性重写为必填但可空，用 anyOf: [T, null]，给模型一个明确的方式说"我不用这个"。然后，在所有工具调用流过的那个唯一接口，他们在校验之前把 null 剥掉，所以任何工具实现都不需要改动。

// 修复前：25 个键，每个都带一个编造的值
{ "action": "read", "file_paths": [...], "offset": 0, "timeout": 120000, ... }

// 修复后：25 个键，4 个真实值，21 个显式 null（在工具跑之前被剥掉）
{ "action": "read", "file_paths": [...], "offset": null, "timeout": null, ... }

修复后的结果：空文件读从 52% 降到 0%，同一份工作所需的工具调用数减少约 30%，因为它不再重读那些返回空白的文件。

如果你维护一个带可选属性的工具层又在评估 Sol，这是第一个要修的东西。不是可选项。漏掉它的代价对模型不可见（它拿到 success: true），但表现为更差的工作、更多的工具调用和更高的成本。

第 2 步：重建 prompt caching——真正的成本藏在这里

这是整个迁移中最有教育意义的工程差异，因为表面上两个 provider 都提供"prompt caching"，这个词掩盖了两种完全不同的设计。如果你在迁移中只谨慎做一件事，让它成为这一件：在 Ploy 做这件事之前，GPT-5.6 看起来比 Opus 贵 50%。这不是模型的定价；是他们的缓存配置。

Ploy 的 agent 在每个对话开头都有一个大约 29K token 的静态前缀（工具 schema + 核心系统 prompt），对所有对话都完全一样。在 Claude 上，他们用 cache_control 标记 cache breakpoint，这个前缀在整个组织内缓存：任何对话，任何 workspace，一个共享条目，没有吞吐预算要担心。缓存命中率 92% 到 96%，caching 退到后台。

GPT-5.6 把 OpenAI 的缓存模型换掉了，让 Ploy 措手不及。之前的 GPT 模型在部分前缀匹配上隐式缓存，免费提供不错的命中率。GPT-5.6 砍掉了部分前缀匹配：隐式缓存现在只创建以最新消息为键的整 prompt 条目。共享 Ploy 那 29K 静态前缀的新对话缓存命中 0%。每个对话按未缓存费率重计完整前缀，而在 GPT-5.6 上，每个未缓存 prompt 还要付 1.25 倍 cache-write 附加费，无论你是否用 caching。

正确的机制是显式的：prompt_cache_breakpoint 标记加上强制的 prompt_cache_key。key 是设计真正分叉的地方，因为它是缓存身份的一部分。相同的 prompt，不同的 key：零缓存命中。每个 key 映射到一个缓存节点，OpenAI 把流量分到其他有独立冷缓存的节点之前，该节点能撑住大约 每分钟 15 个请求。

这把"启用缓存"变成一个真正的设计决策：你把 key 限定在哪个实体上？

Ploy 落地了 workspace 范围的 key，并把系统 prompt 拆成 breakpoint 分层，镜像他们已经在 Anthropic 上用的结构：

request ──► hash(prompt head + prompt_cache_key) ──► 缓存节点（每个 key ~15 req/min）
│
├── [ tools + 静态前缀 ]··························· A  每个 session
├── [ tools + 静态前缀 + workspace 上下文 ]········ B  同一上下文
└── [ ····················· + turn 1 + … + latest ]  C  本 session

• 条目 A 让 session 的首次调用便宜。
• 条目 B 自我修复：当 workspace 内存变化，请求 miss B 但仍命中 A，然后写一个新的 B。一次 context 大小的写入，而不是完整的 29K 重计费。
• 条目 C 是 OpenAI 的隐式整 prompt 链，在 session 内能工作，因为 Ploy 的 prompt 是严格只追加的。

有一个无解的结果：跨 workspace 共享静态前缀在 OpenAI 上按设计就不可能。Anthropic 能共享，因为它的缓存是组织范围的，没有 key 分区。在 GPT-5.6 上，每个 workspace 在空闲窗口要付一次 29K 冷写入——大约 $0.18。真成本，但有界且可预测。

变更后的结果：首次调用缓存命中从约 0% 升到 83.7%，总未缓存输入 token 下降 28%，GPT-5.6 的每套件成本降到 Opus 之下。Ploy 盯着看的每一美元差距都是缓存配置，不是模型定价。 如果你在做成本对比，其中一边是冷缓存，那你在对比的是你的配置，不是模型。

第 3 步：让 Responses API 的推理重放自包含

更短，但它破坏了真实对话。GPT-5.6 的 Responses API 默认把上一轮推理以服务端 item 引用形式重放；Ploy 的对话开始在中途随机报 Item 'rs_...' not found。

修复是 store: false，让 SDK 请求加密的推理内容并重放自包含的 blob，而不是指向服务端状态的指针。

# Responses API：关掉服务端推理状态，让重放自包含
response = client.responses.create(
    model="gpt-5.6-sol",
    input=conversation_history,
    reasoning={"effort": "high"},
    store=False,  # 关键修复：请求加密推理 blob，不是服务端指针
)

一个让 Ploy 多花一下午调试的推论：当服务端推理状态在循环里，即使你发的字节是只追加的，上游的有效 prompt 也可能改变。如果你需要跨请求可复现的对话状态——为了 eval、测试、审计——store: false 是 GPT-5.6 上唯一的路。

第 4 步（可选）：独立开发者/小团队的 CLIProxyAPI 迁移路径

Tibo Sottiaux 公开了一种不同的做法，面向没有 Ploy 那种 SDK 级访问权限的开发者。CLIProxyAPI 是一个开源代理服务器（github.com/router-for-me/CLIProxyAPI），给 CLI 客户端提供 OpenAI / Gemini / Claude / Codex / Grok 兼容的 API 接口。Tibo 的迁移用例：把 Claude Code 或 Codex 指向 GPT-5.6 Sol 而不需要重写客户端代码。

Tibo 的 X 贴文（2026-06-26）："如果你还不敢装 Codex app，你可以留在你的橙蟹身边，把它指向 GPT 5.6 Sol。5 分钟搞定。致敬 Theo 解释其中一种搞法。"

设置分三步：

1. 装 CLIProxyAPI（从 GitHub releases 拿二进制，或 go install）。
2. 用你已有的 Claude Code 或 Codex OAuth 凭证连接——代理复用你已有的认证。
3. 定义一个指向 GPT-5.6 Sol 的 OpenAI 兼容端点，然后让你的客户端指向这个代理。

对于想要在真实工作负载上对比 Sol 和 Opus 而不承诺全量 SDK 重写的独立开发者或小团队，这是阻力最小的路径。代价：你在循环里跑一个代理，额外加 5-15ms 延迟，并且你依赖 CLIProxyAPI 维护者保障安全和可用性。对 Ploy 量级的流量这不可行；对个人工作流这是合适的工具。

Tibo 的做法在一个具体方面与 Ploy 相反：Ploy 把 GPT-5.6 Sol 当作同一 agent 上 Opus 4.8 的替代品。Tibo 把它当作通过现有 Claude Code / Codex 工具能到达的一个 drop-in 端点。两种做法都行，但暗示了不同的赌注：Ploy 赌 Sol 会在接下来至少 6 个月守住默认槽位；Tibo 赌端点级灵活性比绑定一个 provider 更重要。

Opus 4.8 仍然做得比 Sol 好的地方

Sol 不是 Opus 4.8 的严格升级。Opus 守住阵地的三类工作负载：

• 每次调用推理质量比吞吐更重要的短生成。 一次高风险摘要、法律评审、设计评论——这类调用你宁愿等 8 秒拿一个认真的答案，也不要 3 秒拿一个快的。Opus 在这个上更克制。Ploy 自己的设计负责人（在关于 Opus vs Sol 做网页设计的相关文章里）说 Opus"倾向于保持平衡的字号，即使设计有点非标准"——这种本能对某些品牌系统是对的。
• 带强现有系统的设计任务。 Sol 倾向于把文字做很大，尤其在 hero 标题上。Ploy 迁移前的 harness 让 Sol"忽略现有设计系统，反而产出尖锐、克制、明显同质化的输出。"修复是设计侧引导，但对没有 Ploy 级设计与工程团队的公司，这是一个真实成本。
• 任何依赖 Anthropic 组织级共享缓存的工作负载。 GPT-5.6 按设计就无法跨 workspace 共享静态前缀。如果你的多租户架构构建在 Anthropic 的缓存作用域之上，成千上万的客户调用同一套工具定义，$0.18/workspace 的冷写入成本会累加。Anthropic 的缓存在那个架构下是合适的原语；OpenAI 的不是。

反过来说也对：如果你跑的是单租户或低 workspace 数量部署，Sol 的每 workspace 缓存命中 83.7%，只在单次命中成本这个指标上输给 Anthropic 的 92-96%（Sol 缓存输入是 $0.50/M 对 Claude 约 $0.30/M，但 Sol 的冷写入附加费会改变算式）。正确答案取决于工作负载。

Claude Sonnet 5 重新入场的变数（2026-06-30）

Ploy 的迁移故事在 6 月 26 日以 Sol 拿下默认槽位收尾。两周后，Anthropic 重新部署了 Claude Fable 5 和 Mythos 5（2026-06-30），在美国政府出口管制指令解除后，把 Claude Sonnet 5 在全球恢复上线。Sonnet 5 以 $2/$10（输入/输出每百万 token）的促销价上线，截止 2026-08-31——比 Sonnet 4.5 的 $3/$15 便宜 33%。

如果你今天跑 Ploy 那个对比，模型集合不光是"Opus 4.8 vs Sol"。竞争格局是：

• Claude Sonnet 5 $2/$10（促销）—— 非旗舰档位最佳性价比，200K 上下文，适合代码评审、短生成、中等重量 agent loop。
• Claude Opus 4.8 $15/$75 —— 高端档位，只在 Opus 的本能明显更好的工作负载上值得。
• GPT-5.6 Sol $5/$30（缓存重配后落到 GPT-5.5 等效价）—— 旗舰档位，缓存重配后缓存能力最强。
• GPT-5.6 Terra $2.50/$15 —— 生产环境平衡默认，按一半价格匹配 GPT-5.5 能力。
• GPT-5.6 Luna $1/$6 —— 预算档位，适合聊天、分类、一次性生成。

对于 Ploy 那个具体工作负载（长运行、工具密集、输出 token 主导、设计/生成 agent），Sol 仍然赢。对于 1 小时研究 agent，Sonnet 5 $2/$10 可能是更对的选择。迁移教训可以推广：在你承诺默认模型之前，对你自己的 eval 套件、缓存、成本上限做算术。赢得 benchmark 的默认模型不是赢你生产工作负载的默认模型。

如何在自己的 agent 上评估 Sol vs Opus

如果你想在自己的工作负载上复现 Ploy 的结果，这是操作顺序：

1. 审计你的 eval harness 找出在位模型假设。 工具调用预算、批量调用支持、minScore 阈值、默认判定器权重。Ploy 修复前大约三分之一的"失败"是 harness 工件。别跳过这一步。
2. 为 Sol 的"填满每个参数"习惯修复工具 schema 边界。 通过 anyOf: [T, null] 实现"必填但可空"，在工具执行前把 null 剥掉。验证空读率降到 0，并验证每任务工具调用数下降 20-30%。
3. 在第一次请求前设计你的缓存 key 策略。 多租户用每 workspace、企业用每租户、消费者用每用户。每个 key 映射到 ~15 rpm 的缓存节点，所以高流量 key 会溢到冷节点——为此做设计，而不是发现它。
4. 给 Responses API 调用加 store: false，除非你明确需要服务端推理状态。这是个会在生产中咬你的默认值。
5. 用新缓存策略在固定 eval 套件上测 24-48 小时成本再承诺迁移。修复前的 Sol 比 Opus 贵 50%。修复后的 Sol 更便宜。区别是配置，不是模型。
6. 每次 OpenAI 或 Anthropic 调整定价后重评。 你今天迁移过去的 $5/$30 模型三个月后可能 $3/$18。Ploy 的迁移在 GPT-5.6 启动价时说得通；两边任一家每次动价格卡片，账都要重算。

Ploy 的结果是一个真实的、测量的、修复后的数字，针对具体工作负载。它不是一个通用的"Sol 比 Opus 好"的声称。如果你的工作负载匹配 Ploy 的——长运行、工具密集、输出 token 主导、设计或生成——Sol 很可能对。如果不匹配，自己跑 eval。Ploy 的复盘是怎么把这种 eval 做好的剧本，不是替你做它的替代品。

FAQ

GPT-5.6 Sol 和 Claude Opus 4.8 在生产里的成本差多少？

在 Ploy 的重设计 agent 上（n=10 vs n=11），GPT-5.6 Sol 每次完成构建便宜 27%（$2.22 vs $3.06），墙钟时间快 2.2 倍（3m 42s vs 8m 00s），视觉评分反而更高。成本优势是修复缓存之后的；修复前 Sol 反而贵 50%。输出 token 数砍掉大约一半——Sol 写的是精简代码，不只是更快。

为什么 Ploy 从 Claude Opus 4.8 切到 GPT-5.6 Sol？

Opus 4.8 占据 Ploy 默认模型槽位 4 个月。那 4 个月里没有东西打败它。GPT-5.6 Sol 是第一个在 Ploy 那个具体工作负载（构建、编辑、截图真实营销网站）上打败它的。27% 成本下降 + 2.2 倍速度 + 更高视觉评分，足以支撑一次迁移。这次决定是成本博弈，不是能力博弈——同样的 $5/$30 每 token 价格，但 Sol 的 token 效率翻转了单次任务的总额。

这次迁移需要改代码吗？

需要。四个工程修复：(1) 审计 eval harness 找出在位模型假设，(2) 在 provider 边界转换工具 schema，让 Sol 的"填满每个参数"习惯不会被当作真实参数，(3) 围绕 GPT-5.6 的 key 分区缓存节点、用每 workspace key 重建 prompt caching，(4) 给 Responses API 调用设 store: false 让推理重放自包含。第 4 步代码改动最小。第 3 步是最大的成本杠杆。

我能在不重写客户端代码的情况下用 GPT-5.6 Sol 吗？

可以，通过 CLIProxyAPI（github.com/router-for-me/CLIProxyAPI），一个提供 OpenAI / Gemini / Claude / Codex / Grok 兼容 API 接口的开源代理。Tibo Sottiaux 的 X 贴文演示了 5 分钟的设置：装代理，用你已有的 OAuth 凭证连接，把你的客户端指向 OpenAI 兼容端点。适合独立开发者或小团队评估；不适合 Ploy 量级的生产流量。

Claude Opus 4.8 仍然在哪些地方比 GPT-5.6 Sol 强？

三类工作负载：(1) 每次调用推理质量比吞吐更重要的短生成，(2) 带有强现有品牌系统的设计任务（按 Ploy 设计负责人的说法，Sol"默认把文字做很大"），(3) 任何依赖 Anthropic 组织级共享缓存的多租户架构——GPT-5.6 按设计就不能跨 workspace 共享静态前缀，所以每个租户在空闲时要付 ~$0.18 冷写入成本。

Claude Sonnet 5（6-30 重新部署）在这个对比里怎么定位？

Sonnet 5 以 $2/$10 的促销价上线，截止 2026-08-31——比 Sonnet 4.5 便宜 33%。对中等重量 agent loop 和短时高质量生成，Sonnet 5 $2/$10 经常是比 Sol $5/$30 更好的默认选择，尤其当你的工作负载不需要 Sol 的推理深度时。今天的完整竞争集是 Sonnet 5（$2/$10）+ Opus 4.8（$15/$75）+ Sol（$5/$30）+ Terra（$2.50/$15）+ Luna（$1/$6）。正确的默认取决于工作负载。

GPT-5.6 的 prompt caching 有什么坑？

两个。第一，GPT-5.6 砍掉了部分前缀匹配，所以老的"在公共前缀上隐式缓存"那招不再有效——你需要显式的 prompt_cache_breakpoint 标记和 prompt_cache_key。第二，key 是缓存身份的一部分，每个 key 映射到一个节点，每分钟处理 ~15 个请求之后流量就分到冷节点。错误的 key 策略（每对话、一个全局）让你首次调用命中率接近 0。每 workspace key 是多租户应用的最佳点。

GPT-5.6 Sol 现在能用了吗？

可以，2026 年 6 月 26 日起，三个档位（Sol、Terra、Luna）都已通过 OpenAI API 正式上线。发布页面在 openai.com/index/gpt-5-6。Sonnet 5（可比的 Anthropic 档位）2026-06-30 也在美国出口管制指令解除后恢复上线。

怎么拿到 GPT-5.6 Sol 的 API key？

现有的 OpenAI API key 就能用——Sol 在同一个 api.openai.com 端点，你在请求里指定 model: "gpt-5.6-sol" 即可。Responses API（/v1/responses）是 agent 工作负载推荐的接口表面，缓存 key + breakpoint 设计就用在这。Chat Completions（/v1/chat/completions）也能用，适合更简单的场景。

我今天应该从 Opus 4.8 迁移到 GPT-5.6 Sol 吗？

只有当你的工作负载匹配 Ploy 的：长运行、工具密集、输出 token 主导、设计或生成。在承诺之前跑上面那 6 步评估。成本杠杆（缓存策略）是修复前最大浪费源——如果你不重配缓存就迁移，你会得出 Sol 比 Opus 贵 50%、迁移是个错误的结论。缓存重配之后，结论通常相反。教训：永远不要信任在冷缓存上测出来的跨厂商成本对比。