OpenAI Releases GPT-6 Sol and Luna at Half GPT-5.6 Promo Prices

OpenAI released GPT-6 Sol and Luna on September 22, bringing its new model family to lower budgets. Sol costs $2 per million input tokens and $10 per million output tokens, half the promotional rates for GPT-5.6 Sol.

The practical question is how much capability you give up for the saving. Sol at xhigh effort scored 33.2% on AutomationBench at $0.27 per task. The higher-priced Astra at max effort reached 41.4% at $1.73 per task in the same benchmark.

Luna is cheaper again, at $0.10 input and $0.50 output per million tokens. Both models launched in ChatGPT Work, Codex, and the API. OpenAI's announcement says they were not yet available in regular Chat; Free and Go users get Luna through the desktop app.

This is a busy release week, with Grok 4.7 and Claude Opus 5.5 joining the comparison. CodeWalkers hasn't hands-on tested all these models yet. The figures below come from the named providers and benchmark publishers; we'll update this article as our testing and further evidence become available.

What Shipped on September 22

Sol and Luna follow GPT-6 Astra's September launch. Their API identifiers are gpt-6-sol and gpt-6-luna. OpenAI positions the pair as cheaper models for everyday work, while retaining Astra for its most demanding tasks.

Prompt caching is part of the saving. Cached input reads receive a 90% discount, and developers can now adjust reasoning effort or tool availability while preserving earlier cached context. That matters for agents that repeatedly send the same instructions and tool definitions.

Pricing: Half of GPT-5.6 Promo Rates

OpenAI's launch table compares prior promotional list rates to the new GPT-6 tiers and labels both Sol and Luna 50% cheaper. The current rates are on the API pricing page (Standard short context, USD per 1M tokens). The Cached column covers cached input, and both GPT-5.6 models remain listed:

Model	Input	Cached	Output
gpt-6-sol	$2	$0.20	$10
gpt-6-luna	$0.10	$0.01	$0.50
gpt-6-astra	$10	$1	$50
gpt-5.6-sol	$4	$0.40	$20
gpt-5.6-luna	$0.20	$0.02	$1.20

gpt-6-sol is an exact half of gpt-5.6-sol on all three Standard short columns. gpt-6-luna is half on input and cached input versus gpt-5.6-luna; output moves from $1.20 to $0.50. OpenAI's announcement still groups both under the 50% promotional cut.

Sol and Luna support a 1,050,000-token context window and up to 128,000 output tokens, according to their API model pages. Requests exceeding 272,000 input tokens double input and cached-input rates and raise output rates by 50% for the full request. Fast, Batch, and Flex pricing differs from the Standard rates above.

GPT-5.6 Sol promotional pricing remains listed at least through November 21, 2026.

For agents that reuse large system prompts and tool schemas, OpenAI says the caching work matters as much as the per-token cut. The launch post cites GitHub reporting that recent caching improvements cut the share of prompt tokens needing fresh processing by more than 50% across billions of requests. OpenAI cites that partner figure; CodeWalkers has not measured it independently.

Performance per Dollar

Token prices alone won't tell you what an agent workflow costs. Reasoning, tool calls, and retries change the bill. Zapier's AutomationBench 1.0.6 leaderboard reports both task completion scores and cost per task, letting you compare that trade-off within one test.

CodeWalkers Cost Versus Performance (CW CvP) on AutomationBench

These selected rows come from the same Zapier leaderboard, checked September 23. Cost is per benchmark task, including unsuccessful attempts.

Model	Score	$/task	CW CvP
GPT-6 Sol (xhigh)	33.2%	$0.27	122.96
GPT-6 Sol (max)	32.0%	$0.34	94.12
Claude Opus 5.5 (high)	32.0%	$0.65	49.23
Claude Opus 5.5 (max)	40.0%	$1.28	31.25
GPT-6 Astra (max)	41.4%	$1.73	23.93
Claude Fable 5.1 (max)*	31.4%	$2.45	12.82

* Fable 5.1 uses Opus 5 fallback. Its listed cost excludes fallback tokens, so CW CvP overstates the combined system's value. Model parentheses show reasoning effort; costs are USD per task.

CW CvP divides the published percentage score by cost per task: 33.2 ÷ 0.27 = 122.96 for Sol at xhigh effort. Higher values mean more benchmark score per dollar. This descriptive ratio has no industry-standard status and cannot guarantee that a task will succeed.

Sol xhigh costs about 79% less per task than Opus 5.5 max, but finishes fewer tasks correctly: 33.2% versus 40.0%. Against Astra max, it saves about 84% with an 8.2-point score gap. These calculations use the displayed, rounded costs. A cheaper attempt can still be expensive if a failed workflow needs a person to repair it.

Our Grok 4.7 analysis uses the same ratio on CursorBench. The resulting numbers cannot rank Grok against Sol: CursorBench tests coding, while AutomationBench tests business workflows. Compare models within the same benchmark, version, and task setup.

DeepSWE (Vendor Coding Results)

For coding, the OpenAI launch report provides these DeepSWE v1.1 results. The test covers software-engineering work in real repositories; these are vendor-reported scores:

