# GPT-6 Astra vs Sol vs Luna: which GPT-6 model to use

By SeedRouter · Published 2026-09-28 · Updated 2026-09-28

Start with GPT-6 Sol. It is OpenAI's model for complex coding and agent work, it costs a fifth of GPT-6 Astra per token, and on OpenAI's own business-workflow benchmark, Sol at xhigh effort beats Astra at low effort. Move a task to GPT-6 Astra when it is hard, long and expensive to get wrong. Use GPT-6 Luna for classification, extraction and other jobs you run thousands of times, where cost per call matters most.

All three are sold on SeedRouter under one key, and switching is a change to `model`.

## How do GPT-6 Astra, Sol and Luna compare on specs?

|                      | GPT-6 Astra                                   | GPT-6 Sol                            | GPT-6 Luna                                    |
| -------------------- | --------------------------------------------- | ------------------------------------ | --------------------------------------------- |
| Model ID             | `gpt-6-astra`                                 | `gpt-6-sol`                          | `gpt-6-luna`                                  |
| Released             | September 3, 2026                             | September 22, 2026                   | September 22, 2026                            |
| OpenAI's description | Most capable, for the hardest end-to-end work | Complex coding and agentic workflows | Most efficient, for focused high-volume tasks |
| Context window       | 1,050,000 tokens                              | 1,050,000 tokens                     | 1,050,000 tokens                              |
| Max input            | 922,000 tokens                                | 922,000 tokens                       | 922,000 tokens                                |
| Max output           | 128,000 tokens                                | 128,000 tokens                       | 128,000 tokens                                |
| Reasoning effort     | `low` to `max`                                | `none` to `max`                      | `none` to `max`                               |
| Default effort       | Not documented                                | `medium`                             | `medium`                                      |
| Knowledge cutoff     | April 30, 2026                                | April 20, 2026                       | May 18, 2026                                  |
| Input / output       | Text and images / text                        | Text and images / text               | Text and images / text                        |

The figures come from OpenAI's model pages for [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra), [GPT-6 Sol](https://developers.openai.com/api/docs/models/gpt-6-sol) and [GPT-6 Luna](https://developers.openai.com/api/docs/models/gpt-6-luna), and the release dates from the [API changelog](https://developers.openai.com/api/docs/changelog).

The main difference in the API is the lowest effort. GPT-6 Sol and GPT-6 Luna accept `none`, which answers without reasoning and is the only setting that accepts `temperature` and `top_p`. GPT-6 Astra always reasons; `none` returns a 400 error.

## Which one costs less?

### GPT-6 Astra

Current rates are temporarily unavailable. No price estimate is provided; unavailable rates must not be interpreted as free usage.

### GPT-6 Sol

Current rates are temporarily unavailable. No price estimate is provided; unavailable rates must not be interpreted as free usage.

### GPT-6 Luna

Current rates are temporarily unavailable. No price estimate is provided; unavailable rates must not be interpreted as free usage.

GPT-6 Luna is the cheapest by a wide margin, and GPT-6 Astra the most expensive. On OpenAI's list prices, GPT-6 Sol costs a fifth of GPT-6 Astra and GPT-6 Luna a twentieth of GPT-6 Sol. All three read cached input at 10% of the input rate, and a prompt over 272K input tokens moves the whole request to the long-context row. The [GPT-6 API pricing guide](https://seedrouter.ai/blog/gpt-6-api-pricing) walks through how each line is billed.

## How do they score on OpenAI's benchmarks?

