By the time this story was selected, a Hacker News submission linking to OpenAI's GPT-6 Sol and Luna launch had reached 1,165 points and 600 comments. The less obvious number is 20: Sol costs 20 times as much as Luna per input and output token, even though both models expose a 1.05-million-token context window and a 128,000-token output limit. For developers, this release turns model selection into a routing decision inside each product.
OpenAI released both models on September 22 as lower-cost members of the GPT-6 family. Standard API pricing is $2 per million input tokens and $10 per million output tokens for Sol, compared with $0.10 and $0.50 for Luna. The official pricing table puts Astra at $10 and $50, so the family now spans a 100-fold difference between Luna and Astra at either end of a standard request.
One interface, three very different bills
The matching context limits make the models look interchangeable in an integration checklist. OpenAI's Sol documentation and Luna documentation list the same text and image inputs, streaming, function calling, structured outputs, and Responses API tools. Web search, file search, code interpreter, hosted shell, computer use, MCP, and tool search are available on both. Neither model accepts audio or video input, and neither supports fine-tuning.
The intended jobs differ. OpenAI describes Sol as a model for complex coding and agent workflows, while Luna is aimed at focused work performed at high volume. That distinction matters more than the shared feature list. A support classifier and a repository-wide migration may call the same tools and fit inside the same context window, yet they do not demand the same depth of reasoning.
The simple token table also hides a long-context step. For prompts above 272,000 input tokens, both model pages say the entire request is charged at twice the input and cache rates and 1.5 times the output rate. A Sol request does not stay at $2 and $10 once it crosses that line; its effective rates become $4 and $15. Luna moves to $0.20 and $0.75. Teams loading a large repository or document set into every turn need to price the full request at the higher band.
Processing mode adds another layer. Batch and Flex cost half the standard rate, while Fast mode costs twice as much. Regional processing adds 10% where available, and EU data residency for Sol and Luna is limited to Standard processing. OpenAI's pricing documentation therefore leaves no single universal number for either model. The headline 20x ratio holds within the same processing and context tier.
OpenAI's tests draw a boundary, not a guarantee
OpenAI's launch data gives some shape to the capability gap. On DeepSWE 1.1, the company reports 68.8% for Sol at maximum reasoning effort and 66.6% for Luna at maximum effort. It compares the latter with medium-effort Claude Opus 5 and Fable 5, while claiming Luna cost 93% less per task than Opus and 96% less than Fable in those runs. These are vendor-reported comparisons, and the launch page says competitor scores came from public reports rather than one common production setup.
The gap changes with the task. On OSWorld 2.0 offline, OpenAI reports 60.5% for Sol at xhigh effort, close to the 60.3% it lists for Claude Opus 5 at medium effort. Luna at maximum effort reportedly beat GPT-5.6 Sol at medium effort for one tenth of the cost per task. On OpenAI's internal factuality evaluation, Sol made about half as many errors as GPT-5.6 Sol, while high-effort Luna matched the older Sol at about one hundredth of its cost.
Those figures do not establish that Luna is a 20x bargain for every workload. Reasoning effort changes how a model approaches a task, and total cost depends on the tokens a run consumes rather than the posted rate alone. OpenAI also says its factuality set was built from conversations in which users had flagged an earlier error. The company warns that these difficult prompts are not representative of ordinary use. A production router needs its own accepted-answer rate, retry count, latency, and human correction cost.
Astra still has a defined place above the two cheaper models. OpenAI's model guide recommends Astra for its highest level of capability, Sol for demanding reasoning, and Luna for repeatable work at scale. Astra lacks the none reasoning setting that Sol and Luna support. All three can reach max, which gives an application room to raise effort before it jumps to a more expensive model.
Caching can outweigh the sticker price
Long-running agents repeatedly send instructions, tool definitions, and prior context. OpenAI's updated caching system gives eligible shared prefixes a reuse window of 30 minutes and discounts cached input reads by 90%. Under standard rates, cached input costs $0.20 per million tokens on Sol and $0.01 on Luna. Cache writes cost $2.50 and $0.125 respectively, according to the two model pages.
The operational changes are more interesting than the discount. OpenAI's caching announcement introduces a dashboard for hit rates, diagnostics that identify why a request missed, and explicit breakpoints for choosing the reusable prefix. Developers can also change reasoning effort through a configuration update without invalidating earlier cached context. Keeping tool definitions stable while changing which tools are allowed can preserve the same prefix.
GitHub told OpenAI that these changes cut the share of Copilot prompt tokens requiring fresh processing by more than 50% across billions of requests over several months. That is a named customer result, not a general performance promise. It does show why routing and caching belong in the same design. Sending a routine turn to Luna saves little if the application rebuilds and rewrites a large prefix on every request. A well-reused Sol prefix can also cost less than a poorly cached integration built around a lower posted rate.
The release therefore gives teams two independent controls. They can choose how much reasoning a turn receives, then choose which model handles it. OpenAI's guidance allows reasoning effort to range from none through max on both models. A practical router might begin a repetitive extraction on Luna with low effort, retry a failed validation at higher effort, and send a genuinely difficult case to Sol. That sequence is an engineering hypothesis until it survives a team's own evaluations; OpenAI does not publish one routing policy that fits every application.
The API is shared, but migration still needs tests
Both model IDs work through the Responses and Chat Completions APIs. There is one important limit in the official GPT-6 guidance: Chat Completions supports function calling on Sol and Luna only when reasoning_effort is set to none. Applications that need reasoning with built-in tools should use the Responses API. When reasoning is enabled, the guide also tells developers to remove sampling controls such as temperature and top_p.
Rate limits may affect routing before model quality does. At API tier 1, Sol's page lists 500 requests and 500,000 tokens per minute. Luna has the same limits at that tier, then grows much faster at higher tiers: its published tier 5 allowance is 180 million tokens per minute. Sol's tier 5 allowance is 40 million. That capacity split fits Luna's high-volume role, though an organization's actual tier still sets the ceiling.
Access is broader than Astra's initial rollout. OpenAI says Sol and Luna are available in ChatGPT Work and Codex for Plus, Pro, Business, Enterprise, and Edu users, with Luna also available to Free and Go users in the desktop app. At launch, the models were not yet available in regular Chat. API users can call gpt-6-sol and gpt-6-luna directly.
The next useful evidence will come from task-level logs. Teams can replay a sample of real traces against Luna, Sol, and their current model while preserving the same prompt prefix and tools. OpenAI's published rates make it possible to record the full bill after retries, cache writes, and long-context pricing. The 1,165-point launch shows that developers are paying attention. Those routing logs will show whether the 20x ladder saves money.