On September 22, OpenAI released two new models, GPT-6 Sol and GPT-6 Luna, both built on the architecture behind GPT-6 Astra, which launched earlier in September. Rather than pushing the ceiling on capability, OpenAI positioned this release around cost: both models land at roughly half the price of what they replace. In its announcement, OpenAI says they bring "much of [Astra's] strengths into faster and more affordable models."
That framing matters for anyone tracking AI spend. For the past year, the pattern in frontier model pricing was fairly simple: better model, higher price. Sol and Luna break that pattern by splitting GPT-6 into tiers, so teams can match model capability to task complexity instead of paying flagship rates for every call, a shift we've also written about in Token-Based Pricing for AI Models Explained.
GPT-6 Sol is positioned for complex, multi-step work: coding, agentic tasks, and reasoning-heavy jobs where accuracy on hard problems matters more than raw throughput.
GPT-6 Luna is built for high-volume, lower-complexity work: summarization, extraction, classification, and Q&A, the kind of traffic where cost per call matters more than squeezing out the last few points of accuracy.
Both models share the same context window and output ceiling, so the choice between them comes down to the shape of the workload, not what they can technically handle.
| Input | Output | Cached Input | Context Window | Max Output | |
|---|---|---|---|---|---|
| GPT-6 Sol | $2.00 | $10.00 | $0.20 | 1,050,000 tokens | 128,000 tokens |
| GPT-6 Luna | $0.10 | $0.50 | $0.01 | 1,050,000 tokens | 128,000 tokens |
Batch API pricing (for asynchronous, non-latency-sensitive jobs) cuts both further:
| Batch Input | Batch Output | Batch Cached Input | |
|---|---|---|---|
| GPT-6 Sol | $1.00 | $5.00 | $0.10 |
| GPT-6 Luna | $0.05 | $0.25 | $0.005 |
Cached input reads get a 90% discount off the standard input rate on both models, which matters a lot for agentic workloads that repeatedly reuse the same context window. Full rate details are on OpenAI's official pricing page.
| Previous Price (Input/Output) | New Price (Input/Output) | Change | |
|---|---|---|---|
| Sol (was GPT-5.6 Sol) | $4.00 / $20.00 | $2.00 / $10.00 | 50% lower, both directions |
| Luna (was GPT-5.6 Luna) | $0.20 / $1.20 | $0.10 / $0.50 | 50% lower input, 58% lower output |
For the full tier breakdown at launch, see our post on GPT-5.6 Pricing 2026: Sol, Terra and Luna Tiers Explained.
| Model | Input (per 1M) | Output (per 1M) | Context Window |
|---|---|---|---|
| GPT-6 Sol | $2.00 | $10.00 | 1,050,000 |
| GPT-6 Luna | $0.10 | $0.50 | 1,050,000 |
| Claude Opus 5.5 | $4.00 | $20.00 | not specified in our sources |
| Grok 4.7 (short context) | $2.00 | $6.00 | 500,000 |
| Grok 4.7 (200K+ context) | $4.00 | $12.00 | 500,000 |
| Gemini 3.1 Pro (≤200K) | $2.00 | $12.00 | not specified in our sources |
| Gemini 3.1 Pro (200K+) | $4.00 | $18.00 | not specified in our sources |
Sol's input price matches Grok 4.7 and Gemini 3.1 Pro at the short-context tier, but it undercuts all three on output, and it's half of Claude Opus 5.5's rate on both sides. Luna isn't really in the same conversation. At $0.10/$0.50, it's priced well below every other frontier-adjacent model on this list, which is the point: it's built for volume, not for going head to head with flagship reasoning models.
For a deeper cross-vendor look, see our OpenAI vs Anthropic API Pricing Comparison, Gemini Pricing in 2026, and our broader AI Model Cost Breakdowns: The Complete 2026 Comparison Guide.
Pricing only tells half the story. A few data points worth knowing if you're deciding which tier to route to:
| Benchmark | GPT-6 Sol | GPT-6 Luna | Notable comparison |
|---|---|---|---|
| AutomationBench (agentic reasoning) | 33.2% at $0.27/task | 20.7% at $0.037/task | Claude Opus 5.5 scored 40.0% on the same benchmark |
| DeepSWE v1.1 (coding) | 68.8% at $2.74/task | 66.6% at $0.22/task | — |
| Agents' Last Exam | 56.4% at $2.93/task | 50.9% at $0.15/task | — |
The gap between Sol and Luna's accuracy is real, especially on agentic reasoning, but so is the cost gap. Luna running the same task class at roughly a tenth of Sol's per-task cost is exactly why a tiering strategy only works if you're actually routing the right workload to the right tier, not defaulting everything to the smartest available model out of habit.
Benchmark cost-per-task is useful, but a session-level example makes the difference easier to feel. For a typical agent session (2 million input tokens at a 90% cache hit rate, plus 150,000 output tokens):
| Model | Cost per Session |
|---|---|
| GPT-6 Luna | $0.11 |
| GPT-6 Sol | $2.26 |
| Claude Opus 5.5 | $4.16 |
| Claude Fable 5.1 | $9.95 |
That's roughly a 40x spread between the cheapest and most expensive option for what could be functionally the same workload, depending on how much reasoning depth the task actually needs.
Route to Sol for anything where a wrong answer is expensive: coding tasks, multi-step agentic workflows, and reasoning chains where you're willing to pay more per call to reduce retries and errors downstream.
Route to Luna for high-volume, lower-stakes work: ticket triage, first-pass summarization, data extraction, and routing logic where a slightly lower accuracy ceiling is an acceptable trade for a fraction of the cost.
Plenty of real pipelines use both: Luna as a cheap first pass or classifier, with only the harder or ambiguous cases escalated to Sol. That pattern is becoming more common as more labs split their lineups into tiers, and it's exactly where cost tracking tends to get messy if you're not watching it.
Splitting a model family into tiers is good news for your bill, but only if usage is actually going where it's supposed to. A few practices worth putting in place as GPT-6 Sol and Luna traffic ramps up:
Allocate spend to teams and products. With two tiers now live under one model family, it's easy to lose track of which team or feature is driving which cost. Finout's Virtual Tagging can allocate OpenAI spend to business dimensions like team, product, or customer without requiring code changes on your end. See also Tracking AI Costs Per Customer and Per Feature in 2026.
Set anomaly alerts on token usage. A workflow that quietly starts routing to Sol instead of Luna, or a caching miss that spikes input costs, can go unnoticed for weeks in a raw OpenAI invoice. Finout's anomaly detection flags unusual spend patterns before they show up as a surprise on the monthly bill. More on this in How to Monitor AI Costs in Real Time.
Route workloads to the cheapest viable tier. The benchmark and session-cost numbers above only pay off if routing decisions are actually being made with cost in mind. Visibility into what each tier costs for your actual traffic patterns, not just published rates, is what makes that decision possible.
Forecast spend as agentic traffic scales. Agentic workloads tend to grow non-linearly once a workflow proves out, and token consumption follows. Finout's Financial Plans help model that growth ahead of time instead of reacting to it after the invoice arrives.
For a broader framework, see FinOps for AI: The Definitive Overview and AI FinOps: 7 Steps to Manage and Optimize AI Costs.
Most teams aren't running GPT-6 Sol and Luna in isolation. They're also paying for Claude, Grok, Gemini, or some combination, often across API, ChatGPT Work seats, and Codex all at once. Finout's MegaBill consolidates spend across all of these into one view, so the question isn't "what did OpenAI charge us this month" in isolation, it's "what is our total AI spend, and is it going to the tier and vendor that makes sense for each workload."
We've written more about this pattern in Why Your AI Cost Stack Is Becoming Another Reconciliation Project and rounded up the tooling landscape in Best FinOps Tools for Managing AI Costs in 2026.