OpenAI published results in two announcements, [GPT-6 Astra](https://openai.com/index/gpt-6-astra/) and [GPT-6 Sol and Luna](https://openai.com/index/introducing-gpt-6-sol-and-luna/). They were run at different effort levels, so read each row with its setting.

| Benchmark (OpenAI-reported)          | GPT-6 Astra                   | GPT-6 Sol                          | GPT-6 Luna                                      |
| ------------------------------------ | ----------------------------- | ---------------------------------- | ----------------------------------------------- |
| AutomationBench (business workflows) | 30.3% at low effort           | 33.2% at xhigh effort              | Beats GPT-5.6 Luna by 5.4 points at high effort |
| DeepSWE v1.1 (software engineering)  | 74.1%                         | 68.8% at max effort                | 66.6% at max effort                             |
| OSWorld 2.0 (computer use)           | 72.6% in a latency simulation | 60.5% at xhigh effort, offline set | Beats GPT-5.6 Sol (medium) at max effort        |

Two points stand out. On AutomationBench, GPT-6 Sol at xhigh effort scored higher than GPT-6 Astra at low effort, and OpenAI puts Astra's cost per task at 3.9 times Sol's. On software engineering and computer use, GPT-6 Astra still leads; OpenAI calls it "the world's best model for computer use".

On factuality, OpenAI reports that GPT-6 Sol makes about half as many mistakes as GPT-5.6 Sol, "approaching Astra-level reliability at much lower cost", and that GPT-6 Luna at higher effort matches GPT-5.6 Sol at about a hundredth of its cost.

## When is GPT-6 Astra worth the price?

Pick GPT-6 Astra when the task is long, the steps depend on each other and a mistake is expensive: large refactors, design work, research you will act on, or agents that operate a computer for many steps. OpenAI's changelog says it combines its skills "to carry complex tasks from an initial request to a finished result".

For everyday coding and agent loops, GPT-6 Sol usually gives you most of that quality at a fifth of the token price, and you can raise its effort to `xhigh` or `max` before you reach for Astra.

## When is GPT-6 Luna enough?

GPT-6 Luna fits jobs with a clear, narrow answer: routing tickets, tagging content, pulling fields out of documents, short summaries. Run it at `none` or `low` effort for the lowest cost and latency, and raise the effort only if accuracy on your own test set is not good enough.

## Which GPT-6 model should I use?

| If you need                         | Use                     | Why                                                 |
| ----------------------------------- | ----------------------- | --------------------------------------------------- |
| A default for coding and agent work | GPT-6 Sol               | Strong results at a fifth of Astra's price          |
| The best result on hard, long tasks | GPT-6 Astra             | OpenAI's most capable model, best at computer use   |
| The lowest cost per call            | GPT-6 Luna              | A twentieth of Sol's price, `none` effort available |
| `temperature` or `top_p`            | GPT-6 Sol or GPT-6 Luna | Only accepted at `none` effort, which Astra lacks   |

## Frequently asked questions

### Is GPT-6 Sol better than GPT-6 Astra?

Not overall. GPT-6 Astra scores higher on OpenAI's software-engineering and computer-use results. GPT-6 Sol at xhigh effort beat GPT-6 Astra at low effort on OpenAI's business-workflow benchmark, and it costs a fifth as much per token, which is why it is the better default for most work.

### What is GPT-6 Sol?

GPT-6 Sol is OpenAI's GPT-6 model for complex coding and agentic workflows, released on September 22, 2026. It sits between GPT-6 Astra and GPT-6 Luna in capability and price, with a 1.05M-token context window.

### Can I use GPT-6 Astra, Sol and Luna with the same code?

Yes. All three take the same Responses and Chat Completions requests; change `model` and, for Astra, avoid `none` effort and sampling fields.

### Can I switch models in the middle of a conversation?

Yes. Send the next request with a different `model` and the same message history. Reasoning from earlier turns is optional context, so the conversation continues without it.

## Try all three on one key

Run the same prompt on [GPT-6 Sol](https://seedrouter.ai/models/gpt-6-sol), [GPT-6 Astra](https://seedrouter.ai/models/gpt-6-astra) and [GPT-6 Luna](https://seedrouter.ai/models/gpt-6-luna) in the browser, compare the answers and the token counts, then call the winner through the API. The [GPT-6 API guide](https://seedrouter.ai/blog/gpt-6-api) shows the request.
