GPT-5.6 Sol vs Terra vs Luna: Which Tier Should You Use?

Start with GPT-5.6 Terra for mixed work, shadow GPT-5.6 Luna on bounded high-volume tasks, and escalate to GPT-5.6 Sol when the task is hard or a bad answer is expensive. The winning tier is not automatically the cheapest token or the strongest label; it is the route with the lowest cost per accepted output after retries and review. As of July 11, 2026, all three are live in the API, while ChatGPT Work and Codex access depends on plan.

At standard API rates, the same 200,000-input-token and 40,000-output-token workload lists at $2.20 on Sol, $1.10 on Terra, and $0.44 on Luna. That is a useful budget boundary, not a production verdict: one retry doubles model spend, and human review can dominate it.

“

Production stop rule: keep the current default until a controlled same-task test shows a lower accepted-work cost, no unacceptable boundary failure, and a working rollback path.

The three GPT-5.6 tiers in one table

OpenAI describes Sol, Terra, and Luna as durable capability tiers rather than a temporary preview ladder. The GPT-5.6 launch announcement and current API documentation establish the model names, access routes, prices, and request controls. The practical difference is how much capability margin you buy for each job.

The bare API alias gpt-5.6 currently routes to Sol. If cost governance or repeatability matters, use the explicit tier ID instead of relying on the alias. That prevents a default alias from silently choosing the most expensive tier and makes later route changes reviewable.

“Pro” is not a fourth model slug. In the current API contract it is a request mode. All three tiers support reasoning-effort controls from none through max; your evaluation therefore needs to lock reasoning effort rather than comparing, for example, Luna at low against Sol at max and calling the result a tier comparison.

Which tier should you choose by workload?

Use task shape to choose the first pilot. Do not ask which tier is universally best; ask where a failure is expensive, where volume dominates, and where the input can be bounded tightly enough to evaluate.

Start Terra for mixed production work

Terra is the strongest default hypothesis when a queue mixes coding, analysis, tool use, document work, and ordinary knowledge tasks. It costs half as much as Sol at standard API rates, yet OpenAI's published results show relatively small gaps between the two on several agentic and knowledge-oriented rows.

That does not make Terra a universal winner. It makes Terra the sensible control lane: broad enough to expose the task distribution, cheap enough to run a representative test, and capable enough that Sol must demonstrate a meaningful improvement rather than win by reputation.

Promote Terra when it clears the same acceptance bar as Sol and the difference in failures or review time does not justify Sol's 2× list price. Escalate specific task families, not the whole account, when Terra repeatedly fails the same important criterion.

Shadow Luna for bounded, high-volume tasks

Luna deserves a separate lane for tasks such as classification, extraction into a schema, rewriting within strict constraints, routing, or short transformations. Its standard token price is one-fifth of Sol and two-fifths of Terra, so a stable bounded workload can create a large spend difference.

But Luna should begin in shadow traffic, not receive an immediate global promotion. Send it representative copies of real tasks, compare its outputs against the current route, and keep its results out of production until the acceptance and boundary data are strong enough.

Use these Luna stop rules:

• stop if the task depends on reliable recall across a very long input;
• stop if tool or schema failures cause repeated retries;
• stop if reviewers must reconstruct omitted constraints;
• stop if zero outputs pass the fixed acceptance bar;
• stop if a small change in prompt wording causes an unstable route.

The long-context stop matters. On OpenAI's provider-reported MRCR row for 256K-512K context, Sol scored 91.5%, Terra 89.6%, and Luna 41.3%. That result is not a universal quality score, but it is a strong warning against assuming that Luna's low price extends safely to very long-context recall.

Escalate Sol for hard or high-failure-cost work

Sol is the right first route when errors are expensive enough that capability margin matters more than list price: complex agentic workflows, difficult reasoning, long-context synthesis, fragile migrations, or outputs whose failure can create operational or compliance damage.

Sol still has to earn its premium. If a Terra run passes the same tests with the same review burden, paying twice the token price does not create extra accepted work. Keep Sol as an escalation lane when its advantage appears only on a narrow task family.

