GPT-6 Sol vs Terra vs Luna vs Astra: Which Model Should You Use?

Start with gpt-6-sol for demanding everyday coding and agent work, gpt-6-luna for focused tasks you can check cheaply, and gpt-6-astra for the hardest multi-step work. Keep gpt-5.6-terra in the trial if it already works for your team. Terra is a GPT-5.6 model, not a fourth GPT-6 tier. Those are starting choices from OpenAI's model guidance, not measured winners on your workload.

The practical question is whether a model clears your quality bar at an acceptable cost per accepted task. Per-token prices alone cannot answer that: output length, reasoning effort, tool use, retries, and human repair can change the result. The facts and direct-API prices below were checked on September 23, 2026.

Which names are actually GPT-6?

OpenAI's GPT-6 guide identifies three explicit API model IDs: gpt-6-astra, gpt-6-sol, and gpt-6-luna. Its changelog records the Sol and Luna release on September 22, 2026. The Terra model page names it gpt-5.6-terra. There is no gpt-6-terra in that GPT-6 lineup. Use full IDs in tests and configuration so an older model with a similar name cannot be mistaken for a new one.

These roles paraphrase OpenAI's GPT-6 guidance, model-selection guidance, and the Terra model page. They are evaluation priorities, not an independent ranking of speed or pass rate. If your question is specifically about the older three-model lineup, see the GPT-5.6 Sol, Terra, and Luna comparison.

How much does each cost through the direct API?

The following are OpenAI direct-API Standard rates in USD per one million tokens for requests with at most 272,000 input tokens, as listed on the official API pricing page on September 23, 2026. They are token rates, not ChatGPT subscription prices or included Codex usage.

The Sol–Terra row deserves a careful read: their Standard short-context input, cached-input, and cache-write rates are equal; Sol's output rate is $10 versus Terra's $12. For the same counted token quantities and the same billing mode, Sol's token charge is lower if any output is billed. That does not establish a lower bill for the same completed job. The two models may use different output or reasoning tokens, produce different numbers of acceptable answers, or trigger different retries.

The rate relationship applies to a like-for-like token count. It is not a measured task-cost result.

Here is a deliberately hypothetical, uncached Standard request with 100,000 input tokens and 20,000 output tokens, no paid tools, and the short-context rate. Multiply each count in millions by its rate: Luna costs $0.02 (0.1 × $0.10 + 0.02 × $0.50); Sol costs $0.40 (0.1 × $2 + 0.02 × $10); Terra costs $0.44 (0.1 × $2 + 0.02 × $12); Astra costs $2.00 (0.1 × $10 + 0.02 × $50). This compares an identical token tally, not likely token usage or quality on a real task. For a deeper Astra-specific rate breakdown, see GPT-6 Astra API pricing.

What happens after 272K input tokens?

Once input exceeds 272,000 tokens, the pricing rules apply the long-context rates to the entire request, not only the excess. For Standard processing, the long-context input/output pairs per million tokens are Luna $0.20/$0.75, Sol $4/$15, Terra $4/$18, and Astra $20/$75. A 300K-input estimate calculated at short-context prices would therefore be wrong. Cached input and cache writes have their own rates; check the pricing table for the categories your request actually uses.

Batch or Flex, where applicable, have different rates from Standard; Fast and eligible regional processing can change the charge again. Tool calls can add charges. Keep the model, service tier, region, token categories, and input-length band together when you compare invoices. A shared 1,050,000-token headline context window on the GPT-6 model pages does not make requests above 272K cheap or prove equal task performance.

Which model should you try first for your work?

Choose the first candidate from the cost of a mistake, then give every candidate the same acceptance test. If a bad result is easy to catch with code or a quick review, start with Luna. If the work requires substantial coding or tool decisions, start with Sol. If a task crosses several tools or is costly to repair, test Astra. If Terra is already deployed successfully, retain it as a measured baseline instead of assuming the newer generation must replace it. This is a trial order, not a claim that one candidate will be faster or better in your environment.

An extraction queue illustrates the tradeoff. A low token rate helps only while validation catches mistakes and reviewers are not spending the difference on fixes. A repository migration has a different failure cost: one superficially plausible but broken change can outweigh many cheap calls. For either workflow, measure end-to-end completion, not just the first model response.

OpenAI positions Sol for complex coding and Luna for focused, repeatable work. The Astra page describes its higher-capability role. Those pages do not certify a pass rate for your prompts. In particular, the same context limit across models is a capacity limit, not evidence of equal comprehension of a long document.

Run an acceptance test before changing the default

1. Collect representative tasks. Include ordinary cases, expensive failures, long inputs if you use them, and the tool actions your production workflow really needs. Define a clear pass rule before reading the model answers: for example, tests pass and the patch meets review criteria, or extracted fields match checked source records.
2. Fix the comparison setup. Record the exact model ID, prompt, input, tools, service tier, region, and reasoning effort. Compare candidates with equivalent settings where the API supports them; when support differs, record that difference instead of calling the trials identical. Astra does not support none reasoning effort; Sol and Luna do.
3. Record outcomes and usage. For each attempt, log whether it met the pass rule, input categories, output tokens (including billed reasoning output), tool charges, elapsed time, retries, and review or repair time. A token estimate from text length is weaker than returned usage and an actual bill.
4. Compare accepted-task cost. Divide total measured spend—including failed attempts and paid tools—by the number of accepted tasks. Keep human repair time and latency as separate columns, or translate repair time to money using your team's explicit rate. Choose the least costly candidate that meets your quality and latency requirements; keep the baseline if no challenger does.

This diagram shows the evaluation method; the comparison cells are deliberately unfilled.

For example, 100 attempted tasks with 80 accepted outcomes and $8 in model/tool spend yield $0.10 per accepted task before labor. If another model spends $6 but delivers only 40 accepted outcomes, its corresponding figure is $0.15. Those numbers illustrate the calculation; they are not observed results for any of these four models. A controlled trial still needs enough representative tasks to reveal expensive failure modes.

Does the API comparison apply to Work or Codex?

No direct conversion exists between this per-token API table and a Work or Codex plan allowance. OpenAI's Work/Codex model guide says GPT-6 Sol and Luna can be selected there when available, while GPT-5.6 models remain during rollout; they are not ordinary Chat models in ChatGPT. What appears in a particular picker depends on the account, workspace, client, and rollout. Selecting an ID does not grant access or change workspace permissions.

For API development, check model access in the relevant project and use the exact ID in your request. For Work or Codex, check the actual model picker and your applicable plan or credit rules. The Standard table above cannot tell you your subscription limit, purchased-credit rate, or availability in a specific account. If your current workflow is already reliable, run the acceptance test before changing a saved default.