• GPT-6 Sol (max): 68.8%
• GPT-6 Luna (max): 66.6%
• Claude Fable 5 (xhigh): 69.9% (OpenAI's highest listed Fable score on that chart)

OpenAI says Sol max is within 1.1 points of that Fable peak at about 80% lower cost per task, and that Luna max costs 93% less per task than Opus 5 at medium effort and 96% less than Fable 5 at medium effort. These relative cost savings come from OpenAI's own reported comparisons.

Artificial Analysis (Independent)

Artificial Analysis (independent, September 22) frames the launch as a cost-efficiency move. On its Intelligence Index and Coding Agent Index, AA says overall scores stay largely level with GPT-5.6 while cost per task roughly halves:

Model	Cost/task	Coding change
GPT-6 Sol (max)	$1.06	+2
GPT-6 Luna (max)	$0.07	−2

Cost/task is the approximate Intelligence Index cost in USD, down from $1.99 for GPT-5.6 Sol and $0.18 for GPT-5.6 Luna. Coding change is the Coding Agent Index point difference from each model's GPT-5.6 counterpart, with both GPT-6 results at max effort.

The coding result is mixed: Sol scores 57, up two points, while Luna scores 41, down two. Both also regress on GDPval-AA's knowledge-work tasks. Artificial Analysis attributes those misses to deliverables that omit required elements. Lower cost is useful, but it doesn't make every workload an automatic upgrade.

Sol, Luna, or Astra?

OpenAI keeps a clear three-tier stack across the GPT-6 family. Astra is the top tier for the hardest work. Sol sits in the middle as the everyday strong model for complex jobs. Luna is the tier for high-volume jobs with clear goals.

Teams choosing a default can trial Sol on an existing coding or business workflow and compare the result with the model already doing that job. Luna is a candidate for repetitive, well-defined work where mistakes are easy to detect.

In practice that maps cleanly for developers:

• Reach for Sol when the run is multi-step: agents, repo edits, tool loops, long coding sessions in Codex, or business workflows that need more than a single clean pass. On the AutomationBench CW CvP board above, Sol xhigh combines a 33.2% score with $0.27 per task.
• Reach for Luna when the task is repetitive and well-scoped: classify, extract, summarize, draft short replies, or services processing many requests where you can validate each result.
• Keep Astra for the sessions where you want the full GPT-6 ceiling and can pay Astra's Standard short $10 / $50, or Astra's 41.4% AutomationBench score at $1.73 per task on Zapier's leaderboard.

Computer use is another benchmark where OpenAI reports a strong Sol result. It lists 60.5% for Sol xhigh on OSWorld 2.0 offline, close to Opus 5 medium's 60.3% at about 80% lower cost. That's a separate test from AutomationBench, with different tasks and scoring.

Our Fable 5.1 launch report covers Anthropic's higher-end alternative. Read its safeguards alongside its scores: fallback behavior can change both the result and the cost, as the AutomationBench footnote shows.

Where You Can Use Them

OpenAI's availability section lists where each model runs today:

• ChatGPT Work and Codex: GPT-6 Sol and Luna for Plus, Pro, Business, Enterprise, and Edu, starting September 22. These land in Work and Codex, not the regular ChatGPT Chat tab at announcement time.
• Free and Go: GPT-6 Luna only, and only in the desktop app. Free/Go do not get Sol in this launch.
• Regular Chat: not available at announcement time. The gradual rollout described in the post applies to Work and Codex.
• API: gpt-6-sol and gpt-6-luna (Sol model page, Luna model page).

GitHub Copilot: GitHub's September 22 changelog adds both under usage-based billing, joining Astra already in Copilot:

• Sol: Copilot Pro+, Max, Business, and Enterprise
• Luna: also Copilot Pro (plus the higher tiers)
• Rollout is gradual across VS Code, Visual Studio, Copilot CLI, cloud agent, github.com, mobile, JetBrains, Xcode, and Eclipse
• Business/Enterprise admins may need to enable models in Copilot policy settings

If Work, Codex, or Copilot does not show the new models immediately, retry later during the staged rollout.

What to Try First

1. Price the swap on a real prompt. Take a Sol or Luna API job you already run on 5.6, flip the model id to gpt-6-sol or gpt-6-luna, and compare dollar cost and cache hit rate on the Prompt Caching dashboard OpenAI points to in the launch post.
2. Codex daily driver test. If you live in Codex, run Sol on a multi-file change you would have given 5.6 Sol. Check the diff, test results, total cost, and time spent correcting its work.
3. Luna for clear-goal volume. Point Luna at extract/summarize/classify queues or cheap chat backends. Keep a sample of difficult cases and track missed requirements before increasing volume.
4. Keep Astra on the hard queue. When the task is computer-use heavy, long-horizon, or you need the top of the GPT-6 curve, leave Astra on and use Sol/Luna for the surrounding volume.
5. Check long-context and Fast only if you need them. The prices above cover Standard short-context requests. If your prompts are huge or latency-bound, read the long-context and Fast rows on the pricing page before you budget.
6. Measure dollars per successful completion. Track total spend divided by successful jobs, including retries and human corrections. That is the number that determines whether a cheaper model saves you money.