GPT-6 Luna Is Becoming the Default: What a Dime per Million Actually Buys

The most consequential thing to happen to GPT-6 Luna in its first week was not the price cut. It was a merge commit. Within a day of the vendor shipping GPT-6 Luna on September 22, 2026, an open-source agent platform landed a change making it the fallback model for every organisation that had not picked a default of its own — displacing GPT-5.6 Terra, which is a larger and considerably more expensive tier. The stated reasoning was arithmetic: at $0.10 and $0.50 per million tokens, GPT-6 Luna costs a twentieth of GPT-5.6 Terra's input rate and a twenty-fourth of its output rate. That is a real signal, and it is also only half the story. GPT-6 Luna is $0.10 per million input tokens and $0.50 per million output tokens, against $2.00 and $10.00 for GPT-6 Sol, the tier above it, and $10.00 and $50.00 for the flagship GPT-6 Astra. The model it replaces in that default slot, GPT-5.6 Luna, still costs $0.20 and $1.20 — twice the input and more than twice the output. A dime per million is cheap enough that the decision stops being about price and starts being about what the model actually finishes.

So this is not a launch explainer, and it is not a price-cut post — we have written both, and the rate card itself is settled. It is an attempt to answer the question the cheap-tier marketing skips: if a model becomes your default, what does it do to the work that used to go to something bigger? The evidence for that comes from three places, and they do not agree with each other. OpenAI's own benchmarks are the most flattering and the least reproducible. Artificial Analysis published an independent index the same week, and it is more useful because it prices completed tasks rather than tokens. And a handful of people have now run the model against real infrastructure, which is where the interesting failures live. Where a number is vendor-reported, the sentence carrying it says so.

What actually shipped

GPT-6 Luna is the small tier of the sixth-generation family, sitting below GPT-6 Sol and well below the flagship GPT-6 Astra. OpenAI's own model documentation, read this week, gives the envelope:

• Model ID — gpt-6-luna, a single snapshot with no dated variant. There is no gpt-6-luna-pro entry on the model list; the pro string circulating on third-party catalogues is a reasoning-mode value, not a model.

• Context and limits — a 1,050,000-token window, up to 922,000 input tokens, a 128,000-token output ceiling, and a May 18, 2026 knowledge cutoff. Text and image in, text out.

• Price — $0.10 per million input tokens, $0.01 per million cached input, $0.125 per million cache writes, $0.50 per million output. OpenAI has described these as permanent rather than introductory.

• The long-context step — requests above 272,000 input tokens are repriced at twice the input and cache rates and 1.5× the output rate, applied to the whole request rather than the excess. That is the single most expensive mistake available on this model, because it is triggered by total request size, not by how much of it you use.

• Service tiers — Batch and Flex run at half the standard rates; Fast mode doubles them. Async bulk work is therefore half price again, and the rate card has four different effective prices depending on how you send the request.

• Effort — six values: none, low, medium, high, xhigh and max, with medium as the documented default. Effort is per-request, not a property of the deployment.

• Endpoints — Responses, Chat Completions and Batch. Chat Completions handles function calling only when reasoning effort is set to none; built-in tools and function calling generally require the Responses API, which supports web search, file search, image generation, code interpreter, hosted shell, apply_patch, skills, computer use, MCP and tool search.

That last line matters more than it looks. If your automation uses tools, you are on the Responses API, and your effort dial is coupled to your endpoint choice. A team that sets effort to low to save money and expects function calling to keep working on Chat Completions has built a pipeline that will fail on the first tool call.

The number that decides it is cost per completed task, not cost per token

Artificial Analysis published its independent evaluation within hours of the launch, and the headline figure is uncomfortable for anyone who assumed a cheaper token means a cheaper job. On its Intelligence Index, GPT-6 Luna costs about $0.07 per task at maximum effort, against roughly $0.18 for GPT-5.6 Luna at the same effort — a reduction of around 60%, driven by the price cut rather than by the model doing less work. The index score itself is level with the model it replaces. GPT-6 Sol, for scale, costs about $1.06 per index task against $1.99 for GPT-5.6 Sol.

Read those three numbers together and the shape of the family becomes clear. Sol is roughly fifteen times the per-task cost of Luna for a materially higher score. Luna is not a downgrade of Sol; it is a different instrument, and the per-task figure is what tells you which one you are holding.

The uncomfortable half is what happened to the coding agent. On Artificial Analysis's Coding Agent Index, GPT-6 Luna scores 41 at maximum effort — down two points from GPT-5.6 Luna's 43 — while GPT-6 Sol moved the other way, up two points to 57 at $2.99 per task. So the generational replacement in the cheap tier is a small regression on agentic coding, not an improvement, even as the price falls. Anyone who reads "new generation" as "strictly better" will be surprised by that column.

Verbosity is the hidden line item

There is a second number in the same evaluation that explains a lot of the first. During the Intelligence Index run, GPT-6 Luna generated about 51,000 output tokens per task, against roughly 41,000 for GPT-5.6 Luna. The newer, cheaper model is around a quarter more verbose to reach a comparable score. The savings come from the price cut, not from the model becoming more efficient per unit of work.