A useful escalation policy is concrete: route to Sol after Terra fails the same material acceptance criterion twice, or when a predeclared risk class requires the stronger lane from the start. Do not escalate because an output merely “feels less polished.”

Access, pricing, caching, and alias boundaries

The product route and API route are different contracts. According to OpenAI's current launch information, Free and Go users get Terra in ChatGPT Work and Codex, while Plus and higher plans can choose Sol, Terra, and Luna in supported product surfaces. A plan entitlement is not an API credit promise, and API list price is not the cost of a ChatGPT subscription.

Caching can change the input side of the comparison, but it does not change the output-price ratio: Sol remains 2× Terra and 5× Luna at the listed standard rates. A high cache-hit workload may make output tokens and review time a larger share of total cost. A low-hit workload with frequent cache writes may do the opposite. Measure the actual hit pattern rather than applying a headline discount to every input token.

Prices, plan entitlements, cache terms, alias targets, and reasoning controls are volatile. Recheck the official pricing page, model guide, and API changelog before a later rollout.

Compare cost per accepted output, not cost per token

The standard price ratio is simple: Sol costs 2× Terra and 5× Luna for both input and output. The same-workload example makes that spread visible:

• Sol: 0.2 × $5 + 0.04 × $30 = $2.20
• Terra: 0.2 × $2.50 + 0.04 × $15 = $1.10
• Luna: 0.2 × $1 + 0.04 × $6 = $0.44

Now add what the token invoice leaves out:

text
cost_per_accepted_output =
  (initial_api_spend + retry_spend + review_minutes × labor_rate / 60)
  / accepted_outputs

Suppose each lane runs 20 tasks. Sol spends $44 and produces 18 accepted outputs with 40 review minutes. Terra spends $22 and produces 17 accepted outputs with 55 review minutes. Luna spends $8.80 but produces 11 accepted outputs and needs 150 review minutes. At a review rate of $60 per hour:

In that illustrative dataset, Terra wins narrowly even though Sol accepts one more output and Luna has the lowest token bill. Change the labor rate, task mix, or acceptance counts and the route can change. That sensitivity is the point: there is no honest production winner without the workload denominator.

If accepted outputs are zero, do not divide by zero or report cheap tokens as efficiency. The lane failed. Stop it, identify the failure class, and decide whether a bounded repair or a different tier is justified.

How to interpret official benchmarks without buying a winner

Provider benchmarks are useful for choosing what to test first. They are not a substitute for testing your prompts, tools, data, latency requirements, and acceptance rules.

OpenAI's published table suggests three practical hypotheses:

1. Sol and Terra can be close on several agentic workloads. That supports starting Terra as the mixed-work control rather than sending every request to Sol.
2. Sol's smaller edge may matter when failure cost is high. A modest benchmark gap can still be valuable on tasks where one missed constraint creates hours of repair.
3. Luna needs a long-context boundary. The large MRCR reversal at 256K-512K makes long-context recall a mandatory test, not an assumed capability.

Do not average unrelated benchmark rows into a home-made “overall score.” A terminal task, a browsing task, a long-context recall test, and a knowledge exam do not share the same failure cost. Map each signal to the workload it actually resembles, and keep the provider's methodology and harness attached to the claim.

Likewise, do not turn a one- or two-point provider-reported difference into a universal quality declaration. The right conclusion is “pilot this route first for this task,” not “this tier is best at everything.”

Run a controlled 20-task tier test

Use 20 representative tasks from the queue you actually plan to route. A tiny demo can reveal gross incompatibility, but it cannot estimate acceptance or retry behavior well enough to justify a production switch.

1. Freeze the test packet

For every tier, lock:

• the exact task and prompt;
• input files and context order;
• tools, permissions, and tool definitions;
• reasoning effort and Pro-mode state;
• temperature or other sampling controls where applicable;
• time limit, retry policy, and maximum turns;
• acceptance tests and reviewer rubric.

If a tier requires different controls to work at all, record that as a separate route. Do not quietly give Sol more reasoning effort or Luna a shorter input and call the comparison fair.

