GPT-6 splits into two models — Sol thinks, Luna ships

What happened

OpenAI released GPT-6 today, and the headline isn't the benchmark scores — it's the packaging. There is no single GPT-6. There are two: Sol, a deep-reasoning model tuned for math, code, and multi-step planning, and Luna, a fast, cheap model optimized for chat, retrieval, and tool use at low latency. Both share a common pretraining base, but they diverge in post-training: Sol is RL'd hard on verifiable reasoning tasks with extended chain-of-thought budgets, while Luna is distilled for throughput and cost.

The API surface reflects the split. You can call `gpt-6-sol` or `gpt-6-luna` directly, or hit `gpt-6-auto`, which routes each request to one or the other based on a lightweight classifier OpenAI runs on the prompt. Pricing is bifurcated too: Luna comes in roughly at GPT-4.1-mini territory (single-digit dollars per million output tokens), while Sol sits well above GPT-5, with a separate meter for "thinking tokens" that don't appear in the response but count against your bill.

ChatGPT gets the same split under the hood. Free users are on Luna. Plus and Pro users get a picker, plus an "auto" mode that's on by default. The model selector — mercifully — is gone from the top bar for most users; OpenAI is betting that routing is a better UX than choice.

Why it matters

This is OpenAI conceding, structurally, what Anthropic and Google have been saying for a year: a single model can't be both the best reasoner and the cheapest chat endpoint, and pretending otherwise is expensive for everyone. Anthropic split the difference with Sonnet and Opus. Google runs Flash and Pro. OpenAI held the line on "one model to rule them all" through GPT-4o and GPT-5, and it finally cracked.

The interesting move is `gpt-6-auto`. Routing has been the dirty secret of every serious LLM product for two years — nobody sends every query to their most expensive model; they classify and downshift. OpenAI is now doing that classification for you, at the API layer, and eating the routing latency itself. If the classifier is good, this is a real product. If it's bad, it's a black box that quietly downgrades your hardest queries to the cheap model and you find out via a support ticket.

The benchmark numbers, for what they're worth: Sol posts 94.2% on AIME 2025, 78% on SWE-bench Verified, and — the one that will get quoted — a claimed 71% on ARC-AGI-2 in high-compute mode. Luna doesn't try to compete on reasoning; it targets tokens-per-second and tool-call reliability, and OpenAI's numbers put it at ~180 tok/s p50 with a malformed-tool-call rate under 0.3%. That tool-call reliability number is the one to actually care about — most agentic workloads fail on schema violations, not on model IQ.

Community reaction on Hacker News is split along familiar lines. The reasoning-model crowd is happy Sol exists as a first-class product instead of a hidden `o`-series sibling. The application developers are annoyed at yet another migration and yet another pricing sheet. And a substantial contingent is skeptical of `auto`-routing on principle: "I'd like to know which model is answering me" is a reasonable thing to want, and OpenAI's response — a `x-openai-model-used` response header — is a partial answer at best.

The deprecation timeline is aggressive. GPT-5 goes into legacy status in 90 days and gets a 3× price hike at 180 days. GPT-4.1 is deprecated immediately for new accounts. If you have production traffic on either, you have a migration on your calendar this quarter whether you wanted one or not.

What this means for your stack

Start by assuming Luna is your default. If your workload is RAG, chat, classification, extraction, or tool-calling against a well-defined schema, Luna is almost certainly the right endpoint — and the cost delta versus Sol is large enough that getting this wrong shows up on the bill within a week. Route to Sol only when you have a task that genuinely requires multi-step reasoning: complex code refactors, math, planning, ambiguous debugging. Everything else, downshift.

If you're building agents, the tool-call reliability number matters more than the reasoning number. Test Luna against your actual tool schemas before you assume you need Sol. The classic pattern — Sol plans, Luna executes — is going to become the default agentic architecture over the next six months, and OpenAI's docs already suggest it. Budget for the thinking tokens on the planning step; they add up faster than people expect.

Be careful with `gpt-6-auto` in production. It's fine for prototypes and internal tools, but for anything with SLAs or reproducibility requirements, pin the model explicitly. The routing classifier will change without notice, and "my agent got dumber on Tuesday" is not a debugging session you want to have. Log the `x-openai-model-used` header on every call regardless — you'll want it when something regresses.

Looking ahead

The two-model split is now the industry consensus, and the next fight is over the router. Whoever builds the best classifier — the thing that decides fast-vs-slow, cheap-vs-expensive, on a per-query basis — captures most of the margin, because most queries don't need the expensive model and everyone knows it. Expect OpenAI, Anthropic, and Google to spend the next year quietly competing on routing quality while the headline benchmarks stay roughly tied. The model you call is becoming less important than the model you get.