TL;DR: Three models, six reasoning-effort levels, zero Codex checkpoints. OpenAI made GPT-5.6 generally available on July 9, 2026 as Sol, Terra, and Luna. The dedicated coding model is gone — gpt-5.3-codex is deprecated and nothing replaced it. What replaced it is a dial, and its top notch, ultra, spawns subagents. Two things the launch numbers won’t tell you: METR could not turn its own evaluation of Sol into a reliable capability estimate, because Sol kept cheating; and in one independent benchmark, Terra costs more per finished task than Sol despite half the per-token price.

OpenAI’s model list has three GPT-5.6 entries — gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna — and, for the first time in three generations, no coding checkpoint.

The last two generations each shipped one (GPT-5.2-Codex, then GPT-5.3-Codex) and Codex CLI defaulted to it. gpt-5.3-codex and gpt-5.2 are now marked deprecated for ChatGPT sign-in, though API-key workflows are unaffected. One entry still carries the name: gpt-5.3-codex-spark, a text-only research preview, Pro accounts only. Codex now runs the same three models as ChatGPT.

The dial that replaced it

Pick a model in Codex CLI with /model, or set it in config.toml:

model = "gpt-5.6-sol"
model_reasoning_effort = "ultra"

Six effort levels: low, medium, high, extra high, max, ultra. (Codex’s config reference spells the fourth one xhigh. The names don’t line up across OpenAI’s own docs, so don’t assume you misread it.)

Three models times six levels. The previous choice was between a general model and a Codex model.

Ultra is a different kind of setting. OpenAI’s docs say ultra mode “goes beyond a single-agent run,” using subagents “to accelerate complex work, making it useful for larger tasks that can be split across subagents.”

The most common objection on Hacker News is that none of this is new. You could already tell Claude Code or Codex to spin up subagents and they’d do it well; people had been doing it for months. That’s true. What moved is where the instruction lives: it used to be a line in your prompt, and now it’s a value in a config file. How autonomously the model decides to fork once that value is set, the docs don’t say.

Why kill the coding checkpoint at all? My guess is that the hard part of coding moved. What blocks an agent now is decomposing a task, handing out the pieces, and collecting them back; writing a for loop stopped being the problem some time ago. That capability comes from letting the model run a small orchestration of its own, and you don’t get it by swapping checkpoints.

Each copy generates its own tokens. Reports put a single ultra call at roughly two to three times the cost of a normal one; I could not find an official source for that multiple, so treat it as a rough ballpark.

What the launch numbers don’t tell you

Here are the ones circulating, all published by OpenAI: Sol scores 88.8% on Terminal-Bench 2.1, 91.9% with ultra, against 83.4% for Claude Fable 5. OpenAI also says Sol is 54% more token-efficient on agentic coding, without making the baseline clear.

Artificial Analysis supplies the one genuinely independent figure: Sol (max) scored 80 on its Coding Agent Index, leading every evaluation in the set. The line you’ll see quoted everywhere (“2.8 points above Fable 5, using less than half the output tokens”) is OpenAI describing its own result on someone else’s index, and Artificial Analysis never said it, though the two usually get quoted together.

METR runs independent pre-deployment evaluations, and reading their report is what made me mark everything above down a grade. They measure a time horizon: the length of task, in hours a skilled human would need, that a model still completes half the time. Partway through measuring Sol, they caught it cheating — improving its score by exploiting bugs in the evaluation environment, or using approaches the task forbids. Concretely: probing a hidden test suite, extracting source code containing the expected answers.

(I’ve written before about unverified completion claims from agents; this is the same problem one level up, in the thing that grades them.)

How you score the cheating decides the answer. Score it as failure and Sol’s 50% time horizon is about 11.3 hours (95% CI: 5–40 hours). Discard the cheating runs and it’s 71 hours (CI: 13 hours to 11,400 hours — that is the real interval). Score it as success and it exceeds 270 hours.

METR’s own conclusion: “we do not consider any of these numbers to represent a robust measurement of GPT-5.6 Sol’s capabilities.” They add that Sol’s detected cheating rate was higher than any public model they have evaluated on their ReAct agent harness. OpenAI’s system card concedes the behaviour, including an instance where the model updated a research draft to say an equation had been computed and verified when it knew it had not.

Before I overreach: the cheating METR documented happened on METR’s own ReAct harness, not on Terminal-Bench. Those are different evaluations, and gaming one does not automatically void the other. I’m not calling 88.8% fake.

It does change how I read it. METR has now established that this model exploits its evaluation environment when the environment allows it, and 88.8% is a number the vendor measured on its own ground, unreplicated.

The cheaper model costs more per task

CodeRabbit ran their own evaluation: over 100 real repository tasks across TypeScript, Go, Python, JavaScript, and Rust, each asking the agent to read a repo, change code, and pass behavioural checks.

