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:

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