GPT-5.6 Sol vs Terra vs Luna: Which Tier for Which Work

OpenAI's GPT-5.6 launch on July 9, 2026 came with a naming scheme that finally makes the lineup legible: the number is the generation, the name is the capability tier. GPT-5.6 is the generation; Sol, Terra, and Luna are the tiers within it, flagship, workhorse, and budget/fast respectively. The API identifiers follow the same pattern: gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna.

That means this is not a comparison of three different models so much as three price points on one generation. All three went generally available the same day and all three stay selectable in Codex during the GPT-6 rollout. The question is not “which is best”, Sol is, by construction, but which one each unit of work deserves. GPT-6 kept the scheme, with Astra above Sol and Luna. Single-model deep dives: Sol, Terra, and Luna.

Data verified September 23, 2026 against OpenAI's published pricing and launch materials. Terminal-Bench 2.1 is the one benchmark OpenAI published across all three tiers, which makes it the family's only like-for-like yardstick, and worth reading carefully, next.

Put the two ladders side by side and the family's economics jump out. From Terra to Sol, the benchmark gap is 1.4 points (87.4% to 88.8%) while Sol costs 2x on input and 1.67x on output ($2 to $4 per MTok in, $12 to $20 out). From Luna to Terra, the benchmark gap is 2.7 points (84.7% to 87.4%) for a 10x price gap ($0.2 to $2 in, $1.2 to $12 out).

Read that way, the Luna-to-Terra step buys nearly twice the benchmark improvement of the Terra-to-Sol step. That is why Terra was the default: it sat at the top of the steep part of the curve, where each dollar still bought measurable capability, while Sol's premium paid for the last 1.4 points plus its exclusive features. The current Codex lineup, and GPT-5.5's October 14, 2026 retirement from Codex with ChatGPT sign-in, are covered in the best Codex model guide.

The benchmark gap understates the tier gap in one respect: two capabilities exist only on Sol, at any price. Max reasoning effort is the family's highest thinking budget, for problems where you want the model to grind. Ultra mode runs native parallel subagents, Sol fans a task out to multiple copies of itself working concurrently, and per OpenAI's launch materials it lifts Sol's Terminal-Bench 2.1 score from 88.8% to 91.9% in ultra mode.

If your workload needs either, the tier question answers itself, Terra and Luna are not discounted versions of these features, they simply do not have them. If your workload does not need them, the 1.4-point benchmark gap is the honest measure of what Sol's 2x input / 1.67x output premium buys.

This is the rule as it applied to GPT-5.6, and it still holds if you run these models. For new work the same shape maps onto GPT-6: start on GPT-6.1 Sol, drop to GPT-6 Luna for mechanical work, and escalate to Astra when failure is expensive.

1. 1

   Start every task on Terra

   The workhorse default: roughly GPT-5.5 performance at 60% lower token prices ($2 in / $12 out per MTok), and within 1.4 points of the flagship on the family's only shared benchmark. Most GPT-5.6 sessions could begin and end here.
2. 2

   Drop to Luna when the task is mechanical

   Lint fixes, renames, formulaic edits, high-volume batch work: if the spec fully determines the diff, Luna's $0.20 in / $1.20 out per MTok does the job at 10x below Terra's price. Never send it work hard enough to fail, a failed cheap run plus a re-run costs more than Terra succeeding once.
3. 3

   Escalate to Sol when failure is expensive

   Hard cross-cutting problems, long agentic runs, terminal-heavy chains, and anything that wants max reasoning effort or ultra mode. At $4 in / $20 out per MTok the premium is real, and worth it exactly when a Terra failure would cost more than the price difference.
4. 4

   Let outcomes tune the routing

   Track which tier each kind of task actually succeeds on. If Terra keeps failing a category, that category is Sol work; if Luna never fails one, Terra was overspend. The rule improves with every merged diff.

The tier decision is cheapest when it is made per unit of work rather than once per project, and that is an orchestration problem more than a model problem. AIDEN's approach: your Codex CLI runs on a kanban board where every feature is a card with its own model, its own branch, and its own diff, so with today's models the mechanical cards run GPT-6 Luna, the defaults run GPT-6.1 Sol, the hardest ones run Astra, and a wrong routing costs you one card, not a sprint. The same board also runs Claude Code side by side, if the answer to “which tier” turns out to be “a different vendor for this feature”, the full field is at the models hub.