GPT-5.6 Luna 80% Cheaper: Codex Routing Playbook

OpenAI cut GPT-5.6 Luna's API price by 80% on July 30, 2026, and dropped Terra by 20% alongside it. For teams running agents, RAG pipelines, and CI-based AI workflows, that single pricing line rewrites the routing math. Here is how the three GPT-5.6 tiers actually behave, where each one earns its keep, and how to wire Codex CLI to route between them.

Why the Luna price cut matters more than another flagship launch

Frontier benchmarks grab headlines. Pricing changes move budgets. OpenAI framed the cut as a performance gain — same model, better kernels — but the real story is that GPT-5.6 Luna at ~$0.20 per million input tokens makes commodity AI genuinely cheap for the first time in 2026. Three reasons it hits engineering teams hardest:

• Agent loop economics flipped. A 12-step agent that spends 8 turns on extraction, classification, and schema validation used to cost Sol-tier rates. Those turns now cost Luna-tier rates, and you keep Sol for the two planning turns that need reasoning depth.
• Codex CLI became the default routing surface. Codex runs as an Apache-2.0 CLI with a configurable model field. Routing is a one-line config change, not a custom dispatcher.
• The competitive floor dropped again. Claude Sonnet 5 sits at $2/$10 per million tokens through August 31, then jumps to $3 input on September 1. Gemini 3.1 Pro is near $1.25/$5. Luna at the new floor is the reference price for cheap inference that still passes modern evals.

The three-tier GPT-5.6 family in practice

OpenAI shipped three siblings in the family, and the naming is doing a lot of work to confuse people. Here is how I think about them after two weeks of routing real workloads.

Sol: the planner

GPT-5.6 Sol is the flagship. It is the right choice when you need long-context planning, multi-file refactors, or the kind of architectural reasoning that other models still botch. On SWE-bench Verified it is still the ceiling. The cost is ~$5 input / $15 output per million tokens, and Sol should be reserved for the turns where it demonstrably earns that premium.

In my agent loop, Sol runs at:

• The initial plan turn where the agent decomposes a request
• Architectural decisions across files
• Code review on diffs larger than ~500 lines
• Recovery turns after a failed step

Terra: the workhorse

Terra is the model most teams should run as the default. At the new $0.80 input / $2.40 output per million pricing it is competitive with Claude Sonnet 5 on price and within striking distance on most coding evals. For chunked RAG, code generation, and most tool-calling sequences, Terra is the right answer.

The trap with Terra is over-routing to it for things Luna handles fine. If your prompt fits in 8K tokens and has clear instructions, you are paying a Terra premium for a Luna task.

Luna: the commodity layer

Luna is where the price cut lives. The new pricing sits near $0.20 input / $1.20 output per million tokens, down from roughly $1/$6. It is fast, instruction-following is solid, and for short, well-scoped prompts it is hard to tell apart from Terra.

Use Luna for:

• Structured extraction from short passages
• Classification and routing prompts
• JSON-schema-constrained outputs
• Test generation once the test names are decided
• The "summarize what just happened" turn at the end of an agent loop
• Bulk CI annotations on pull requests

Wiring Codex CLI to route by task

The reason this price cut is actionable right now is that Codex CLI shipped a routing surface in mid-2026 that was waiting for exactly this kind of price spread. You can pin a model per session, per directory, or per prompt, and Codex will switch models mid-session if you ask it to.

Static routing with config.toml

The simplest setup is a per-directory configuration. Drop a config.toml in the repo where you want Terra to be the default:

1model = "gpt-5.6-terra"
2model_reasoning_effort = "medium"
3approval_mode = "on-request"

For the prototype folder where you want Luna to handle scaffolding:

1model = "gpt-5.6-luna"
2model_reasoning_effort = "low"

The reasoning effort field matters more than people realize. Luna at low is roughly the same quality as Luna at medium for classification tasks and is meaningfully cheaper. Calibrate per workload.

