GPT-5.6 Sol, Terra, Luna: How to Actually Pick a Tier

On July 9, 2026, OpenAI opened GPT-5.6 to everybody. Three models, not one: Sol at the top, Terra in the middle, Luna at the bottom.^[1] Sol costs $5 per million input tokens and $30 per million output tokens. Terra is $2.50 and $15. Luna is $1 and $6.^[1,4] Sit with those numbers for a second, because they are the most interesting thing in the launch and almost nobody wrote about them.

Every tier has the exact same input-to-output ratio. One to six. Terra is precisely half of Sol. Luna is precisely one fifth. There is no pricing curve here, no clever mid-tier discount, no place where the math bends. OpenAI shipped a scalar. Whatever your token mix looks like, heavy input for retrieval-augmented generation (RAG, where you stuff documents into the prompt) or heavy output for code generation, the ratio between tiers never moves. Sol is 5x Luna on any workload you can construct.

That collapses the whole build decision into one question. Is the top model 5x better at your task? Not “better.” Five times better, in dollars. For the overwhelming majority of what agents actually do all day, the honest answer is no, and OpenAI's own benchmark table tells you so.

The tiers are closer than the price gap suggests

Start with the single-shot coding numbers, because that is where most people form their gut opinion. On SWE-Bench Pro (a benchmark that hands a model a real GitHub issue in a real repository and asks it to produce a patch that passes the tests), Sol scores 64.6%. Terra scores 63.4%. Luna scores 62.7%.^[6]

Read that again. The budget model, at one fifth the price, lands within two points of the flagship on the benchmark everyone quotes when they argue about coding models. If you are paying 5x to close a 1.9-point gap on bounded tasks, you are not buying capability. You are buying insurance you never claim on.

Now widen the frame. On the Artificial Analysis Coding Agent Index, which measures multi-step agentic work rather than a single patch, the spread nearly triples: Sol 80, Terra 77.4, Luna 74.6.^[6] On the broader Intelligence Index it widens again, 59 to 55 to 51.^[6] And on Agents' Last Exam, an evaluation of long-running professional workflows across 55 fields, Sol posts 53.6 and beats Claude Fable 5 by 13.1 points.^[7]

There is the whole routing rule, sitting in plain sight. The tiers are nearly identical on short tasks and diverge as the horizon gets longer. That is not a coincidence, it is arithmetic. Small per-step reliability differences compound. A model that is one point worse on a single patch is meaningfully worse on a fifty-step task, because it has fifty chances to be wrong and every wrong step poisons the context the next step reads.

What an agent actually costs, in dollars

Take a coding agent that does something ordinary: read a repo, plan, edit files, run tests, iterate. Call it 25 model calls per task, an average of 40,000 input tokens per call (the system prompt, tool definitions, file contents, prior turns) and 1,500 output tokens per call. That is 1,000,000 input tokens and 37,500 output tokens for one completed task. Not an exotic workload. That is Tuesday.

Run the prices from the launch against it:

• Sol: $5.00 input plus $1.13 output = $6.13 per task.
• Terra: $2.50 plus $0.56 = $3.06 per task.
• Luna: $1.00 plus $0.23 = $1.23 per task.

Now scale it to a product. Ten thousand agent tasks a month, which is a small startup with a few hundred active users, not a hyperscaler. Sol costs you $61,300 a month. Terra costs $30,600. Luna costs $12,300. The difference between the top and bottom tier is $49,000 a month, or roughly $588,000 a year. That is four engineers. For 1.9 points of SWE-Bench Pro.

Caching is a bigger lever than tier choice

Which brings me to the part of the release that got maybe one paragraph of coverage and deserves the headline. GPT-5.6 lets you set explicit cache breakpoints, meaning you tell OpenAI exactly which prefix of your prompt to keep warm, with a 30-minute minimum cache life. Cache writes bill at 1.25x the uncached input rate. Cache reads get the 90% cached-input discount.^[13]

Go back to our agent. In a 25-call loop, the system prompt, the tool schemas, and most of the repo context are identical on every call. Say 90% of your input tokens are a stable cached prefix. Sol's input cost drops from $5.00 to $0.95 (900k cached tokens at $0.50 plus 100k fresh at $5.00). Add the same $1.13 of output and your task lands at $2.08 instead of $6.13. That is a 66% cut, on the flagship, with zero quality loss.

Cached Sol is cheaper than uncached Terra. Read that sentence twice before you go downgrade your model. Most teams reach for a smaller model when their bill spikes, because switching a string in a config file is the easy move and prompt architecture is the hard one. The easy move costs you quality. The hard move costs you nothing.

What “agentic capability” actually means here