2. Use task-specific acceptance checks

“Looks good” is not an acceptance criterion. A coding task might require tests, lint, type checks, browser verification, and reviewer approval. Extraction might require schema validity plus field-level precision and recall. A research task might require citation validity, source quality, and coverage of mandatory facts.

Define hard failures before the run: invented facts, destructive tool actions, missing required fields, security-boundary violations, or an output that cannot be reviewed inside the time box. These boundaries should not be averaged away by fluent prose elsewhere in the answer.

3. Keep an evidence ledger

For each task and tier, record:

Blind the reviewer to the tier label where practical. Randomize output order and use the same rubric. The goal is not to prove that the flagship wins; it is to discover the cheapest safe route for each task family.

4. Decide with four reversible states

Use a predeclared threshold. For example: promote only if the challenger reduces cost per accepted output by at least 10%, has no additional hard-boundary failures, and stays within the latency budget. A small apparent win below the threshold remains a shadow result until more evidence accumulates.

For cross-provider coding choices, the separate GPT-5.6 Sol vs Claude Fable 5 comparison covers model, harness, billing, and effective-model boundaries. Do not mix those harness differences into this within-family tier test.

A production router you can start with

The following policy is intentionally conservative:

text
if task.risk == "high" or task.long_context == "unproven":
    route = "gpt-5.6-sol"
elif task.family in luna_validated_families and luna_shadow_gate_passed:
    route = "gpt-5.6-luna"
else:
    route = "gpt-5.6-terra"

on material_acceptance_failure:
    escalate one tier and log the reason

on boundary_failure or zero_accepted_outputs:
    stop the lane; do not auto-retry indefinitely

Keep the router versioned. Log the route reason, not only the chosen model. That makes a later alias, price, or model update auditable and lets you roll back without reconstructing why traffic moved.

Start with 90% on the existing route and 10% shadow or canary traffic on the challenger. Expand only after the acceptance, boundary, latency, and cost thresholds remain stable over a representative window. A launch-day benchmark is not a reason to move 100% of traffic.

Frequently asked questions

Is GPT-5.6 Terra the best default?

Terra is the best starting hypothesis for mixed workloads because it costs half as much as Sol and is positioned between the flagship and high-volume tiers. Your default should still be chosen by a same-task test that includes retries, review time, acceptance, and failure impact.

Which GPT-5.6 tier is cheapest?

Luna has the lowest standard API list price: $1 per million input tokens and $6 per million output tokens as of July 11, 2026. It is cheapest per token, not necessarily per accepted output. Review burden and retries can erase the saving.

Which tier should I use for long context?

Start with Sol for high-stakes or unproven long-context work, and test Terra as the lower-cost challenger. Do not promote Luna to long-context production without direct evidence: OpenAI's provider-reported 256K-512K MRCR row shows a much larger Luna drop than the Sol-to-Terra gap.

What does the gpt-5.6 API alias select?

The bare gpt-5.6 alias currently selects Sol. Use gpt-5.6-sol, gpt-5.6-terra, or gpt-5.6-luna explicitly when cost control and reproducibility matter, and recheck the changelog before future deployments.

Can Free or Go users choose Sol, Terra, and Luna?

OpenAI's July 11 launch contract gives Free and Go users Terra in ChatGPT Work and Codex. Plus and higher plans can choose all three tiers in supported product surfaces. Plan access does not create free API usage.

When should I switch the production default?

Switch only when a representative controlled test shows that the challenger clears the same hard boundaries and improves a predeclared metric such as cost per accepted output by a meaningful margin. Roll out gradually and keep a tested rollback path.

Bottom line

Use Terra as the mixed-work control, Luna as a bounded shadow lane, and Sol as the hard-task or high-failure-cost escalation. Then let accepted work—not model branding, a single benchmark, or raw token price—decide what gets promoted.

The first useful action is deliberately small: select 20 representative tasks, freeze the controls, measure retries and review, and keep the current default until the evidence crosses your promotion threshold.