Blog / 12 juillet 2026 · 6 min read

Sol, Terra, Luna: OpenAI just turned Codex into a vending machine

GPT-5.6 ships in three pricing tiers inside Codex. On paper it's flexibility. In reality, you have to guess which model is going to code your task — and how much it'll cost before you find out.

Okay. I spent part of my weekend comparing pricing grids instead of coding. Not glamorous, but necessary.

OpenAI shipped GPT-5.6 on June 26, 2026, in limited preview, then in public access on July 9. Not one model. Three. Sol, Terra, Luna. Baked straight into Codex.

And the thing that made me pause wasn’t the tier names. It was the output price.

The grid, as it actually stands

I wanted to double-check before writing anything, because aggregators sometimes copy each other without cross-checking. So I cross-referenced the pricing docs with what several specialized sources report (aipricing.guru included). The following numbers are confirmed, input and output, per 1M tokens:

Sol (the flagship): $5 input / $30 output
Terra (the “balanced” model, meant to replace GPT-5.5 for half the price): $2.50 input / $15 output
Luna (fast and cheap): $1 input / $6 output

If you’d only remembered “5 / 2.50 / 1 dollars,” you had half the picture. The other half, the one that actually matters for a coding agent, is that output costs 6 times more than input, across all three tiers.

And a coding agent, by nature, generates a lot of output. It’s not paid to read your repo. It’s paid to write diffs, explanations, commands, test feedback, iterations.

Why this changes the decision

Before, picking a model was a quality question: which one understands my code best?

Now, with three tiers baked into the same product, the question becomes budgetary before it becomes qualitative. Every task you hand to Codex has an implicit price, and that price mostly depends on how much the model is going to write, not how much it’s going to read.

Concretely:

A refactor touching 15 files that regenerates a lot of code → heavy output → Sol gets expensive, fast.
An analysis task (“explain why this test flakes”) → lots of reading, little writing → the gap between Luna and Sol becomes almost anecdotal.
An agent looping through fix-test-refix → each iteration rewrites code → the bill climbs on output, not input.

The tier’s name doesn’t tell you any of this. You have to infer it from the type of task.

When paying for Sol is worth it

I’m not going to pretend I benchmarked the three models on my codebase — I didn’t, and I’m not going to fabricate a score table to look serious.

What I can say is what logically follows from the pricing structure and OpenAI’s announced positioning: Terra is sold as equivalent to the old GPT-5.5 for half the price, and Luna as the “decent capability, minimal cost” tier.

So the real question isn’t “is Sol better?” — it probably is, it’s the flagship. The question is: does the task actually need that extra capability, knowing every output token costs 6x more on it?

Sol justifies itself on:

old architectural debt, with lots of ambiguity and few specs;
a concurrency or security bug where a reasoning mistake costs more than the API bill;
a task you’re going to review line by line anyway — might as well make the first draft as solid as possible.

Terra or Luna are plenty on:

writing tests for already-clear code;
applying a pattern already established elsewhere in the repo;
mechanical, repetitive, low-risk tasks.

And for renaming 80 imports or a dumb SQL migration, none of the three tiers is the right answer. That’s a script. I already touched on this in the article on the end of the magic flat-rate plan: the reflex of “throw everything at the premium model because it works better” is exactly the kind of habit this new pricing grid is going to punish financially.

The real risk: the agent on auto-accept

Here’s what worries me most, and it’s specific to how an agent works, not just to the pricing grid.

When you run Codex in autonomous mode — auto-accept, multiple iterations, potentially delegated subtasks — you don’t pick the tier once. The agent can burn through a lot of turns, each generating output, without you seeing a single bill until the end.

If the session runs on Sol because it’s the project’s default tier, or because the task started out complex and stayed on that model even after it became trivial, you’re paying $30/1M output for operations that would have been $6/1M on Luna.

Multiply that by a correction loop that fails three times before succeeding, and the gap stops being cosmetic.

This is exactly the scenario Gartner points to in its June 24, 2026 forecast: AI coding costs per developer could exceed the average developer salary by 2028, because token consumption escapes human control once you’re on usage-based pricing. Gartner already cites companies spending between 200 and 500 dollars per developer per month — and 6% going over 2000 dollars. This isn’t science fiction, it’s a trend already underway.

What this changes in an actual workflow

A default tier per task type, not per project. Coding a complex feature: Sol allowed but not automatic. Writing tests, applying a known pattern, doing docs: Terra or Luna by default, period.

An explicit cap before launching a long auto-accept session. Not “go ahead, do what’s needed” — more like “here’s the budget, stop and summarize if you go over it.” The “ultra” mode OpenAI announced, which delegates to subagents to move faster, is exactly the kind of feature to watch closely: more subagents often means more cumulative output, so a bigger bill, even if each individual subtask looks small.

Look at the bill per task, not per month. A monthly statement tells you you spent 400 dollars. It doesn’t tell you that 60% of that went into a single poorly-scoped refactor session on Sol when Terra would have been enough.

Don’t confuse “most expensive model” with “safest model.” On an ambiguous task, it’s sometimes the opposite: better to ask clarifying questions cheaply on Terra than let Sol hallucinate an entire architecture at full price.

The bottom line

What I take away from this announcement is less about the model itself than the shift in posture it forces. With a single model, choosing meant accepting the price. With three tiers in the same tool, choosing becomes a constant tradeoff — and an autonomous agent makes that tradeoff on your behalf, turn after turn, without necessarily asking your opinion.

The name “Sol” sounds like a dream. The billing line doesn’t dream.

Sources

— Kevin Aubrée

Keep reading

Back to blog