That matters for two reasons. At $0.50 per million output tokens, an extra 10,000 output tokens per task costs half a cent. Run that across a hundred thousand tasks a day and the increment is a billion tokens, or $500 a day — on a model whose headline price is a dime per million input tokens. And verbosity interacts badly with the 128,000-token output ceiling: a model that thinks longer and writes longer hits that cap sooner, which turns a cost problem into a truncation problem.

The mitigation is cache discipline, and this family has a genuinely good one. Cached input reads at $0.01 per million are a tenth of the uncached rate, and OpenAI changed the invalidation rules so that adjusting reasoning effort or tool availability no longer discards cached context. For a workload with a stable long prefix — a schema, a system prompt, a document you ask six questions about — the effective input rate is closer to a cent than a dime, and that gap is wider than the headline cut. It is also the difference between the cheap tier being cheap and it being merely cheaper.

Where the cheap tier regresses, and where it does not

The same independent evaluation separates the regressions from the noise, and the distinction is the most useful thing in it. GPT-6 Luna loses roughly 75 Elo against its predecessor on GDPval-AA v2.1, and about 45 Elo on AA-Briefcase v1.1. Artificial Analysis attributes both to lower presentation quality and deliverables that skip required rubric elements rather than to factual or reasoning failures. Its hallucination rate improves sharply, from about 93% to 77%, and its AA-Omniscience Index moves from −10 to 1. On AutomationBench-AA it gains, 53% against 50%; on Terminal-Bench 4.0 it gains narrowly, 13% against 12%.

That split is the whole decision. The model did not get worse at the task; it got worse at handing you the finished artifact. If you consume structured output — a classification, an extraction, a routing decision, a JSON payload — the regression costs you nothing and the price cut is free money. If a human reads the deliverable, the regression costs you a reviewer, and that reviewer's time is probably more expensive than the tokens you saved.

OpenAI's own unreproduced claims sit at the other end of the spectrum: that at high effort GPT-6 Luna improves on its predecessor by 5.4 percentage points at 58% lower cost per task; that at maximum effort it scores 66.6% on DeepSWE 1.1, which OpenAI compares to Claude Opus 5 at medium effort at a fraction of the task cost; and that on OSWorld 2.0 it exceeds GPT-5.6 Sol at medium effort at roughly one tenth of the cost. Those are vendor-harness comparisons at vendor-chosen effort settings, and the one thing worth taking from them is directional — the cheap tier is now within reach of last year's mid tier. The per-task percentages are worth ignoring, because the harness is not the same on both sides.

The effort floor is where this gets practical. The published guidance is to test none or low first for simple extraction and routing and raise effort only where measured quality justifies it. One hands-on write-up from the launch week found that at low effort GPT-6 Luna is not usable for agentic work at all, which puts its practical floor at medium for anything multi-step. A second finding from the same kind of testing is more pointed: in one deployment exercise the model's Kubernetes manifests passed schema validation and then failed on all three attempts against a real cluster, because a validator checks shape and not behaviour. If generated configuration ships without an execution check in the loop, the cheap tier will hand you failures that look like passes.

The default question, and why routing is the answer to it

The platform that made GPT-6 Luna its fallback model rated the change as medium risk, and the note attached to it is the honest version of the whole article: every organisation without its own default shifts to Luna, which is cheaper but a smaller tier than Terra, so hard-task quality may vary. That is exactly the trade. A default is a bet that most traffic is easy, and for most organisations that bet is correct — which is why the change shipped. The risk is the minority of requests that are not.

The way to take that bet without owning its downside is to stop treating the default as a single model. GPT-6 Luna is routable through OrcaRouter at its listed rate with no markup on top, which means the vendor's permanent price is the price you see here and a future cut lands the same day rather than at the next contract renewal. On our own model page this week it is measuring 74.3 tokens per second of output with a 0% error rate across the traffic we serve. Both context tiers are carried as published: $0.10 in and $0.50 out below 272,000 input tokens, stepping to $0.20 and $0.75 above it.

What that buys is a default that can escalate. A routing DSL lets you send the bulk of traffic to GPT-6 Luna at medium effort and divert on a condition — input length above the 272K line, a tool-call requirement, a task class that the rubric-sensitive regression actually affects — to GPT-6 Sol or, for long-horizon work, to the flagship GPT-6 Astra, on the same key, with no second contract and no code change. That is a different shape of decision from picking one model and living with it. You get the ten-cent tier where the evidence says it holds and a two-dollar or ten-dollar tier where it does not, and the boundary is a rule you wrote rather than a hope. Automatic failover covers the other failure mode, which is the cheap tier's upstream having a bad afternoon while your automation is mid-run.

Who should move, and who should wait

Move if your traffic is structured and high-volume: classification, extraction, tagging, intent routing, log triage, summarisation, and the bounded implementation loops that sit inside a larger agent. The evidence supports the price cut and the score parity, and the presentation regression is invisible to a consumer that parses JSON.

Do not move a long-horizon agent chain, a multi-file refactor, or anything whose output a human signs off on, purely because the token is cheap. The Coding Agent Index moved down two points, the knowledge-work evaluations moved down, and the model is more verbose per task than the one it replaces. A cheaper token that needs a reviewer is not a cheaper task.

And watch one number rather than all of them. The 51,000-versus-41,000 output-token gap is the figure that decides whether a Luna default is a saving or a wash on your particular workload, and it is measurable on your own traffic in an afternoon. The rate card is settled and permanent; the token count per completed job is not, and it is the one that shows up on the invoice.