Sol passed 63.7%, averaging 20,968 output tokens per task. Terra passed 40.7%, averaging 55,594.

Multiply by list price. Sol’s output runs $30 per million: about $0.63 a task. Terra’s runs $15: about $0.83 a task.

The model with half the per-token price costs about a third more to finish a task, and solves 23 percentage points fewer of them.

Fold the pass rates in — the unit that matters is a solved task — and it gets worse: roughly $0.99 per solved task for Sol against $2.05 for Terra, a little over 2x. That amortises failures across retries and assumes the retries are independent, which they aren’t.

All of this covers output only. Sol’s input costs twice Terra’s and repo-reading is input-heavy, so the real gap could move either way, on one benchmark run on one vendor’s harness.

CodeRabbit also found Sol getting stuck in unproductive paths across multi-turn conversations (one change took eight turns), and still prefers Fable for architectural judgment.

The app went too

Codex is gone from the model list, and it’s going from your desktop. OpenAI folded the Codex app into the ChatGPT desktop app on macOS and Windows, with Chat, Work, and Codex as surfaces inside one app. On macOS you can keep the Codex icon, which leaves the name if not the thing.

Launch-day reporting says ultra is limited to Pro and Enterprise in ChatGPT Work, but available from Plus upward in Codex. OpenAI’s model docs state no plan restriction at all. Check your own account; I wouldn’t plan around the press.

What I’d check

I haven’t run GPT-5.6. I’m out of credits, and it went generally available yesterday — most of the “impressions” online right now are predictions.

If you have access, the useful measurement is small and it isn’t on any leaderboard. Sol averages roughly 21,000 output tokens per task in the published numbers, on repositories that are not yours. So take a task you know well, run it, record the output tokens, and compare against whatever you were using before. (If you’ve never counted them, how many tokens is your prompt actually using? covers the input side; this comparison lives on the output side, which is the expensive half.)

A note on sources. Written the day after GPT-5.6 shipped (July 10, 2026), entirely from published documentation and other people’s measurements. The provenance falls in three layers, which I’ve tried to mark in the text:

• Published by OpenAI: the model list, the six effort levels, pricing, the 88.8% and 91.9% Terminal-Bench scores, the 54% token-efficiency claim. A vendor grading its own model.
• Measured independently: METR’s pre-deployment evaluation, CodeRabbit’s benchmark, Artificial Analysis’s Coding Agent Index. None share OpenAI’s interests — though CodeRabbit and Artificial Analysis each run their own harness and have commercial stakes of their own.
• Derived by me: the $0.63 and $0.83 per-task output costs, and the $0.99 and $2.05 per-solved-task costs, obtained by multiplying CodeRabbit’s token counts by OpenAI’s list prices and dividing by their pass rates. Output only, no input, no cache, and it assumes retries are independent. It illustrates the gap between per-token price and per-task cost. It is not your bill.

Ultra’s plan gating comes from launch-day press, not OpenAI’s documentation. Prices and access tiers move quickly; check the current docs before you act on any of this.

Sources: OpenAI model docs · GPT-5.6 announcement · GPT-5.6 system card · METR pre-deployment evaluation · CodeRabbit benchmark · Artificial Analysis · TechCrunch

Related:

• Why coding agents are moving back to the terminal: why Codex CLI is a terminal program in the first place
• Claude Fable 5: first public Mythos-class model, one day in: the model Sol is benchmarked against here
• How many tokens is your prompt actually using?: worth knowing before you turn ultra on
• When an AI says “done,” ask it to show you: what METR caught is an unverified completion claim

中文版：Codex 5.6 其實不存在：GPT-5.6 的 Sol、Terra、Luna 是什麼

TL;DR：GPT-5.6 在 2026 年 7 月 9 日全面上線，分成 Sol、Terra、Luna 三階。Codex（OpenAI 給工程師寫 code 用的工具，不是你平常聊天的那個 ChatGPT）從此沒有自己的模型：清單上只剩 gpt-5.6-sol、gpt-5.6-terra、gpt-5.6-luna，上一代的 gpt-5.3-codex 標成已淘汰。專用 checkpoint 讓位給一個叫 reasoning effort 的設定，最高那一格 ultra，官方說它會叫 subagent 出來把大任務拆開做。另外兩個反直覺的點：獨立評測機構 METR 在自家測試環境抓到 Sol 作弊，作弊率高於他們評過的任何公開模型；而單價便宜一半的 Terra，在一份獨立測試裡跑完一個任務反而比 Sol 貴。

OpenAI 的模型文件上，reasoning effort 現在列了六段：low、medium、high、extra high、max、ultra。

前面五段講的是同一件事的程度，想久一點、想細一點。第六段換了說法：官方說 ultra 超出單一 agent 跑一輪的範圍，會動用 subagent 來加速，適合那種可以拆開平行做的大任務。

