GitHub announced that GPT-6 Sol and GPT-6 Luna are now available in Copilot, joining the Astra that shipped earlier. The same day, Vercel enabled them on AI Gateway and OpenAI published its official announcement. Sol is positioned as the balanced model for agentic work; Luna as the lightweight option and the cheapest in the family.
Why it matters
The signal isn't in the benchmarks. It's in the price. According to the breakdown Hipertextual published, GPT-6 Sol lands at 2 dollars per million input tokens and 10 for output, against 4 and 20 for GPT-5.6 Sol. Luna drops to 10 cents for input and 50 for output, against 20 cents and 1.20 dollars for its predecessor. That's half the price, with better performance at the top.
For the past two years, architecting any LLM-backed feature started with the same uncomfortable question: does my budget cover running the good model inside this loop? And the answer, almost always, was to build a cascade: a small model that filters, a big model that solves, a router in the middle, and a pile of glue code nobody wanted to maintain. That router existed because the price delta between tiers justified the complexity.
When the mid tier costs half as much and the lightweight tier drops to 10 cents per million input tokens, the math changes. Routing complexity starts costing more —in development time, in bugs, in observability— than the billing difference it avoids.
What changes in practice
There are three concrete decisions I'd revisit this week if you work with this every day.
First: the two-tier router. If you have a cascade where the small model classifies and the big one executes, measure how much it actually saves you today. With the new prices, there are cases where sending everything to the mid tier costs about the same and takes a piece of infrastructure off your plate. Don't assume it: measure it against your real token distribution.
Second: long-running agentic work. Vercel describes Sol as suited for complex professional flows and sustained coding tasks where quality and room to iterate both matter. That second part —room to iterate— is what the price unlocks. An agent that can afford ten validation steps instead of three is a different agent.
Third: the operational details in Copilot. They're not minor, and it's worth having them straight before promising anything to the team:
- Sol is available on Copilot Pro+, Max, Business and Enterprise. Luna also reaches Pro, one step further down.
- Both are billed under usage-based billing; they don't come out of the plan's fixed pool.
- The rollout is gradual: if you don't see them in the model picker, your turn hasn't come yet.
- On Business and Enterprise, admins govern access through the model policy. With the automatic-enablement default, new models come in on their own unless someone turned off the global default or explicitly disabled the model.
That last point is the one that breaks teams. If your organization turned off the global default six months ago over a compliance argument nobody remembers anymore, the new models won't show up and people will assume it's the gradual rollout. Check the policy before opening a ticket.
| Criterion | GPT-6 Sol | GPT-6 Luna |
|---|---|---|
| Profile | Balanced, interactive and agentic | Lightweight and cheap |
| Intended use | Multi-step validation, sustained tasks | Small, fast, high-volume tasks |
| Input / output (USD per million) | 2 / 10 | 0.10 / 0.50 |
| Copilot plans | Pro+, Max, Business, Enterprise | Pro, Pro+, Max, Business, Enterprise |
When NOT to use it
Here's what the announcement won't tell you.
Don't migrate anything this week. The rollout is gradual and, by definition, not under your control. If you wire your pipeline to a model half your team still can't see in the picker, you're going to get bug reports that aren't bugs. Wait until it's evened out.
The communication improvements come with a cost. Vercel says Sol and Luna communicate more directly than their GPT-5.6 counterparts, with less jargon and fewer low-value details. That sounds great until you have parsers, evals or prompts that depend on the older verbose format. If your system extracts structure from the model's prose —and plenty of them do without admitting it— that change breaks things silently. Run your evals before touching the model in production.
The improvement figures come from the vendor. OpenAI claims these models make roughly half the errors of the GPT-5.6 variants, and that Sol beats Claude Fable 5.1 at a lower cost. There's no independent evaluation in the available material. These are marketing claims until you verify them against your own set of tasks. And the most interesting claim to verify is a different one: that they're less prone to making misleading statements about completed work in coding tasks. If that holds up, it matters far more than any benchmark, because that's exactly the failure mode that makes you lose trust in an agent.
Luna is not cheap Sol. It's a lightweight model for small tasks. Dropping it into a twenty-step agentic loop because the price tempts you is how you build a system that fails in hard-to-debug ways. The lightweight tier got cheaper; it didn't change category.
What I'd do today
Nothing in production. I'd open the model picker, throw Sol at the three tasks that hurt most this week and compare the output against what I use today, in the same context window. In parallel, I'd run the real numbers on what my current routing actually saves me at the new prices: if the number is small, the next refactor is deleting code, not adding models.
The underlying read: token price has stopped being the main constraint in most designs. What remains as a constraint is what it always was —knowing what to ask for, verifying what comes back, and having evals that catch when the new model behaves differently. Nobody makes that cheaper.