GPT-6 Sol and Luna: what OpenAI's cheaper API models change for developers

The important release this week is not a single new champion. It is a wider GPT-6 line with a smaller model aimed at high-volume production and a lower-priced option for routine agent work.

OpenAI released GPT-6 Sol and GPT-6 Luna on September 22, adding two lower-priced tiers below GPT-6 Astra. The launch matters less as a new benchmark crown than as a price signal: production teams can now route more routine model work below the flagship tier without jumping to a completely different provider.

What OpenAI actually launched

OpenAI describes Sol as a production model for coding, computer use and long-running agents. Its list rates are $3 input and $15 output per million tokens, with cached input at $0.30. OpenAI also lists Sol at $18 for cached input above 272K tokens, $6 for input above 272K, and $22 for output above 272K.

Luna is aimed at high-volume tasks such as classification, extraction and search. It lists at $0.20 input and $1.20 output per million tokens, cached input at $0.02, and separate long-context rates of $0.40 input, $6 cached input and $2.40 output above 272K tokens. Both models support a 1.05-million-token context window and 128K maximum output.

The structural point is simple: the GPT-6 family now has more than one price-performance choice. Astra remains the premium option, but teams no longer have to send every routine task to it.

Independent evidence says the gap is narrower than the headline price gap

Artificial Analysis tested both models after launch. Sol scored 57 on its Intelligence Index, placing it in fourth place rather than at the top. Luna scored 27, while a different “application” index in the same testing rated Luna 38. Those figures are snapshot measurements, not permanent rankings, but they are useful corrective pressure: cheap does not mean flagship-equivalent.

The same testing estimated that Sol’s output was about 7.2 tokens per second, faster than GPT-6 Astra and Claude Opus 5.5. That matters for interactive agents, where waiting time is user experience rather than an abstract benchmark. Luna, meanwhile, had a 28-second time to first token in the reported test, so its low token price should not be mistaken for low latency.

The useful cost comparison is not “$3 versus $10”

OpenAI’s launch material argues that Sol can be roughly 40% cheaper than Anthropic’s comparable model on simple workloads, and much cheaper on complex ones. VentureBeat reported developer estimates that ranged from 40% below Anthropic’s comparable offering to more than 90% below, depending on token mix, caching, reasoning effort and the model used for comparison.

Those ranges are the practical lesson. A lower per-token rate can disappear when a cheaper model makes more retries, emits longer answers, loses a tool-use task and forces a second pass, or is used without prompt caching. Conversely, a slightly more expensive model that completes a task in one call may be cheaper overall.

Here is a simple model:

• Tokens × the rate for your actual input/output mix
• + cached input tokens × the cache rate
• + retries, tool calls and any fallback model
• ÷ successful tasks completed = effective cost per successful task

Measure that number on a copy of real production traffic for a week. It is more informative than a generic per-million-token table.

Where Sol fits

Sol is the sensible first trial for code generation, tool-using workflows, computer interaction and agents that need a larger reasoning budget than Luna. OpenAI positions it for production software work, and Simon Willison’s hands-on test highlighted substantial improvements in “interacting with, and building, complex web applications,” with a terminal-based coding run completing in just over 15 minutes.

That result is encouraging but not a universal benchmark. Treat it as one developer’s workload, not proof that Sol will code your repository faster or more correctly. Before switching, test your own tasks: bug-fix success, test-suite pass rate, tool-call reliability, token use and total wall time.

Where Luna fits

Luna is the more consequential product for cost structure. At $0.20 input and $1.20 output per million tokens, it is cheap enough for high-volume extraction, routing, classification and search pipelines where a frontier model would be wasteful.

The practical pattern is a model cascade:

1. Use Luna first for bounded, easy-to-check work with strict output schemas.
2. Escalate to Sol or Astra only when validation fails, ambiguity is detected, or the task needs deeper planning.
3. Measure both success and escalation rates. A cheap first pass is valuable only if the total number of calls stays controlled.

This approach can reduce cost without pretending that Luna and Sol are interchangeable. It also makes failures easier to inspect: keep the original prompt, validation result, model version and reason for escalation.

Should you switch today?

Switch if your workload matches Sol’s or Luna’s intended use, you have a repeatable evaluation set, and the current cost is material. Start with a canary deployment, preserve the old model as a fallback, and compare successful-task cost rather than token cost alone.

Wait if your task depends on frontier-level reasoning, you cannot validate outputs automatically, or your prompt contains highly sensitive data and your governance review is not complete. The new price points will not remove those responsibilities.

Bottom line: OpenAI has widened the useful middle of its model line. The choice is no longer “premium model or cheap different provider.” It is now often a routing decision inside GPT-6 itself. The launch lowers the cost of useful AI, but only disciplined evaluation will show whether it lowers the cost of your finished work.

Prices and benchmark figures are standard published rates as of September 25, 2026 and can change without notice. Some outbound links may be affiliate links — see our disclosure. Found an error? Tell us and we'll correct it in public.