The short answer by workload
| Start with | Best fit | Escalate when |
|---|---|---|
| GPT-6 Luna | Fine-grained edits, extraction, triage, repeated automations, and other scoped work with a reliable validator | Retries, rejected outputs, or review time erase the price saving |
| GPT-6 Sol | Everyday coding, writing, research, and multi-step agent work that needs judgment and completeness | The task remains ambiguous, tool recovery is difficult, or a wrong handoff is costly |
| GPT-6 Astra | Demanding analysis, broad-context projects, computer use, and high-stakes end-to-end deliverables | Usually start here when the downside of failure costs more than the model premium |
Use the table to route work; it does not rank every possible response. OpenAI describes Luna as its efficient model for focused, high-volume tasks, Sol as a model for complex coding and agentic workflows, and Astra as its most capable model for the hardest end-to-end work. The right tier depends on how much reasoning the task needs, how often it runs, and how easily you can reject a bad result.
Official API prices create a 100x spread
The table uses OpenAI's Standard short-context API prices, checked on September 23, 2026. Rates are per 1 million tokens for prompts with no more than 272,000 input tokens.
| Model | Input | Cached input | Cache writes | Output |
|---|---|---|---|---|
| GPT-6 Astra | $10.00 | $1.00 | $12.50 | $50.00 |
| GPT-6 Sol | $2.00 | $0.20 | $2.50 | $10.00 |
| GPT-6 Luna | $0.10 | $0.01 | $0.125 | $0.50 |
At these rates, Astra costs five times Sol and 100 times Luna per input or output token. Sol costs 20 times Luna. All three model pages list a 1.05 million token context window and a 128,000 token maximum output. Prompts above 272,000 input tokens use twice the input and cache rates and 1.5 times the output rate for the full request. Batch, Flex, Fast mode, regional processing, tools, retries, and rejected work can change the realized cost.
What we tested
We ran twelve fresh Codex CLI sessions on September 23, 2026: one run per model for each of four frozen tasks. Every run used Codex CLI 0.155.0-alpha.9.2, medium reasoning effort, a read-only sandbox, the same output schema, and an ephemeral session. No run was retried and no model output was edited.
- Classify four incident records from exact rules, cite the decisive field, and preserve one unknown value.
- Review a small JavaScript function for zero-price handling, an integer range, and numeric two-decimal rounding.
- Update a plan after a requirement change while preserving completed work and avoiding a false claim that a new file already exists.
- Inspect a five-file local project, run a specified Node.js test, diagnose the intentional failure, hold the release, and refuse an unauthorized deployment.
The fourth case adds real shell use. Each model inspected the fixture and ran node tests/check.mjs. The command was expected to fail because the frozen source incorrectly rejected a zero estimated cost. Passing the task meant reporting that failure, proposing a zero-safe missing-value check, respecting the failed unit gate, and reading production_authorized: false before choosing DO NOT DEPLOY.
Observed results
| Model | Cases accepted | Corrected checks | Local elapsed total | Retries | Output edits |
|---|---|---|---|---|---|
| GPT-6 Luna | 4/4 | 22/22 | 65.60 s | 0 | 0 |
| GPT-6 Sol | 4/4 | 22/22 | 81.89 s | 0 | 0 |
| GPT-6 Astra | 4/4 | 22/22 | 73.42 s | 0 | 0 |
The elapsed values include CLI startup, network conditions, model service time, and local tool execution. One run per case cannot estimate latency or reliability, so Luna's lower total is an observation rather than a speed claim.
The Codex event stream recorded 109,357 input tokens for Luna, 110,422 for Sol, and 113,150 for Astra across the four sessions. It also reported 51,456, 52,992, and 37,120 cached input tokens respectively. Fresh CLI sessions carry substantial system and capability context, so these totals do not represent the four short user prompts alone and should not be used as a model-efficiency benchmark.
The grader needed a correction
The first frozen grader gave Luna 21/22 checks and gave Sol and Astra 19/22. Inspection showed seven lexical false negatives. It accepted only a == null patch even though Sol and Astra proposed valid !== 0 forms, required authorization evidence to appear as the exact joined string production_authorized=false, and missed two verification statements that referred to the exact section named in the preceding answer.
We changed only those matchers and ran the corrected grader against the same twelve output files. No model was rerun and no answer was edited. All three then scored 22/22. The download retains both result files, both grader hashes, the seven-item correction record, and every raw event stream. A brittle evaluator can create a model ranking that disappears when its string matching is audited.
Tokens are visible; Codex credits are not
The CLI event stream exposed token counts but did not expose a per-run Codex credit debit. We therefore recorded credit consumption as unavailable instead of estimating it. This test ran in Codex and did not generate an API invoice. The dollar figures above are current API list prices, not the bill for these twelve Codex sessions.
If you run the same workflow through the API, compare cost per accepted result:
token charges + tool charges + retries + review time + repair time
A Luna run that passes a deterministic gate on the first attempt is hard to beat on price. A cheap run that needs repeated repair can cost more than a stronger model that finishes once. The threshold depends on your review cost and the damage caused by an accepted mistake.
What this small test supports
For these bounded cases, Luna is the sensible first candidate. It matched Sol and Astra on every corrected check at the lowest published price. The result supports a practical experiment: send easily graded work to Luna, measure rejects and repair time, then promote the cases it cannot handle reliably.
The test does not show that Luna matches Astra on ambiguous research, long-context synthesis, visual judgment, live computer use, asynchronous tool recovery, or multi-hour projects. It also does not prove that Sol has no middle-tier advantage. None of the four cases was difficult enough to expose one.
OpenAI released GPT-6 Sol and GPT-6 Luna on September 22, 2026. Its current guidance says to use Luna for efficient repeatable work, Sol for strong reasoning on demanding tasks, and Astra for the highest capability. Our evidence changes the starting point for cheap, verifiable work. It does not replace that broader product positioning.
Keep the September 11 result as history
Our earlier GPT-6 Astra vs GPT-5.6 Sol and Terra comparison remains at its original URL. On September 11, all nine outputs passed 48 of 48 checks. Local elapsed totals were 43.01 seconds for Astra, 37.80 seconds for GPT-5.6 Sol, and 37.96 seconds for GPT-5.6 Terra.
Those numbers remain useful as a dated fixture record. They should not be placed beside the new timings as a generation-over-generation speed chart. The older run used Codex CLI 0.153.4, reasoning effort none, three tasks instead of four, different service conditions, and two models that are no longer the subject of this page.
Run a routing test on your own work
- Collect real tasks from the workflow you plan to route. Include common cases, edge cases, missing inputs, a failed tool, and one requirement change.
- Write acceptance checks before running a model. Test the artifact or decision, not the tone of the answer.
- Run each candidate more than once in randomized order. Record tokens, cache use, tool charges, elapsed time, retries, rejected outputs, and human repair minutes.
- Start production routing with the cheapest tier that meets the acceptance target. Keep an escalation rule for cases that fail validation or exceed the review budget.
Download the September 23 Astra, Sol, and Luna test kit. It contains the four prompts, tool fixture, twelve outputs, event streams, timing files, both grader results, correction record, and test summary. The September 11 Astra, GPT-5.6 Sol, and GPT-5.6 Terra kit remains available as the dated historical result.
