Industry Perspectives

GPT-6 Sol and Luna: What OpenAI Changed and What to Do About It

Two new GPT-6 tiers cut the cost of a task rather than raise the ceiling. Here is what changed, what the published benchmarks do not show, and which work is worth moving first. Atoms gives you a place to test the build path.

Start building for free
12 min readPublished Updated
OpenAI GPT-6 Sol and Luna launch artwork
On this page

OpenAI released GPT-6 Sol and GPT-6 Luna on September 22, 2026, nineteen days after GPT-6 Astra. The announcement is not about a new intelligence ceiling. It is about moving a generation of capability down the price list, and about caching changes that affect anyone running agents at volume. Astra remains the best model in the family, and OpenAI says so in the post itself.

This article separates what OpenAI published from what third parties added and from what nobody has measured yet. That distinction matters, because most launch coverage reads the vendor's benchmark slide as a verdict on model quality.

What OpenAI shipped on September 22

Sol and Luna were trained with methods similar to Astra's, according to the announcement, which is the vendor's way of saying the two smaller models inherit advances in professional work, factuality, coding, computer use, and alignment rather than being separate research branches. OpenAI frames the pair as a way to distribute the benefits of that generation by advancing cost efficiency.

The pricing move is the headline: API prices for both models dropped 50% against their GPT-5.6 promotional pricing. Sol goes from $4 to $2 per million input tokens and from $20 to $10 per million output tokens. Luna goes from $0.20 to $0.10 on input and from $1.20 to $0.50 on output. OpenAI attributes the cut to caching and inference improvements and says it is passing the savings through.

Availability started the same day: ChatGPT Work and Codex for Plus, Pro, Business, Enterprise, and Edu users, with GPT-6 Luna reaching Free and Go users in the desktop app. The models are not in the Chat surface yet, and OpenAI said it would roll them out gradually through the day.

Sol and Luna do different jobs

GPT-6 Sol is the model for difficult work tasks, with higher usage limits and a lower price than Astra, and OpenAI positions it against similarly priced competitor models rather than against its own flagship. On the automation and professional-work benchmarks it is the tier that takes multi-step tasks: workflows across many tools, long investigations, changes that touch several files.

GPT-6 Luna is the volume tier. It is cheaper by an order of magnitude on input tokens, and it is the model OpenAI expects to see behind high-frequency calls: summarization, extraction, classification, routine rewriting. Third-party coverage frames the split the same way, with Sol carrying more reasoning capability and Luna optimized for speed and volume.

Both inherit the communication style OpenAI introduced with Astra: more clarity, less jargon, fewer odd turns of phrase, fewer low-value details, and slightly shorter answers without losing substance. OpenAI says the difference is most noticeable in technical and coding conversations, and publishes a side-by-side where the newer model states what it did and did not check instead of narrating its own implementation details. That is a vendor description, not an independently tested claim.

The 50% price cut and the three lines it does not cover

GPT-6 Sol pricing and GPT-6 Luna pricing are simple at the top level and more complicated two lines down.

Model Input per 1M tokens Output per 1M tokens Compared with
GPT-6 Sol $2 $10 GPT-5.6 Sol promotional: $4 and $20
GPT-6 Luna $0.10 $0.50 GPT-5.6 Luna: $0.20 and $1.20

Three details change what a real bill looks like. First, the baseline for the 50% is promotional pricing, not list price. A third-party breakdown of OpenAI's pricing pages notes that the GPT-5.6 promotion is guaranteed only at least through November 21, 2026, and that OpenAI has not published what GPT-5.6 Sol costs after that. Second, long prompts carry a surcharge. The same breakdown reports that above 272,000 input tokens the whole request bills at twice the input rate and 1.5 times the output rate. Third, writing to the cache is not free: cache writes bill above the normal input rate, while cache reads bill at 10%. A cached prefix pays for itself from the second request that reuses it.

That last point is the one to model before celebrating. Agent workloads spend most of their tokens on context they reuse, so the effective price of a run depends on hit rates, not only on the per-token line. OpenAI's caching section is where the practical savings are explained.

Caching and effort: what changes for agent pipelines

OpenAI says caching for GPT-6 now achieves higher hit rates by default and that cached input-token reads carry a 90% discount. Two of the changes matter more than the discount itself.