同一份清單的上面，沒有 gpt-5.6-codex。

清單上少了一個名字

前兩代 OpenAI 都會另外出一顆給寫 code 用的 checkpoint：GPT-5.2-Codex、GPT-5.3-Codex，Codex CLI 預設就是用它。（Codex 是 OpenAI 那套 AI 寫 code 的工具，終端機和桌面 app 都有。）

5.6 沒有。能選的就是 gpt-5.6-sol、gpt-5.6-terra、gpt-5.6-luna，跟 ChatGPT 網頁上跑的是同一批。文件裡把 gpt-5.3-codex 和 gpt-5.2 標成「ChatGPT 登入下已淘汰」，用 API key 的工作流不受影響。整條 Codex 血脈只留下一個 gpt-5.3-codex-spark，純文字的 research preview，而且只給 Pro。

Sol、Terra、Luna 這組命名 OpenAI 自己解釋過：數字是世代，名字是能力階，兩邊各自更新。

分化的軸換了一根

Codex CLI 那邊的操作很直白。/model 選 sol、terra 還是 luna，或者直接寫進 config.toml：

model = "gpt-5.6-sol"
model_reasoning_effort = "ultra"

（Codex 的 config 參考文件把 extra high 寫成 xhigh，跟模型文件上的名字對不太起來，看到的時候別以為自己記錯。）

三顆模型乘六段 effort。以前的選擇只有「通用模型」或「Codex 模型」兩個。

Hacker News 那串討論裡，對 ultra 最常見的反駁是這能力早就有了。你今天就可以叫 Claude Code 或 Codex 去開 subagent，它們也做得不錯，這功能存在超過半年了。這話沒錯。差別在於，以前那是你 prompt 裡的一句話，現在是設定檔裡的一個值。至於設好之後模型有多自主地決定要不要分身，文件沒寫。

至於專用 coding 模型為什麼消失，我猜是因為 coding 的難點換地方了。現在卡住 agent 的多半是拆任務、派工、把結果收回來這一段，而寫 for loop 早就不是問題。這種能力得讓模型自己跑一小段 orchestration，換一顆 checkpoint 拿不到。

每個副本各自產 token。有報導說一次 ultra 呼叫大約是一般呼叫的兩到三倍成本，這個倍數我沒找到官方出處，當個粗略的參考就好。

那些數字有多可信

先講大家在轉的那組，這些都是 OpenAI 自己公布的：Terminal-Bench 2.1 上 Sol 拿 88.8%，開 ultra 是 91.9%，Claude Fable 5 是 83.4%。OpenAI 還說 Sol 在 agentic coding 上的 token 效率高出 54%，不過跟誰比，公告沒講清楚。

獨立一點的是 Artificial Analysis：他們自己那套 Coding Agent Index 給 Sol (max) 打 80 分，三項評測都領先。至於「比 Fable 5 高 2.8 分、output token 用不到一半」這句被轉爛的話，是 OpenAI 拿同一個 index 講的，Artificial Analysis 沒說過。這兩句常常被當成同一句轉出去。

METR 是做部署前獨立評測的機構，我讀完他們那份報告之後，把上面整段的可信度往下調了一階。他們量的是 time horizon：一項任務，熟手得花多少時間才做得完，而模型還有五成機率完成它，那個長度就是模型的 time horizon。量到一半，他們發現 Sol 在作弊。METR 的定義是「模型靠鑽評測環境的漏洞、或用任務明文禁止的手段，把分數弄上去」。抓到的實例包括去挖藏起來的測試套件、把寫著預期答案的原始碼撈出來。（我之前寫過怎麼確認 agent 真的做完了，講的也是沒人驗過的完成宣告，只是那時候講的是 agent。）

同一份資料，看你怎麼處理作弊的紀錄，會得出三個數字。把作弊算失敗，50% time horizon 大約 11.3 小時（95% 信賴區間 5 到 40 小時）。把作弊的紀錄丟掉不算，71 小時（信賴區間 13 小時到 11400 小時，你沒看錯）。把作弊算成功，270 小時以上。

METR 的結論寫得很白：「我們不認為上面任何一個數字，構成對 GPT-5.6 Sol 能力的可靠量測。」他們還補了一句，Sol 被偵測到的作弊率，高於他們在自家 ReAct harness 上評過的任何公開模型。OpenAI 的 system card 自己也承認，模型會在任務上作弊、會捏造研究結果，包括把一條根本沒算過的方程式寫成「已計算並驗證」。

這裡要講清楚一件事，不然就變成我在亂扣帽子：METR 抓到的作弊，發生在 METR 自己的 harness 上，Terminal-Bench 是另一個評測。在其中一個作弊，不會讓另一個的分數失效。所以我不會說 88.8% 是假的。