Every model launch says “better at agents.” This one shipped a specific mechanism, and it is worth understanding because it changes your cost math more than the tier does.

In the Responses API, GPT-5.6 supports programmatic tool calling. Instead of the classic loop where the model emits one tool call, you execute it, you feed the result back, and the model reads it, GPT-5.6 writes a small JavaScript program that coordinates multiple tools in a hosted runtime, passes data between them, filters the intermediate results, and returns only what matters.^[8] OpenAI reports that on scene-construction workflows this used 63.5% fewer total tokens and 50.1% fewer model turns than the same model doing direct tool calls, with named-customer reductions in the 38% to 63.5% range.^[8]

The strategic read: OpenAI is quietly moving the agent loop from your infrastructure into theirs. Fewer round trips means fewer network hops, less orchestration code on your side, and a much stickier API surface. Every framework you built to manage tool calls is now partially redundant. That is good for your latency and your token bill. It is also good for OpenAI's lock-in, and you should price that in when you decide how much of your stack to hang on it.

The speed tier is where the honest premium lives

One more number that reframes the lineup. Standard Sol is not fast. Artificial Analysis clocked it at roughly 66 to 69 output tokens per second at high reasoning effort, below average for its class.^[6,16] OpenAI also shipped Sol Fast at $12.50 in and $75 out, the same flagship model served on Cerebras hardware at up to 750 tokens per second.^[6]

So the real price ladder is not three rungs, it is four, and the top rung is 12.5x the bottom. What you are buying at the top is not intelligence, it is latency. That is a much more defensible thing to sell. Intelligence commoditizes. A user watching a cursor blink does not.

Here is the trend I would actually bet on. Frontier capability is converging: Sol sits one point below Claude Fable 5 on the Intelligence Index, Gemini 3.1 Pro undercuts everyone at $2 in and $12 out, and Terra undercuts Claude Sonnet 5.^[6] Nobody has a durable quality moat at the top of the stack anymore. The margin is migrating to the things that are hard to copy, which are serving speed, cache infrastructure, and the agent runtime. Watch where the labs put their premium pricing. It tells you what they think is actually scarce.

The 12 days that mattered more than the model

The launch you saw on July 9 was not the original launch. On June 25, the White House Office of the National Cyber Director and the Office of Science and Technology Policy asked OpenAI, on a nominally voluntary basis, to restrict the June 26 release to government-vetted partners, citing Sol's cybersecurity capabilities.^[9,10] Roughly twenty organizations got access. Everyone else waited twelve days.^[12]

I care about this for one boring, practical reason. If you are building a company on top of these APIs, model availability just became a government-adjacent variable. Not regulated, exactly. Nothing here was legally binding, and the White House went out of its way to deny it had given a green light.^[14]But “voluntary” requests that a lab complies with in under 24 hours are not really voluntary in any sense a founder should be planning around.

The thing to internalize is the Preparedness classification. All three tiers, including the $1 budget model, are treated as High capability in cybersecurity and bio.^[3] That is new. The cheap model is dangerous now too. Which means the review process does not just gate flagships. It gates the whole family, and the family is the product.

What I'd do on Monday

Concretely, if I were shipping on this API next week:

1. Instrument step count, not task type.Log how many model calls each of your workflows takes to complete. That histogram is your routing table. Anything under five calls goes to Luna. Anything over twenty goes to Sol. The middle is Terra's job, and Terra is GPT-5.5-class quality at half of GPT-5.5's old price, which is the single best value in the lineup.^[4]
2. Fix caching before you touch the model string. Move everything stable to the front of your prompt, set an explicit cache breakpoint after it, and keep your loop under the 30-minute window. A 66% cut with no quality loss beats an 80% cut that costs you accuracy.
3. Escalate, don't pre-assign.Run Luna first. If it fails a cheap validator (tests don't pass, output doesn't parse, confidence is low), retry on Sol. Two Luna attempts plus one Sol rescue on the 20% of tasks that need it still costs less than putting everything on Sol, and you get Sol's ceiling where it matters.
4. Try programmatic tool calling on your most tool-heavy loop first. The 38% to 63.5% token reduction is a bigger number than anything you will win by arguing about tiers.^[8]

The GPT-5.6 launch got covered as a capability story. It is really a pricing story wearing a capability costume. OpenAI is telling you, with a clean 5:2.5:1 scalar and a premium speed tier, that it no longer expects to win on being the smartest. It expects to win on being the default: the one your routing logic already points at, with your prompt cached in its memory and your agent loop running inside its runtime. Terra at half the price of last year's flagship is not generosity. It is a land grab.

Take the discount. Just build the abstraction layer that lets you leave.