Raising or lowering reasoning effort mid-conversation no longer breaks the cache. Neither does enabling or disabling tools as an agent's needs change. Before this, a pipeline that escalated effort on a hard turn, or that switched a tool set on for a subtask, paid to reprocess context it had already sent. Developers also get explicit breakpoints to choose where a cached prefix ends, plus a dashboard and a diagnostics tool that explain why a cache hit was missed.

OpenAI adds a partner figure: GitHub reports that these improvements cut the share of prompt tokens requiring fresh processing by more than 50%. That is a caching result rather than a model-quality result, so treat it as a signal about how much context reuse has improved, not as an independent benchmark.

One integration detail from the model pages has bitten teams already. Third-party summaries of the model documentation report that Chat Completions supports function calling only when reasoning effort is set to none, and that built-in tools and function calling are meant to run on the Responses API. If your agent calls tools through Chat Completions at medium or high effort, swapping the model id is not a drop-in change.

What the benchmark numbers support, and what they leave out

The GPT-6 Sol benchmarks that OpenAI published are cost-per-task claims from a vendor harness. Read them that way and they hold together; read them as a ranking and they do not.

Benchmark What it measures OpenAI's published result
AutomationBench 1.0.6 Business workflows across 47 tools Sol at xhigh scores 33.2% at $0.27 per task; Claude Opus 5 at max scores 26.9% at 11.1 times that cost
Agents' Last Exam V1 Long-horizon professional tasks across 55 sub-industries Sol at max scores 56.4%, above Opus 5's highest score, at 60% lower cost per task
DeepSWE v1.1 Software engineering in real codebases Sol at max scores 68.8% against Claude Fable 5 at xhigh with 69.9%, at roughly 80% lower cost per task; Luna at max scores 66.6%
OSWorld 2.0 offline Computer use Sol at xhigh scores 60.5% against Opus 5 at medium with 60.3%, at roughly 80% lower cost per task
FrontierCode 1.1 Main Merge-ready code Sol matches Claude Fable 5.1 at xhigh at much lower cost; no score published

Three limitations travel with that table. Competitor scores were taken from publicly available reports rather than rerun by OpenAI. Scores for Claude Fable 5 were substituted where Fable 5.1 results were unavailable, and on AutomationBench the Fable 5.1 cost figure omits Opus 5 fallback runs that OpenAI says occurred on about 40% of tasks. Evaluations ran in OpenAI's research environment or through its API, which can differ from production ChatGPT because of system prompts and available tools.

A third party that read the values behind OpenAI's interactive charts found two more things worth knowing. GPT-5.6 Sol still holds the top score on two of the coding and computer-use charts, so the newer model's advantage there is cost rather than capability. And the FrontierCode comparison runs against Fable 5.1 at xhigh, which is that model's lowest setting on the chart. Those figures come from a third party's reading of chart data that OpenAI did not publish as a table, so treat them as an outside check on the vendor's framing rather than as independent testing.

Factuality and alignment results

On OpenAI's internal factuality evaluation, which is built from de-identified ChatGPT conversations where users had flagged a factual error, GPT-6 Sol makes about half as many mistakes as its predecessor and approaches Astra-level reliability at a much lower price. Luna improves as well: at higher effort levels it matches GPT-5.6 Sol at about a hundredth of the cost. The sample is skewed by construction, since those conversations were selected precisely because they caused errors, and OpenAI notes that factual errors are rarer in typical use.

On alignment, OpenAI reports that both models improve over their GPT-5.6 counterparts, including lower rates of misleading claims about their own coding work. The evaluations deliberately test adversarial situations and do not measure failure rates in normal use. Third-party write-ups of the chart data quote per-test failure rates for each model, including stress tests around warning circumvention and unauthorized agent interaction, where the new models are not uniformly better than Astra. Those percentages come from reading chart values, so the honest summary is directional: the trend is up, the absolute numbers in normal use are unknown.

Where you can use the models, and what to change first

The GPT-6 Sol API is available under the model id gpt-6-sol, and Luna under gpt-6-luna. In ChatGPT, both arrive through ChatGPT Work and Codex rather than Chat, and Enterprise and Edu administrators may need to enable them. The gradual rollout means two people on the same plan can see different model lists on the same day.

The first engineering check is your API surface, not the model id. If you call tools through Chat Completions with reasoning switched on, plan the move to the Responses API before you plan the migration. The second check is your effort setting. OpenAI publishes each of these benchmark results at a named reasoning setting, so a score belongs to that setting rather than to the model as a whole. Run your own task set at more than one level before you commit, because the highest setting is not automatically the best value.

