GPT-5.6 Sol vs Terra vs Luna: Which Tier Should You Ship?
OpenAI's GPT-5.6 family splits into Sol ($5/$30), Terra ($2.50/$15), and Luna ($1/$6) per million tokens, and the bare gpt-5.6 alias quietly routes to the priciest tier. This guide maps workloads to tiers by the cost of a wrong answer, not by spec sheets. It also shows when raising reasoning effort on a cheaper tier beats upgrading, and how 90% cache-read discounts shrink Sol's premium. For PMs, the takeaway is that tier routing is now a margin decision that needs a named owner.
This week, pull the model string from every service that calls the OpenAI API and put the list in front of your engineering lead. Anything running the bare gpt-5.6 alias is billing at Sol rates, $5 in and $30 out per million tokens as of July 2026, whether or not the workload needs flagship reasoning. Your concrete action: pin explicit model IDs everywhere, set Terra as the org default, and require a written justification (an eval result, not a vibe) for any service on Sol. Then stand up the cheapest eval you can tolerate: 100 representative requests per workload, run through Luna, Terra, and Sol, scored by whoever owns that product surface. One afternoon of work tells you whether your $2,500-a-month workload is actually a $500 one. Check the caching angle too. If your agents share a long prompt prefix, the 90% cache-read discount changes which tier is genuinely cheapest for you. To be fair to OpenAI, this family is friendlier to buyers than the single-flagship pricing of a year ago; the dial exists, which is more than most vendors give you. But the dial does nothing if nobody turns it. Every week your services sit on the wrong tier is spend you never recover, and your Q3 budget review will not wait for you to get around to it.
The plain gpt-5.6 alias routes to Sol at $5/$30 per million tokens, so teams that swapped only the model string are paying flagship rates by accident.
OpenAI shipped GPT-5.6 in three tiers on July 9, and the default is quietly the most expensive one. Call the API with the bare gpt-5.6 alias and you get Sol, at $5 per million input tokens and $30 out, per OpenAI's model docs. Plenty of teams did exactly that during last week's migration.
My verdict: Terra ($2.50/$15) is the right default for most product work, Luna ($1/$6) should carry your volume, and Sol has to win each workload on merit. Here is the framework for sorting them.
The spec sheet will not sort this for you. All three tiers share the 1.05M-token context window, the 128K max output, the February 16, 2026 knowledge cutoff, and the full tool set, from web search to computer use, per OpenAI's launch docs. I covered the family structure in our GPT-5.6 launch analysis; the prices above are as of July 2026, with live rates in our model tracker.
What actually differs is reasoning depth, speed, and price. So the deciding question is not which model is smarter. It is: what does a wrong answer cost you here?
Price the failure, not the model
Sort every workload by what happens when the model gets it wrong.
If a wrong answer is expensive, buy Sol. An unattended agent refactoring production code, a 40-step plan nobody reviews mid-run: errors compound across steps, and rerunning a failed agent costs more than the tier premium.
If a wrong answer gets caught cheaply, because a human reviews the output or a validator rejects bad results, Terra is enough. OpenAI positions Terra as GPT-5.5-class performance at half the price, per the launch materials, and GPT-5.5 was the frontier model until this month.
If a wrong answer barely matters, or retries cost fractions of a cent (classification, extraction, routing, ticket summaries), use Luna. It is also the fastest tier, and users feel speed, not reasoning depth.
| Workload | Tier | Why |
|---|---|---|
| Unattended agents, long-horizon coding runs | Sol ($5/$30) | Errors compound across steps; reruns cost more than the premium |
| Copilots and RAG with a human in the loop | Terra ($2.50/$15) | Review catches misses; near-flagship output at half the price |
| Classification, extraction, routing | Luna ($1/$6) | Low stakes, high volume; retries are nearly free |
| Latency-sensitive chat, autocomplete | Luna ($1/$6) | Fastest tier; speed is the feature users notice |
| Hard debugging, security review, deep research | Sol ($5/$30) | Reasoning depth is the actual product |
Turn the effort dial before you change tiers
Every tier exposes selectable reasoning-effort levels, per OpenAI's API docs. That dial changes the upgrade math, because a cheaper tier thinking harder often beats a pricier tier at default settings.
Run the arithmetic. Terra's output rate is $15 per million tokens, half of Sol's $30. A Sol request that emits 2,000 output tokens costs $0.06 on output.
Terra can spend 4,000 tokens on the same request (twice the reasoning budget) for the identical $0.06, while its input bills at half Sol's rate. Terra at high effort has to lose badly to Sol at medium before the upgrade pays.
So the escalation ladder runs: Luna at default effort, Luna at high, Terra, Terra at high, then Sol. Move up a rung only when your evals force it. Effort is a per-request parameter; a tier migration is a project.
Now scale it to a full workload. Take 100,000 requests a month at roughly 2,000 input and 500 output tokens each: that is 200M input and 50M output tokens. Luna: 200 × $1 plus 50 × $6 = $500 a month.
Terra: 200 × $2.50 plus 50 × $15 = $1,250. Sol: 200 × $5 plus 50 × $30 = $2,500. Same workload, a 5× spread, and only your eval suite can say which line is justified.
The complete rate card, batch discounts included, is in our GPT-5.6 pricing breakdown, and you can run your own traffic through the cost calculator before committing.
Caching quietly shrinks Sol's premium
Prompt caching is the hidden variable in the tier decision. Cache reads take a 90% discount on all three tiers ($0.50 per million on Sol, $0.25 on Terra, $0.10 on Luna, as of July 2026), while cache writes bill at 1.25× the uncached input rate, per OpenAI's caching docs.
Now price an agent with a fat shared prefix. A 50,000-token system-prompt-and-tools block hit 10,000 times a month is 500M prefix tokens. Uncached on Sol, that input alone runs $2,500.
Served as cache reads, $250. Notice what just happened: Sol's cached input at $0.50 per million is cheaper than Luna's uncached input at $1. On prefix-heavy agent traffic, Sol's real premium concentrates in output tokens, and the list-price gap overstates the working one.
To be fair to OpenAI, routing the bare alias to Sol is a defensible call. First impressions of a new family come from the flagship, and Sol still undercuts Anthropic's Claude Fable 5, priced at $10/$50, by half — how those two actually compare for builders is its own question. But defensible for OpenAI is not cheap for you.
Picking a tier is like picking shipping speed: overnight delivery exists for a reason, and overnighting every package is how mailroom budgets die.
The fix takes ten minutes. Pin explicit model IDs (gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna) in your config and make the bare alias unreachable in production code.
The harder question sits past this quarter's invoice. When one API family spans a 5× price range with a per-request effort dial, model selection stops being an engineering footnote and becomes a margin lever. Teams that build routing and evals now will quietly out-earn the ones paying a flat flagship tax.
So who on your team owns the routing layer — and if the answer is nobody, how much is that costing you every month?
Get this in your inbox. AI Rundown Daily delivers original briefings every morning — free. Subscribe →
Frequently Asked Questions
The claim comes from OpenAI's own launch materials, so treat it as a vendor benchmark until independent numbers settle. OpenAI stopped self-reporting to the tracked SWE-bench Verified leaderboard, which makes third-party verification harder than it should be. What is verifiable: Terra's $2.50/$15 rate is half of GPT-5.5's $5/$30, and GPT-5.5 was OpenAI's frontier model until this month. The practical answer is to run your own evals on 100 representative requests rather than trusting either the marketing or the skeptics. Scores vary by scaffold and source, so your workload is the only benchmark that matters.
Start with static routing, not dynamic: assign each service one tier in config based on the failure-cost framework, using explicit model IDs rather than the gpt-5.6 alias. That is a config change, not a project. The next step up is an escalation pattern, where you call Luna or Terra first and retry on Sol only when a validator rejects the output. Dynamic per-request routing is real engineering, and most teams do not need it yet. Size the potential savings first, then decide how much routing sophistication the money justifies.
Quality failures on cheap tiers are often silent, and that is the real risk. A misclassified ticket or a subtly wrong extraction does not throw an error; it quietly degrades your product until a customer notices. Luna also spends fewer reasoning tokens by design, so multi-step tasks that chain its outputs can compound small misses into large ones. The guard is a validator or human checkpoint downstream of any Luna call whose output feeds another system. If you cannot afford to check it, you probably cannot afford to run it on the cheapest tier.
