GPT-6 Sol and Luna: The Price of Choosing the Right Model

TL;DR: OpenAI released GPT-6 Sol and Luna on September 22. For standard API requests with at most 272,000 input tokens, Sol costs $2 per million input and $10 per million output tokens; Luna costs $0.10 and $0.50, while Astra costs $10 and $50.^[1][2] Those are 5-to-1 price steps from Astra to Sol and 20-to-1 from Sol to Luna, not measured quality ratios. Route by verified task outcome, then account for cache writes, tools and retries.

Cover: generated editorial artwork. Rail parcels directed toward three workshops illustrate a routing decision, not OpenAI's model architecture or a measured performance result.

The real story isn't that OpenAI now sells a smaller model. It is that the September 22 launch turns model selection into a visible unit-economics decision. Sol and Luna accept text and image input and produce text through the Responses and Chat Completions APIs. OpenAI positions Sol for complex coding and agentic workflows, Luna for focused work at volume, and Astra for the hardest end-to-end tasks.^[1][5]

The temptation is to set the cheapest model as the default and call the difference savings. That skips the expensive part: determining whether the work passed review. An answer that costs one-twentieth as much per token but requires a second attempt, a stronger-model rescue and human repair may be the costlier product. These are risks to test, not measured outcomes of this launch.

The Price Ladder: Fivefold and Twentyfold Steps

OpenAI's published Standard rates are per million text tokens. Under the short-context schedule, Astra is $10 input, $1 cached input, $12.50 cache write and $50 output. Sol is $2, $0.20, $2.50 and $10. Luna is $0.10, $0.01, $0.125 and $0.50 respectively.^[2] The fivefold and twentyfold ratios apply to those listed token rates. They say nothing by themselves about answer correctness or task completion.

Consider an illustrative job with 100,000 uncached input tokens and 10,000 billed output tokens, no tools, retries or regional uplift. Applying OpenAI's listed rates gives Astra $1.50, Sol $0.30 and Luna $0.015. That is arithmetic on identical token counts, not a prediction that all three will generate the same number of reasoning tokens, finish the same task or deliver the same quality. Output token use can change with model and effort.

Above 272,000 input tokens, the published long-context schedule doubles input and cache rates and raises output rates by 50% for the full request. In Standard processing, Sol then lists $4 input and $15 output; Luna lists $0.20 and $0.75. A job at 300,000 input tokens does not pay the lower rate on its first 272,000.^[2]

The Routing Rule: Begin with the Failure Cost

Here's the useful division. Try Luna first on bounded classification, extraction, tagging and short transformations where a schema or a human sample can catch errors. Try Sol on repository changes, multi-step analysis and agents that must choose and use tools. Reserve Astra for tasks where a failed intermediate judgment would invalidate an expensive chain, or where a representative evaluation shows a meaningful lift. This is an editorial starting policy, not OpenAI's guarantee about any workload.

Let's be clear: neither a model description nor a price card is an evaluation. Build a held-out set from real work, keep instructions and tool access comparable, and score accepted outcomes. Track total input, cached input, cache writes, output and tool charges across every attempt. Include elapsed time, p95 latency, escalation frequency and human correction minutes. OpenAI's agent-evaluation guidance recommends traces, graders and repeatable datasets for checking routing changes.^[8]

Use a narrow escalation trigger: schema failure, failed test, missing citation or a low-confidence classification. The router should record why it escalated. If Luna fails a check and Sol completes the task, count both calls in Sol's accepted-result cost. If Sol still fails, evaluate Astra against the same acceptance criterion. Stop when the result passes; a premium model should not become a ritual final pass.

The Cache: Cheap Reads Still Need a Paid Write

What's often overlooked is that the cached-input line is not the whole caching bill. OpenAI charges cache writes at 1.25 times ordinary input rates and cache reads at one-tenth. For Sol, that is $2.50 per million written and $0.20 per million read; for Luna, $0.125 and $0.01. A stable prefix used twice costs 1.35 times one ordinary input pass in OpenAI's example, compared with twice without caching. Cache-write charges replace the ordinary rate for those tokens; they are not added on top.^[2][6]

That math favors stable instructions, schemas and reference material that are actually reused. OpenAI's minimum cacheable prompt length for GPT-5.6 and later is 1,024 tokens, and the default minimum lifetime is 30 minutes after the latest write or reuse. A session does not guarantee a hit. Check usage fields before counting any saving.^[6]

Batch processing offers another deliberate trade. OpenAI lists a 50% discount and a completion window of up to 24 hours for asynchronous jobs. It fits back-office classification or evaluations with a deadline tomorrow, not an interactive answer due now.^[7] A $0.015 illustrative Luna request would be $0.0075 at half the Standard token rate under the same token assumptions, before any other charges. That is a price illustration, not a measured Batch bill.

The API Boundary: Cheap Tokens Are Not Cheap Agents

Both new models support none, low, medium, high, xhigh and max reasoning effort; medium is the documented default. For built-in tools and tool-using reasoning, OpenAI directs developers to Responses. Chat Completions function calling on Sol and Luna is supported only at reasoning_effort: "none".^[3][4] That matters when migrating an agent: changing only the model ID may change the tool contract you intended to use.

Tool calls can carry separate fees. A web-search or computer-use workflow also has more chances to retry or consume context. The published rate card says regional processing can add 10%, and EU data residency for Sol and Luna is available only with Standard processing.^[2][9] Build the estimate from the actual endpoint, processing tier and geography. Do not apply a US-dollar API rate to a subscription allowance or claim it is a European customer offer.

For interactive Codex users, our Astra usage guide examines the separate problem of working within subscription allowances. Its advice on controlling repeated context is useful here, but these API token prices should not be used to price a Codex subscription.

The Business Test: Pay for Accepted Work

The uncomfortable truth is that a 100-to-1 Astra-to-Luna input and output price gap creates room for two mistakes. One is paying frontier rates for deterministic work. The other is forcing low-cost inference through work it cannot reliably finish. Neither can be settled by a vendor benchmark without matching the task, tools and acceptance test.

Run the first routing trial on three queues: a checkable high-volume queue, a multi-step queue and a high-consequence queue. For each, report accepted jobs per 1,000 attempts, dollars per accepted job and p95 completion time. Break out failures rescued by another model. This exposes whether the lower token price became a lower operating cost. It also gives teams a reason to change the router as models or prices change.

Sol and Luna make GPT-6 more accessible to software builders. Their lasting effect depends on whether teams treat model choice as an empirical product decision. The winning tier is the one that finishes the work at the lowest verified total cost.

Last updated: September 26, 2026