The third check is the one most teams skip: bill per completed task, not per token. A model that finishes in one pass at a higher rate can be cheaper than a model that needs a retry, and the caching changes shift that arithmetic further in favor of workloads with stable prefixes.

Limits worth knowing before you switch

OpenAI's own post does not publish a context window or an output limit for the two models. Third-party summaries list 1,050,000 tokens of context and 128,000 tokens of maximum output for both, plus reasoning effort levels from none through max, but those figures come from provider documentation pages that this article did not verify. Check them against the model pages before you size a context budget.

No confidence intervals accompany the benchmark table, no third party had published independent results at launch, and the competing model released the same evening is absent from every chart. If your choice is between Sol and that competitor, your own evaluation is currently the only comparison available.

Building on the new models with Atoms

Choosing a model tier is separate from shipping the product that uses it. Atoms takes a natural-language brief and coordinates AI agents across planning, building, research, and growth to produce a working website or web application, including generated images and video placed directly into the page, plus 3D and game experiences and backend capabilities such as persistent data, authentication, and deployment.

The model pages on Atoms list what is available to build with, including the GPT-5.6 Sol page for the tier these two models succeed, so the pricing and effort decisions above connect to something you can run rather than to a spreadsheet. Production settings, integrations, payments, accessibility, security, and performance still need review before launch, which is true of any generated build and worth planning for.

Three builds from the same library show the shape of the work these tiers are bought for.

Terminal 3D Game Engine A browser 3D dungeon explorer that renders ray-cast scenes in ASCII characters, the kind of multi-file build that benefits from a model that can hold a whole codebase in context.

tuftcraft A Minecraft-style block-building prototype delivered as static HTML, an example of a long single-pass generation that has to stay internally consistent.

Sportswear E-commerce Website A storefront for a performance apparel brand, closer to the high-volume content work that a cheaper tier handles without supervision.

None of these were built with GPT-6 Sol or Luna; they show the class of work the tiers are chosen for.

Conclusion

The launch changes your cost per task more than it changes your ceiling, and the ceiling still belongs to Astra. Pick one task set you already run in production, run it on Sol at high or xhigh effort and on Luna at maximum, and compare what a completed task costs rather than what a million tokens costs. Move the tasks that come out cheaper, leave the rest where they are, and check your tool-calling path before you touch the model id.

If you would rather test the new tiers inside a build instead of through an API client, start from the model pages on Atoms and describe the product you want.

A little more clarity

Frequently asked questions

01Q1: When did GPT-6 Sol and GPT-6 Luna launch?

OpenAI released both models on September 22, 2026, and said availability would roll out gradually through the day. They followed GPT-6 Astra, which arrived earlier in September 2026.

02Q2: How much do GPT-6 Sol and GPT-6 Luna cost?

Sol is $2 per million input tokens and $10 per million output tokens. Luna is $0.10 per million input tokens and $0.50 per million output tokens. Both figures are half of the GPT-5.6 promotional rates for the equivalent tiers, and both exclude surcharges such as cache writes and long-context pricing above 272,000 input tokens.

03Q3: What is the difference between GPT-6 Sol and GPT-6 Luna?

Sol is the higher-effort model for difficult, multi-step work such as codebase changes and agent runs. Luna trades peak reasoning for price and throughput, and it is the tier that fits summarization, extraction, and other repeated calls. Both were trained with methods similar to Astra's.

04Q4: Are GPT-6 Sol and GPT-6 Luna better than GPT-6 Astra?

Not on capability. OpenAI states that Astra continues to be its best model across the board. Sol and Luna are means of reaching a GPT-6 generation result at a lower cost per task, and on some benchmarks the previous generation still scores higher at a higher price.

05Q5: Can I use GPT-6 Sol in ChatGPT?

Yes, through ChatGPT Work and Codex on Plus, Pro, Business, Enterprise, and Edu plans, with administrator enablement on the last two. Free and Go users get GPT-6 Luna in the desktop app. Neither model is in the Chat surface yet, and the rollout is gradual.

06Q6: Do I need to change my API integration to use them?

Check two things first. Tool calling through Chat Completions works only with reasoning effort set to none, so agents that call tools with reasoning enabled belong on the Responses API. Then verify your effort setting: the highest level is not always the best value, and the right setting varies by task.

Share this article
Made with Atoms

Your next idea starts here.

Turn what you learned into a working app or website.

Start building for free