TL;DR
OpenAI released GPT-6 Sol and GPT-6 Luna on September 22, 2026, expanding the GPT-6 family beyond Astra. Sol is designed for complex coding and agentic workflows, while Luna targets focused, repeatable work at high volume. Both accept text and image input, generate text, provide a 1,050,000-token context window, and support the Responses and Chat Completions APIs. Their main difference is workload economics: Sol spends more per token to handle demanding work, while Luna minimizes unit cost for well-bounded tasks.
For most teams, the practical starting point is simple: use Astra for the hardest end-to-end work, Sol when capability and cost must be balanced, and Luna when the task is narrow enough to validate automatically. OpenAI access is live for both Sol and Luna. CometAPI should be checked separately because gateway availability, promotions, and account routing can differ from OpenAI's direct release.
Key Takeaways
- GPT-6 Sol is the stronger starting point for demanding code, multi-step agents, difficult debugging, and workflows where failure creates substantial review cost.
- GPT-6 Luna is designed for focused, high-volume tasks such as extraction, classification, routing, structured summaries, and first-pass transformations.
- Both models have the same published context and output ceilings, so context length alone is not a reason to choose between them.
- OpenAI's Standard short-context rates are $2 input and $10 output per million tokens for Sol, versus $0.10 input and $0.50 output for Luna.
- Use the Responses API for tool-rich reasoning. In Chat Completions, function calling for Sol and Luna requires reasoning_effort to be set to none.
What Did OpenAI Release With GPT-6 Sol and Luna?
The September 22 release adds two lower-cost operating tiers to the GPT-6 family. GPT-6 Astra remains the most capable option for the hardest end-to-end work; Sol brings strong reasoning to demanding coding and agent tasks at a lower token rate; Luna is optimized for focused work that must run repeatedly and economically.
This is more than a naming update. OpenAI's API changelog lists the exact model IDs gpt-6-sol and gpt-6-luna, with text and image input, text output, and availability through both Responses and Chat Completions. Developers can therefore test the models with the same representative prompts and select a tier based on accepted-output rate, latency, total tokens, retries, and human-review time—not token price alone. See the OpenAI API changelog and official model comparison.
What Is GPT-6 Sol?
GPT-6 Sol is OpenAI's GPT-6 model for complex coding and agentic workflows. It is intended for work that requires sustained reasoning, tool decisions, and multiple steps, including repository analysis, debugging, and agent-driven software changes. The official specification lists text and image input, text output, a 1,050,000-token context window, up to 128,000 output tokens, and reasoning effort from none through max.
Sol is not simply “the middle model.” Its economic value depends on whether stronger multi-step performance reduces retries, escalation, and review. It is a good default when Luna's lower unit cost would be outweighed by more failed validations or more human intervention.
What Is GPT-6 Luna?
GPT-6 Luna is the efficiency-focused GPT-6 option for well-scoped work repeated at high volume. Examples include extraction, classification, template-driven responses, support triage, and first-pass summaries, provided outputs are checked against the application's requirements. Luna has the same published 1,050,000-token context and 128,000-token output ceilings as Sol, with text and image input and text output.
Luna is most compelling when success can be defined clearly and checked cheaply. A low token rate does not automatically produce the lowest workflow cost: teams should include retries, rejected outputs, downstream failures, and reviewer time in their evaluation.
How Did GPT-6 Sol and Luna Improve Performance?
Professional and coding evaluations
In OpenAI's published launch evaluations, Sol scored 33.2% on AutomationBench at xhigh effort with an estimated $0.27 cost per task; low-effort Astra scored 30.3% in that comparison. Sol scored 68.8% on DeepSWE v1.1 at max effort, while Luna scored 66.6% at max effort. AutomationBench tests workflows across applications; DeepSWE tests long-horizon software-engineering tasks. These figures are from specific test settings and do not establish a universal ranking for every prompt.
The useful lesson is not that one benchmark declares a universal winner. It is that the best model can change with reasoning effort, tool use, and task design. Benchmark settings should be treated as evidence for forming a test plan, not as a substitute for evaluating production prompts.
Computer use, factuality, and limits
On OpenAI's OSWorld 2.0 offline evaluation, Sol reached 60.5% at xhigh effort. OpenAI also reported roughly half as many mistakes for Sol as its GPT-5.6 predecessor on an internal set of conversations selected because users had flagged factual errors. That set is not representative of typical traffic.
For deployment, evaluate the failure modes that matter to your application: incorrect tool choice, incomplete multi-step execution, schema failures, factual errors, latency, and cost per accepted result. A small representative evaluation set is more actionable than a broad leaderboard score.
How Much Do GPT-6 Sol and Luna Cost?
The official OpenAI pricing table separates Standard short-context and long-context rates. Prices below are USD per one million tokens. A prompt with more than 272,000 input tokens uses long-context rates for the full request, not only for the portion above the threshold.
| OpenAI Standard rate / 1M tokens | GPT-6 Sol: short / long | GPT-6 Luna: short / long |
|---|---|---|
| Input | $2.00 / $4.00 | $0.10 / $0.20 |
| Cached input | $0.20 / $0.40 | $0.01 / $0.02 |
| Cache writes | $2.50 / $5.00 | $0.125 / $0.25 |
| Output | $10.00 / $15.00 | $0.50 / $0.75 |
Batch, Flex, Fast mode, and eligible regional processing have separate rates. Estimate cost using the service tier, full input length, output length, cache behavior, tool fees, and retry rate.
CometAPI pricing and availability snapshot
CometAPI currently lists both GPT-6 Luna and GPT-6 Sol at 20% below OpenAI’s corresponding short-context Standard API rates. For GPT-6 Luna, CometAPI charges $0.08 per million input tokens and $0.40 per million output tokens, compared with OpenAI’s $0.10/$0.50 rates. The catalog also lists discounted cache-read and cache-write pricing, with the same 20% reduction.
GPT-6 Sol receives the same 20% CometAPI discount. Its short-context rate is $1.60 per million input tokens and $8.00 per million output tokens, compared with OpenAI’s $2/$10 Standard pricing. This makes Sol substantially more expensive than Luna on a per-token basis, but the two models target different workloads: Sol is designed for demanding coding and agentic workflows, while Luna emphasizes efficient, high-volume inference.
| CometAPI model | Public status | Short-context input / output | Interpretation |
|---|---|---|---|
| GPT-6 Luna | Listed with 20% off | $0.08 / $0.40* | Input is displayed publicly; output is the corresponding 20%-off calculation. Recheck the dashboard. |
| GPT-6 Sol | Listed with 20% off | $1.60 / $8.00* | Input is displayed publicly; output is the corresponding 20%-off calculation. Recheck the dashboard. |
*Dated snapshot and disclosed calculation, not a guarantee of future pricing or account access. See the CometAPI model catalog and pricing page.
GPT-6 Astra vs GPT-6 Sol vs GPT-6 Luna: How Should Developers Choose?
The three models should be compared by the cost of a successful workflow, not by specifications alone. Astra offers the highest capability ceiling, Sol balances strong reasoning with a much lower token rate, and Luna minimizes unit cost for tasks with clear boundaries and validation.
| Model | Choose it when | Operating tradeoff |
|---|---|---|
| GPT-6 Astra | The task is the hardest end-to-end work: ambiguous, high-consequence, tool-heavy, or expensive to review. | Highest token price, but it may reduce downstream failures and human intervention on the most difficult cases. |
| GPT-6 Sol | You need strong coding and agentic performance without paying Astra rates for every request. | A strong default for demanding production work; validate whether its extra capability reduces retries enough to justify its cost over Luna. |
| GPT-6 Luna | The work is narrow, measurable, high-volume, and protected by schemas, rules, or sampling. | Lowest unit cost, but weak task definitions or poor validation can turn savings into review and retry costs. |
Recommended routing pattern: send routine, well-bounded work to Luna; route demanding cases to Sol; reserve Astra for tasks where complexity, ambiguity, or consequence makes the higher capability ceiling valuable. Escalation signals can include failed validation, tool requirements, low confidence, unusually long prompts, or a high cost of error.
Why Has GPT-6 Terra Not Been Released?
OpenAI has not announced a GPT-6 Terra model or given a reason for its absence as of September 23, 2026. Its public GPT-6 model catalog lists Astra, Sol, and Luna, and the API changelog announces Sol and Luna without a Terra model ID. The earlier GPT-5.6 generation included Terra, which explains the question, but does not establish a GPT-6 launch plan.
Any explanation based on pricing, lineup strategy, or release timing is analysis rather than an OpenAI statement. Until OpenAI publishes a model page or announcement, a release date, specification, benchmark, and price for GPT-6 Terra remain unknown.
How Can Developers Access and Use GPT-6 Sol and Luna?
Use OpenAI directly
Both model IDs are live in OpenAI's Responses and Chat Completions APIs. Use Responses for reasoning with built-in tools and function calling. Chat Completions supports ordinary requests, but function calling for Sol and Luna requires reasoning_effort="none".
Use CometAPI after checking the live route
CometAPI documents an OpenAI-compatible base URL, so teams can use the OpenAI SDK with a CometAPI key. The public catalog currently supports using Luna as the safer example. Only substitute gpt-6-sol after your account confirms that the Sol route is enabled.
If your CometAPI dashboard documents Responses and chat support for the selected route, test it separately before rollout. Log the provider, route, model ID, reasoning setting, latency, tokens, validation result, and billed cost so gateway tests remain distinguishable from OpenAI-direct tests.
Conclusion
GPT-6 Sol and GPT-6 Luna extend the GPT-6 family with two different workload economics. Sol is built for complex coding and agentic workflows; Luna is designed for efficient, focused work at scale. Astra remains the option for the hardest end-to-end tasks. Because all three choices can look economical under different conditions, the right comparison is cost per accepted result—not context length or token price in isolation.
Start with a representative evaluation set. Measure quality, latency, total tokens, retries, validation failures, and human-review time. Use OpenAI's published model IDs for direct access, and verify the live CometAPI route and account pricing before making gateway-specific availability claims.