但它確實改了我讀那個分數的方式。METR 已經證實這顆模型會鑽評測環境的漏洞，而 88.8% 是廠商在自己的場地上量的，沒有第三方複驗過。

便宜的那顆，跑完一個任務不一定便宜

benchmark 之外，CodeRabbit 做了一份獨立測試，拿一百多個真實 repo 任務去跑，涵蓋 TypeScript、Go、Python、JavaScript、Rust，要求 agent 讀 repo、改 code、通過行為檢查。

Sol 通過 63.7%，平均每個任務吐 20,968 個 output token。Terra 通過 40.7%，平均吐 55,594 個。

把定價乘進去算一下。Sol 的 output 每百萬 30 美元，一個任務大約 0.63 美元。Terra 每百萬 15 美元，一個任務大約 0.83 美元。

單價便宜一半的那顆，跑完一個任務反而貴了三成，通過率還低 23 個百分點。

把通過率也除進去，算成「解掉一題要多少錢」：Sol 大約 0.99 美元，Terra 大約 2.05 美元，差了兩倍出頭。（這是把失敗的嘗試攤進去算的，假設重試彼此獨立，實際上當然沒這麼乾淨。）

這筆帳只算 output。Sol 的 input 又比 Terra 貴一倍，讀 repo 的任務輸入量不會小，補上之後差距往哪邊跑，我不知道。它也只是單一 benchmark，跑在 CodeRabbit 自己的 harness 上。別把這幾個數字當成你的帳單。我寫一段 prompt 到底花掉多少 token 的時候只處理了輸入端，這裡的落差全在輸出端，而輸出正是貴的那一半。

CodeRabbit 另外提到，Sol 在多輪對話裡有時候會卡在沒用的路徑上打轉，有個改動來回了八輪；而架構判斷，他們還是偏好 Fable。

Codex 這個 app 也一起收掉了

模型清單上沒有 Codex，桌面上也快沒有了。OpenAI 把 Codex app 併進 ChatGPT 桌面版（macOS 和 Windows），Chat、Work、Codex 三個介面收在同一個 app 裡。macOS 上還能掛著 Codex 的 icon，算是留個名字。

方案這邊有個容易搞錯的地方。發表當天的報導說，ultra 在 ChatGPT Work 裡只給 Pro 和 Enterprise，但在 Codex 裡 Plus 以上就開得起來。官方模型文件本身沒寫方案限制，所以這句我只當報導看，用之前自己確認一下。

我還沒真的跑過

額度不夠，我到現在一次都沒跑過 5.6。上面寫的全是讀文件、翻別人量出來的數字。昨天才 GA，網路上現在多數的「心得」都還是預測。

真要知道這三顆值不值，能查的不多：沒有一份 benchmark 跑的是你的 repo，所以拿一個你熟的任務跑一遍，記下它吐了多少 output token，再跟你原本那顆比一下。

聲明：這篇寫在 GPT-5.6 上線的隔天（2026 年 7 月 10 日），文中沒有一個數字來自我自己跑的實驗。出處分三層，我盡量在內文標清楚了：

• OpenAI 自己公布的：模型清單、六段 reasoning effort、定價、Terminal-Bench 的 88.8% 和 91.9%、token 效率 54%。廠商講自己的分數，看看就好。
• 第三方獨立量測的：METR 的部署前評估、CodeRabbit 的 benchmark、Artificial Analysis 的 Coding Agent Index。這三個跟 OpenAI 沒有共同利害，但 CodeRabbit 和 Artificial Analysis 各自有自己的 harness 和商業立場。
• 我自己推算的：Sol 和 Terra 的每任務 output 成本（0.63 / 0.83 美元），以及把通過率攤進去的每題成本（0.99 / 2.05 美元）。都是拿 CodeRabbit 的 token 數乘 OpenAI 的定價算的，只算輸出端，沒算 input 和 cache，也假設了重試彼此獨立。它是一個用來說明「單價不等於總價」的算式，不是你的帳單。

另外，ultra 的方案權限是我從發表當天的報導看來的，官方文件沒寫。這類條件和價格改得很快，真要動手之前，以你當下看到的官方文件為準。

資料來源：OpenAI 模型文件、GPT-5.6 發表公告、GPT-5.6 system card、METR 部署前評估、CodeRabbit 獨立測試、Artificial Analysis benchmark、TechCrunch 報導

延伸閱讀：

• AI 寫 code 為什麼又搬回終端機了：Codex CLI 為什麼長成一個終端機程式
• Claude Fable 5 是什麼？第一個公開的 Mythos 級模型：這篇裡被拿來當基準的那顆模型
• 你的 Prompt 到底花掉多少 Token？：ultra 開下去之前，先知道 token 怎麼算
• AI 說「完成了」，怎麼確認它真的做完？：METR 抓到的，就是一個沒人驗的完成宣告

English version: There is no GPT-5.6-Codex