Dynamic routing with subagents

If you want the planner to dispatch to cheaper models for subtasks, Codex's subagent system supports a model override per spawn. A practical pattern is to write a planner prompt that says:

For each subtask, spawn a subagent pinned to gpt-5.6-luna for extraction and gpt-5.6-terra for synthesis. Reserve direct calls to gpt-5.6-sol for the final review pass.

This gets you roughly 60-70% of the savings without writing a custom dispatcher. The catch is that the planner itself is running on whatever model the parent session uses, so leave the parent on Terra or Sol.

Token accounting before you ship

Before turning on routing in production, run a one-week shadow. Codex has a /usage view that breaks tokens down by model. In my own setup, a 40/40/20 Sol/Terra/Luna split on a coding-agent workload beat a Sol-only baseline by roughly 4x on cost while keeping eval scores within noise.

Where Luna still loses

Luna at this price point has predictable weak spots:

• Long context, long reasoning. Luna drops on tasks holding more than ~30K tokens of code while doing multi-step planning. Push those to Terra or Sol.
• Subtle refactors. When the change spans more than two files and semantics matter, Luna takes the easy path. Review its diffs.
• Ambiguous prompts. Luna is obedient. Vague prompts produce confident-looking nonsense. Terra pushes back slightly better, Sol flags that the prompt itself is wrong.

Treat Luna like a junior engineer with a fast keyboard. Useful for throughput, dangerous for judgment.

The bigger picture: 2026 is the year of routing

What changed between January and August 2026 is that we stopped asking "which model is best" and started asking "which model for which turn." The price spread inside a single family — Sol at 25x Luna — finally makes that question economic instead of academic. Anthropic, Google, and the open-weight vendors are heading the same direction. Claude Sonnet 5 to Opus 5, Gemini 3.5 Flash Lite to 3.1 Pro — every frontier lab now sells a tiered menu, and the engineering work is in the routing layer, not the model selection.

If you have not yet built a routing surface into your agent stack, this is the week to start. A 4x cost reduction on the same product is not something you leave on the table.

Frequently asked questions

Did GPT-5.6 Luna actually get 80% cheaper, or is this marketing?

The cut is real. OpenAI confirmed the new input price at roughly $0.20 per million tokens and output near $1.20 per million tokens, down from about $1 input and $6 output. The announcement frames it as a performance gain — better kernels, lower cost — but the public API pricing dropped to match.

Should I migrate from Claude Sonnet 5 to GPT-5.6 Terra?

On coding evals the two are close. Sonnet 5 is still slightly better at long-context summarization and refusing ambiguous prompts. Terra is faster and cheaper at the new pricing. If Claude is already in production and working, the migration cost is probably not worth it before September 1, when Sonnet 5's introductory price expires.

How do I prevent Luna from being used for tasks it cannot handle?

Two practical levers. First, set model_reasoning_effort = "low" and watch the failure rate on your eval set — if it climbs, push back to Terra. Second, write planner prompts that explicitly forbid Luna for synthesis or refactor turns. Routing discipline lives in the planner prompt more than in the runtime config.

Is the Codex CLI routing surface stable enough for production?

As of mid-2026, yes. Codex CLI is Apache-2.0, the config format is documented, and model_reasoning_effort is honored across sessions. The subagent API for per-spawn model overrides is the part most likely to change, so pin your Codex CLI version if you depend on it.

What happens to my bill if I leave Codex on the default model?

The default is still a frontier-tier model (currently GPT-5.6 Sol). Without explicit routing, you will not see the price cut — savings only show up once you opt into Luna and Terra for the right turns.

The cut is live and the routing surface exists. If you want a head start, the tools page has the Codex CLI setup I use daily, the projects page shows a routed RAG pipeline running on this stack, and the about page explains how I think about agent economics in 2026. Pick a workload, shadow it for a week, and ship the routing config before Luna pricing becomes the new normal — because it will be.