GPT-6 Sol vs Luna: route coding tasks by accepted-result cost, not token price

Quick answer

OpenAI released gpt-6-sol and gpt-6-luna on September 22, 2026. Both accept text and image input, produce text, expose a 1.05-million-token context window, support up to 128,000 output tokens, and are available through the Responses and Chat Completions APIs. The decision is not “expensive model versus cheap model.” It is whether a task needs Sol's stronger judgment for complex coding and agentic work, or Luna's efficiency for focused, repeatable, high-volume work.

Start bounded transforms, extraction, classification, and well-specified maintenance work on Luna. Start ambiguous feature work, multi-tool debugging, and tasks with expensive mistakes on Sol. Measure cost per accepted result, including retries and tool calls. At Standard short-context rates, Sol costs 20 times Luna per input, cached-input, cache-write, and output token—but one failed or repeated run can erase that headline advantage.

Who this is for

This guide is for teams moving API coding and agent workloads from an older model, splitting one queue between Sol and Luna, or deciding whether a lower token price survives real acceptance tests.

If your tasks regularly require the hardest cross-application reasoning, compare them with the GPT-6 Astra migration checklist. If you are upgrading from the previous family, the older GPT-5.6 Sol, Terra, and Luna comparison is useful only as a workload inventory; do not carry its model names, prices, or assumptions into GPT-6.

What changed and why it matters

The official API changelog identifies the exact model IDs as gpt-6-sol and gpt-6-luna. The model catalog positions Sol for complex coding and agentic workflows, while Luna targets focused work at volume. Both support reasoning effort from none through max.

There is one important API boundary: OpenAI recommends the Responses API for built-in tools and function calling. In Chat Completions, Sol and Luna support function calling only when reasoning_effort is none. A migration that changes both model and endpoint can therefore create a false model comparison.

Standard pricing per million tokens is:

Model	Input	Cached input	Cache write	Output	Long-context input	Long-context output
GPT-6 Sol	$2.00	$0.20	$2.50	$10.00	$4.00	$15.00
GPT-6 Luna	$0.10	$0.01	$0.125	$0.50	$0.20	$0.75

The long-context rate applies to the full request when input exceeds 272,000 tokens: input and cache rates double, while output rises by 50%. Batch and Flex are half of Standard; Fast mode is twice the applicable rate. Keep the processing tier constant during comparison.

A task-routing matrix

Workload	Start with	Acceptance evidence	Escalate when
Field extraction, tagging, deterministic rewrites	Luna, low or medium	Schema-valid output and fixture match	Repeated omissions or repair loops exceed the cost budget
Small edits with explicit files and tests	Luna, medium	Patch scope, tests, and unchanged forbidden files	The task spans unclear ownership or hidden dependencies
Feature implementation from a clear brief	Luna medium, paired once with Sol	Test pass, review findings, accepted patch	Sol materially reduces retries or review defects
Multi-file debugging and tool-heavy investigation	Sol, medium or high	Reproduction, root cause, minimal patch, regression test	Failure is ambiguous, cross-system, or costly
Irreversible production or security decision	Sol, high, with human gate	Independent checks and explicit approval	Consider Astra; never route only by token price

This is a starting policy, not a vendor benchmark. Your repository, tool definitions, prompts, and reviewers determine the actual boundary.

Measure accepted-result cost

For every representative task, calculate:

model_cost = input_tokens × input_rate
           + cached_input_tokens × cached_rate
           + cache_write_tokens × cache_write_rate
           + output_tokens × output_rate

accepted_result_cost = (model_cost + tool_cost + retry_cost) / accepted_results

Record the maximum input tokens for each request, because crossing 272K changes the rate for the entire request. Also record endpoint, reasoning effort, processing tier, tools, prompt version, retry count, latency, reviewer corrections, and final acceptance. Comparing Luna at low with Sol at high, or Batch with Fast, measures the configuration—not just the model.

A reversible migration workflow

1. Freeze five real tasks. Include one simple transform, one small patch, one coordinated edit, one tool loop, and one high-cost failure case. Remove secrets but preserve difficulty.
2. Pin the request contract. Use explicit model IDs, the same endpoint, prompts, tools, schemas, reasoning effort, timeout, and retry policy.
3. Preflight capabilities. Confirm text/image input, output limits, structured output, and every required tool. Prefer Responses for tool-driven agents.
4. Run paired canaries. Execute Sol and Luna once on each fixture before adding retries. Preserve usage receipts and tool transcripts.
5. Judge the deliverable. Apply the same tests and review rubric. An API 200 or valid JSON is not an accepted coding result.
6. Publish a routing rule. Send bounded, high-volume work to Luna; send judgment-heavy or expensive-failure work to Sol. State an escalation threshold.
7. Keep rollback boring. Retain the previous model route until the new policy passes a defined sample, budget ceiling, and error-rate gate.

Decision tree

Is the task bounded, repeatable, and machine-verifiable?
  yes -> start with Luna
          accepted within retry and review budget? -> keep Luna
          no -> retry only if policy allows, then escalate to Sol
  no  -> start with Sol

Could a wrong result cause irreversible, security, or production harm?
  yes -> require independent verification and a human gate;
         compare Astra for the hardest cases

Does any request exceed 272K input tokens?
  yes -> apply long-context rates to the full request before deciding

Common mistakes

• Treating Luna's lower token price as proof of lower completed-task cost.
• Changing endpoint, effort, tools, prompts, and model in the same experiment.
• Applying short-context prices to a request that exceeds 272K input tokens.
• Using Chat Completions tool calling with a non-none reasoning effort.
• Treating an API response, syntactically valid patch, or passing unit test as sufficient acceptance.
• Assuming a model's availability in another product proves the same API access, billing, or rollout state.

Building something? Turn your product page into a show people want to watch with PromoFast—hosted, embeddable, and ready to export.

FAQ

Is GPT-6 Luna always cheaper than GPT-6 Sol?

It is 20 times cheaper per token at the listed Standard rates, but the useful business metric is accepted-result cost. Retries, longer outputs, tool calls, review corrections, and failed tasks can reverse the outcome.

Do Sol and Luna have different context windows?

The official model pages list the same 1,050,000-token context window and 128,000 maximum output tokens. Context size is not the differentiator here; workload judgment, throughput, and measured acceptance cost are.

Can I use function calling with Chat Completions?

Yes, but the GPT-6 guidance says Sol and Luna support Chat Completions function calling only with reasoning_effort: "none". Use the Responses API for built-in tools and broader tool-driven workflows.

Should I update every route on release day?

No. Canary representative tasks, keep the previous route available, and promote only after evidence meets your quality, cost, latency, and failure gates.

Sources

• OpenAI API changelog
• GPT-6 Sol model page
• GPT-6 Luna model page
• OpenAI API pricing
• GPT-6 model guidance
• OpenAI model selection guide

Originally published on IndieSeek.