GPT-6 Luna is enough for small, easy-to-verify code edits. GPT-6 Sol is worth its price when the task needs repo-wide exploration or touches auth, migrations, or API contracts.
Luna costs 1/20 of Sol per token. In my 60-run test on real repository tasks, though, the gap opened on repo-wide work, and on one refactor Luna passed every test while editing code I never asked it to touch.
GPT-6 Sol and GPT-6 Luna are two tiers of OpenAI’s GPT-6 API lineup. Sol is the mid tier for complex coding and agent work. Luna is the cheap tier for focused, high-volume tasks.
Below are the current prices, what I measured, and the routing rules I run now.
On this page
GPT-6 Sol, Luna and Astra prices (October 30, 2026)
These are OpenAI’s standard API rates per 1 million tokens, checked on the official pricing page on October 30, 2026.
| Model | Input | Cached input | Output |
|---|---|---|---|
gpt-6-astra |
$10.00 | $1.00 | $50.00 |
gpt-6-sol |
$2.00 | $0.20 | $10.00 |
gpt-6-luna |
$0.10 | $0.01 | $0.50 |
Luna is exactly 1/20 of Sol on input, cached input and output. Astra is 5x Sol.
Prompts over 272K input tokens cost more: the Sol model page lists 2x input and 1.5x output for the whole request. Batch and Flex run at half the standard rate.
GPT-6 Luna is also cheaper than the model it replaced. GPT-5.6 Luna is listed at $0.20 input and $1.20 output, so GPT-6 Luna halves input and cuts output by more than half.
Both Sol and Luna have a 1,050,000-token context window and 128,000 max output tokens (model pages, checked October 30, 2026). The difference you pay for is capability, not context size.
I left Astra out of my test. I keep it as the top tier for extremely hard tasks, and I haven’t used it on its own yet.
What changed since launch
The lineup moved after Sol and Luna shipped on September 22, 2026.
- GPT-6.1 Sol (
gpt-6.1-sol) arrived on September 29. It keeps $2 input and $10 output but drops cached input to $0.10. Thegpt-6-solpage now points to it as the newer Sol model. - GPT-6.1 Terra (
gpt-6.1-terra) is now in OpenAI’s model list at $1 input and $5 output, between Sol and Luna.
My test below used gpt-6-sol and gpt-6-luna, not the 6.1 models.
My 60-run test: where Luna was enough
Right after the API release on September 22, I connected gpt-6-sol and gpt-6-luna through the Responses API. I compared them on a separate test route first.
I picked 30 coding tasks from a real repository and ran each once per model, 60 runs in total:
- 10 small code edits
- 10 multi-file refactors
- 10 test-writing or bug-fix tasks
On small edits, Luna was enough in most cases. The gap opened on tasks that required exploring the whole repo and inferring design intent.
The failure that changed how I judge results came from the refactor group, covered next.
Why can Luna pass every test and still produce a worse diff?
Because tests check correctness, not scope. A model can pass every test while also editing code outside the request, and that makes the change harder to merge.
One refactor in my set showed this clearly. The goal was to remove duplicate validation in one service.
GPT-6 Luna did that, then kept going. It renamed exceptions and restructured helpers in adjacent code I hadn’t asked about, and the diff grew.
By test score, the task succeeded. By merge judgment, its scope discipline was worse.
After that, I dropped “tests pass” as the single criterion in my routing benchmark. I now score four things:
- correctness
- change scope
- retry count
- how much a human had to fix
Benchmarks are moving the same way. FrontierCode, Cognition’s coding benchmark that OpenAI cited at launch, scores mergeability apart from correctness, and version 2.0 (October 27, 2026) lists scope discipline in its rubric.
When should you escalate from Luna to Sol?
Escalate after one Luna failure, or as soon as the task needs repo-wide exploration. Before picking a model, I sort each task into one of three risk levels by what a bad change would break. I used the same three levels before GPT-6 and kept them as they were.
I first ran them with a cheaper model, Ox Alpha (GLM 5.3 Flash). In a 30-task comparison on one repository, Ox Alpha succeeded on 73% of tasks against Claude’s 87%, and fell into a repeat loop on 17%. Over one week of routing logs, risk-based routing cut cost by about 60% compared with sending everything to Claude. Those are the final numbers from that test, not re-measured since, and not GPT-6 results. The 60% came from the routing itself, not from the cheap model’s price.
| Level | Default model | When |
|---|---|---|
| Low | Luna | Output is easy to verify |
| Medium | Luna, then Sol | Failure or wide search |
| High | Sol from the start | Auth, migrations, API contracts |
Low covers test boilerplate, simple conversions, docs and small function edits, where you can verify the output right away.
Medium moves to Sol after one failure, or when the model has to dig widely through repo context. High covers auth and permissions, DB migrations, multi-module refactors and public API contract changes.
Even when Sol succeeds on High Risk work, I don’t auto-merge. Model choice and human approval are separate problems (more on coding agent approval prompts).
Risk and Difficulty are different axes
Adding GPT-6 made one more distinction clear to me.
A 500-line data transformation is hard to implement, so Difficulty is high. If snapshot tests fully verify it, Risk can still be low.
A one-line change to an auth condition is the opposite. It’s easy to write but high risk.
In my setup, Difficulty decides which model you need. Risk decides which verification and approval you need.
The routing table as code
Here is the table above as a minimal Python sketch with the OpenAI Responses API. It shows the shape of the rule, not my production config; the escalation signals are flags your harness would set.
from openai import OpenAI
client = OpenAI()
MODEL_BY_RISK = {"low": "gpt-6-luna", "medium": "gpt-6-luna", "high": "gpt-6-sol"}
def run_task(prompt, risk, failed_once=False, needs_repo_search=False):
model = MODEL_BY_RISK[risk]
if risk == "medium" and (failed_once or needs_repo_search):
model = "gpt-6-sol" # escalate after one failure or wide search
resp = client.responses.create(model=model, input=prompt)
return model, resp.output_text # high risk: a human still approves the merge
Caching lowers the token bill, not the cost to finish
Cached input is 90% off the input rate for both Sol and Luna, so list prices alone overstate the bill.
The cost I watch is cost to finish the task, not cost per token. If cheap tokens make you lenient about calls and retries, Luna can end up looping on a Medium Risk task that one Sol call would finish. Latency goes up, and so does the diff a human has to review.
As a worked example, compare one Sol call with three Luna calls, two failed test runs and a human fix. Once you count the test runs and the human time, the real engineering cost gap doesn’t widen to the 20x on the price sheet.
Luna being cheap makes routing more important, not less. That’s why I push back on “just send almost everything to Luna.”
Where each model sits in my routing layer today
Low goes to Luna. Medium starts on Luna and escalates to Sol. High runs on Sol together with human review.
Price tables go stale in weeks, and this one already moved with GPT-6.1. Separating Risk from Difficulty is the part I’ll carry to the next model as is.
FAQ
Is GPT-6 Luna faster than Sol?
OpenAI doesn’t publish a latency figure for either model. As of October 30, 2026, the Sol page offers a separate Fast mode at 2x the normal rates. One-file edits and repo-wide tasks run so differently that a single average across both describes neither, so time a few of your own typical tasks of each kind on both models.
What reasoning effort do Sol and Luna use?
Both default to medium. The model pages list none, low, medium, high, xhigh and max for both (checked October 30, 2026). If you run your own comparison, set the same effort on both, or you’re testing two variables at once.
Can I use GPT-6 Sol or Luna on the API Free tier?
When I checked on September 23, 2026, neither model was offered on the API Free tier, and rate limits started at Tier 1. As of October 30, 2026, the Sol and Luna model pages list rate limits only for the paid Build, Launch and Grow tiers.
Is GPT-6 Luna in ChatGPT Free?
On September 23, 2026, ChatGPT Free and Go users saw only Luna in the desktop app. That is ChatGPT UI exposure only and says nothing about API access. Plan lineups change often, so check the model picker in your own app.
Sources
- Introducing GPT-6 Sol and Luna (OpenAI): launch of gpt-6-sol and gpt-6-luna, FrontierCode citation
- OpenAI API Pricing: standard, cached, Batch/Flex rates for GPT-6 and GPT-5.6 models (checked 2026-10-30)
- GPT-6 Sol model page: long-context pricing, Fast mode, context window, reasoning effort, rate-limit tiers, pointer to GPT-6.1 Sol (checked 2026-10-30)
- GPT-6 Luna model page: context window, reasoning effort, rate-limit tiers (checked 2026-10-30)
- OpenAI models overview: GPT-6.1 Sol and GPT-6.1 Terra listings (checked 2026-10-30)
- FrontierCode | Cognition: mergeability scoring, version 2.0 dated 2026-10-27, model changelog
Related posts
- Codex “Ran Out of Room in the Model’s Context Window” Fix
- Codex CLI npm install Fails? It Was the Sandbox, Not npm
- Claude Outage Fallback: Request Failed, Files Still Changed
- ChatGPT Pro 500 vs Pro 200 for Codex: Why I Went Back
I first wrote this in Korean on my blog: https://jjeongil.tistory.com/3564.