GPT-6 Sol and Luna: Frontier AI at a Lower Cost

Picture a coding agent working through a bug report at 2 a.m. It reads a repository, searches documentation, edits several files, runs tests, notices a failure, and tries again. One response may be cheap; a long chain of tool calls can become the bill. That is the practical problem GPT-6 Sol and GPT-6 Luna are designed to address: not only how capable an AI model is, but how much useful work it can complete for each dollar.

OpenAI's GPT-6 family now has three clear positions. GPT-6 Astra is the flagship for the hardest multi-step work. GPT-6 Sol is the balance point for serious coding, professional tasks, and agentic workflows—software that can plan, call tools, inspect results, and continue. GPT-6 Luna is tuned for focused, repeatable, high-volume work. The important detail is that Sol and Luna are not presented as unrelated lightweight models; OpenAI says they carry over advances in reasoning, factuality, coding, computer use, and alignment from the Astra generation.

The bill is measured in tokens

A token is a small piece of text processed by a model. Input tokens are what your application sends; output tokens are what the model generates. API pricing is usually quoted per one million tokens, so the number on a pricing page can look remote until an agent starts repeating the same work hundreds of times.

At these listed rates, one million input tokens plus one million output tokens would cost about $60 on Astra, $12 on Sol, or $0.60 on Luna, before caching and other charges. That is not a typical single request. It is a useful way to see why model choice matters: lower prices give a development team room to retry, compare prompts, and let an agent take another pass instead of stopping at the first imperfect answer.

Reasoning is a dial

GPT-6 Sol and Luna expose a reasoning.effort setting. Reasoning effort tells the model how much work to spend thinking through a request. Supported levels can include none, low, medium, high, xhigh, and max; higher effort generally favors harder problems at the cost of more time and tokens.

A small Python request might look like this:

from openai import OpenAI

client = OpenAI

response = client.responses.create(
 model='gpt-6-sol',
 reasoning={'effort': 'high'},
 input='Review this database migration plan. List risks, missing rollback steps, and tests to add.',
)

print(response.output_text)

The model name and effort level do different jobs. gpt-6-sol chooses the capability-and-cost tier; high asks that tier to spend more effort on the task. For a short classification or extraction pass, Luna at none may be a better fit. For a migration review, a difficult code change, or a workflow with several dependent steps, Sol at high effort is a more sensible starting point. The tricky part is that more reasoning is not automatically better when the task is routine.

Why prompt caching changes the math

Long-running agents repeat context. They may send the same system instructions, tool definitions, coding standards, and repository notes with every turn, followed by a new user request. Prompt caching stores a matching beginning of that prompt so the service does not have to process the reusable material from scratch each time.

OpenAI says GPT-6 cached input-token reads receive a 90% discount. A cache hit depends on the prefix matching, so stable instructions should come first and changing task details should come later. Editing an earlier tool schema or rewriting the system prompt can break reuse. GPT-6 also supports changing reasoning effort and tool availability in supported flows without rewriting the earlier cached prefix, which is useful when an agent moves from quick inspection to deeper analysis.

Performance is about completed work

The release focuses on more than price. On AutomationBench, which tests end-to-end business workflows across 47 tools, GPT-6 Sol at xhigh effort scored 33.2% at $0.27 per task. Claude Opus 5 at max effort scored 26.9% while costing 11.1 times more in the comparison. Those numbers do not mean every Sol response wins; they show why cost per successful workflow can be more informative than a model's sticker price.

The same pattern appears in software engineering evaluations. On DeepSWE, GPT-6 Sol at max effort scored 68.8%, close to Claude Fable 5's 69.9% high-effort result at about 80% lower cost per task. GPT-6 Luna reached 66.6% at max effort, comparable to medium-effort results from the competing models, while costing 93% less than Opus 5 and 96% less than Fable 5 in those comparisons. On OSWorld, a computer-use benchmark, Sol at xhigh scored 60.5% versus 60.3% for Claude Opus 5 at medium effort, again at roughly 80% lower cost per task.

Factuality also matters because a fast wrong answer creates rework. OpenAI reports that Sol makes about half as many mistakes as its predecessor on an internal evaluation built from conversations where users had flagged factual errors. Luna improves as well, matching GPT-5.6 Sol at higher effort for about a hundredth the cost in that evaluation. The test deliberately concentrates on error-inducing conversations, so it is better read as a stress test than as a prediction of ordinary chat.

The models are also meant to communicate more cleanly: less jargon, fewer odd turns of phrase, fewer low-value details, and somewhat shorter answers. That sounds cosmetic until an agent is producing hundreds of notes, code reviews, or status updates. Cleaner output reduces the amount of text a person has to inspect.

Choosing between Astra, Sol, and Luna

A practical starting point looks like this:

This is a routing decision, meaning your application sends different tasks to different models instead of treating one model as the answer to everything. Track success rate, retries, latency, human corrections, and total cost per completed task. A cheaper model that needs three repair attempts may not be cheaper; a slightly slower model that finishes in one pass often is.

For API builders, the model IDs are gpt-6-sol and gpt-6-luna. The current catalog lists both with a 1.05-million-token context window and a 128,000-token maximum output, along with functions, web search, file search, and computer use. A context window is the amount of conversation, instructions, and reference material a model can consider in one request, which makes these tiers suitable for much larger workflows than a short prompt-and-answer demo.

Benchmark scores are useful maps, not guarantees. Your own logs will reveal whether Luna can handle the routine 80% of a workload, whether Sol should take the difficult remainder, and when Astra's extra capability pays for itself. That is the larger shift behind GPT-6 Sol and Luna: advanced AI becomes less of a single expensive choice and more of an engineering system built around matching effort to the work.