GPT-6 Luna is the default for focused, high-volume work; GPT-6 Sol is worth considering when a task needs stronger complex coding or agentic capability. Sol costs exactly 20 times more than Luna at the published Standard input, cached-input, cache-write and output rates.
That price gap is not evidence of a 20× performance gap. OpenAI positions Sol as the balanced model for complex coding and agents, while Luna is its efficient model for focused, high-volume tasks. The right decision depends on successful-task rate, retries and human review—not the family name alone.
This comparison uses OpenAI and GitHub documentation checked on September 23, 2026. We have not independently benchmarked the two models.
GPT-6 Sol vs Luna at a glance
| Decision | GPT-6 Sol | GPT-6 Luna |
|---|---|---|
| Model ID | gpt-6-sol | gpt-6-luna |
| Positioning | Complex coding and agentic workflows | Focused, high-volume tasks |
| Standard input/output | $2 / $10 per MTok | $0.10 / $0.50 per MTok |
| Cached input | $0.20 | $0.01 |
| Cache write | $2.50 | $0.125 |
| Batch/Flex input/output | $1 / $5 | $0.05 / $0.25 |
| Context | 1.05M | 1.05M |
| Maximum output | 128K | 128K |
| Reasoning | none, low, medium, high, xhigh, max | none, low, medium, high, xhigh, max |
| Copilot plans | Pro+, Max, Business, Enterprise | Pro, Pro+, Max, Business, Enterprise |
Exact price difference
Every ordinary token rate is 20× higher for Sol:
- $2 versus $0.10 input;
- $0.20 versus $0.01 cached input;
- $2.50 versus $0.125 cache writes;
- $10 versus $0.50 output.
Batch and Flex halve both models’ rates and preserve that 20× ratio. Fast doubles both models and also preserves it. Processing mode therefore changes the absolute bill, not the relative price relationship.
Pricing examples
These calculations use published token prices. They do not measure model quality or task success.
One million input plus 100K output
| Model | Input | Output | Total |
|---|---|---|---|
| Sol | $2.00 | $1.00 | $3.00 |
| Luna | $0.10 | $0.05 | $0.15 |
At 1,000 identical jobs, that is $3,000 for Sol versus $150 for Luna before caching. A small quality difference can matter, but it must offset $2,850 in this illustrative workload.
One million cached input plus 100K output
| Model | Cache read | Output | Total |
|---|---|---|---|
| Sol | $0.20 | $1.00 | $1.20 |
| Luna | $0.01 | $0.05 | $0.06 |
Caching reduces both totals without changing the 20× ratio. The first cache write would cost $2.50 on Sol or $0.125 on Luna.
High-volume lightweight agent workflow
For ten million input tokens and one million output tokens under Standard processing:
- Sol: $20 input + $10 output = $30
- Luna: $1 input + $0.50 output = $1.50
This is where Luna’s intended role is clearest: routing, classification, extraction, short transformations and bounded tool decisions that pass an automated acceptance test.
A request above the long-context threshold
For 300,000 input tokens and 20,000 output tokens, both models apply their higher rates to the full request:
- Sol: 300K × $4/M + 20K × $15/M = $1.50
- Luna: 300K × $0.20/M + 20K × $0.75/M = $0.075
OpenAI’s threshold is 272,000 input tokens. Only charging the portion above that threshold at the higher rate would understate cost.
Same limits do not mean the same role
Both models accept text and image input, return text, expose a 1,050,000-token context window and allow up to 128,000 output tokens. Both offer reasoning from none through max, with medium as the default.
Those specification similarities make Luna attractive, but OpenAI explicitly assigns the models different capability positions. Sol is built for complex coding and agentic workflows. Luna is the efficient option for focused work at scale. A shared context window says how much a model can receive, not how reliably it can reason across that context.
Use LLM regression testing to compare completion quality, tool-call validity, latency, retries and reviewer intervention on your own tasks.
When Luna is likely sufficient
Start with Luna for:
- classification into a controlled label set;
- structured extraction with schema validation;
- routing requests to tools or stronger models;
- summaries and transformations with objective checks;
- short code explanations or mechanical edits;
- high-volume first-pass processing;
- low-risk agents with narrow permissions and deterministic validation.
Luna is especially compelling when failures are cheap to detect and can escalate automatically. A guarded Luna-to-Sol route can deliver much lower average cost than sending every request to Sol.
When Sol may justify its cost
Evaluate Sol for:
- repository-scale changes spanning multiple files;
- long agent loops with planning, tools and recovery;
- debugging where the root cause is ambiguous;
- architecture or migration work requiring tradeoff analysis;
- tasks where Luna repeatedly fails validation or escalates;
- higher-stakes outputs whose review cost dominates token cost.
Do not upgrade because a task merely sounds important. Promote it when evaluation data shows that Sol improves successful-task cost or materially reduces human intervention.
Batch, Flex and latency choices
Batch costs $1/$5 for Sol and $0.05/$0.25 for Luna. It suits asynchronous jobs where turnaround can wait. Flex uses the same token rates and is designed for workloads that accept weaker latency and availability guarantees. Fast doubles Standard pricing for lower-latency work.
For bulk extraction or offline enrichment, Luna Batch can be extremely inexpensive. For an interactive coding agent, Sol Standard or Fast may be more appropriate if latency and recovery quality matter. Processing mode cannot compensate for selecting a model that misses the task’s quality threshold.
GitHub Copilot difference
GitHub is gradually rolling both models across its supported IDE, CLI, cloud-agent, app, web and mobile surfaces. Luna is available from Copilot Pro, while Sol starts at Pro+; both also cover Max, Business and Enterprise. Administrators on managed plans control access through model policies.
Copilot uses usage-based billing for the selected model. Direct OpenAI API rates should not be treated as the literal cost of a Copilot interaction. Luna’s wider plan availability nevertheless makes it the more accessible GPT-6 option inside Copilot.
A practical routing policy
- Send bounded, automatically verifiable tasks to Luna.
- Validate schema, tool results and task-specific acceptance criteria.
- Escalate failures or low-confidence cases to Sol.
- Record total tokens, retries, latency and reviewer time.
- Revisit the route when prompts or model behavior change.
This avoids paying Sol rates for every simple request while keeping a stronger path for complex work. Apply permission boundaries regardless of model; lower cost does not make an agent lower risk.
Verdict
Use GPT-6 Luna by default when the work is narrow, high-volume and easy to validate. Pay for GPT-6 Sol when evaluations show that its complex coding and agent capability prevents enough failures, escalations or reviewer time to cover a 20× token-price premium. Equal context and output limits make Luna unusually capable on paper, but only workload testing can establish whether it is sufficient.
Read the GPT-6 Sol guide and GPT-6 Luna guide for complete API boundaries and regional-processing details.