GPT-6 Luna vs Sol vs Astra: Picking a Tier on Cost Per Task

OpenAI shipped GPT-6 Sol and GPT-6 Luna on September 22, 2026, joining GPT-6 Astra in a three-tier family. The first thing most teams do is open the pricing page, see $0.10 next to Luna and $10 next to Astra, and conclude the top tier costs a hundred times more.

That number is real and it is also the wrong unit. You do not ship tokens to production. You ship finished work: a resolved ticket, a migrated file, a completed browser task. Reasoning models decide for themselves how many tokens that takes, and the effort level you pass changes the answer by an order of magnitude. A cheap model at maximum effort can cost more per finished task than an expensive model answering quickly.

This guide is the GPT-6 successor to our GPT-5.6 Sol vs Terra vs Luna comparison. That post compared tiers on price per million tokens, which was the right unit for that generation. This one compares them on cost per task, because that is the unit OpenAI itself used to justify the new models.

The three tiers on paper

Two things in that table surprise people.

First, Luna has the largest context window of the three. The cheapest model in the family takes a full million tokens, while Sol stops at 872k. If your workload is “read a lot, decide a little,” the budget tier is not the constrained one.

Second, the Astra row has holes. The Sol and Luna launch post does not restate Astra’s context window or its cached-read rate, and Astra carries no published Artificial Analysis index score alongside the other two. Those are gaps in the source material, not zeros.

Sol and Luna are both described as 50% cheaper than GPT-5.6, and OpenAI’s own wording is that the comparison is against GPT-5.6 promotional pricing. That qualifier matters enough that we gave it its own breakdown. Against the GPT-5.6 list rates our launch coverage recorded at the time, the cut is larger than the headline.

Why price per token stops predicting your bill

Three separate multipliers sit between the rate card and the invoice.

Reasoning tokens are output tokens. When a model thinks before answering, that thinking bills at the output rate, which is five times the input rate across all three tiers. A task that returns a 200 token answer after 8,000 tokens of reasoning bills like a 8,200 token answer.

Effort level is a dial, not a flag. OpenAI’s benchmark tables report results per effort setting: low, medium, high, xhigh, max. The same model at max effort and at low effort are, for budgeting purposes, two different products with two different prices per task.

Agent loops resend the prompt. A twelve step agent sends its system prompt, tool definitions and accumulated history on every step. Input volume grows quadratically with steps unless caching absorbs it, which is exactly why GPT-6 shipped a caching release alongside the models: 90% off cached input reads, and reasoning effort or tool changes no longer invalidate the prefix.

Put those together on a realistic agent task: twelve model calls, a 40k token prompt prefix, 2k output tokens per call. Assume the first call pays full input price and the remaining eleven read the prefix from cache.

The headline input ratio is 1:20:100. Once caching is in the picture the spread stretches to roughly 1:20:294, or compresses to 1:20:100 again, entirely depending on an Astra cached-read rate that the launch table does not give us. That single unknown moves the top tier’s cost per task by a factor of three. Find out what it is for your account before you size a budget around Astra.

What OpenAI’s own cost-per-task numbers show

The launch post publishes score and relative cost together, which is the useful part. On AutomationBench 1.0.6:

Read that top pair slowly. The mid tier at xhigh effort scores 2.9 points above the flagship at low effort and costs roughly a quarter as much per task. On the $0.27 baseline that puts Astra at low effort near $1.05, which is arithmetic on OpenAI’s multiplier rather than a figure OpenAI printed.

The same shape repeats elsewhere:

• Agents’ Last Exam V1: Sol at max scores 56.4%, above Claude Opus 5’s best result, at 60% lower cost per task.
• DeepSWE 1.1: Sol at max reaches 68.8%, within 1.1 points of Claude Fable 5 at xhigh, at roughly 80% lower cost per task. Luna at max reaches 66.6%, comparable to Opus 5 and Fable 5 at medium effort, at 93% less per task than Opus 5 and 96% less than Fable 5.
• OSWorld 2.0 offline: Sol at xhigh scores 60.5% against Opus 5 at medium on 60.3%, around 80% cheaper per task. Luna at max beats GPT-5.6 Sol at medium at a tenth the cost.
• Factuality: Sol makes about half the mistakes of its predecessor. Luna at higher effort matches GPT-5.6 Sol at about a hundredth the cost.
• Cost movement within the tier: Luna at high effort beats its own predecessor by 5.4 points at 58% lower cost per task.

Two honest caveats. Every one of those comparisons was written against Claude Opus 5, because Anthropic released Opus 5.5 the same day and OpenAI’s post predates it. And the Astra numbers in that table are a single low effort data point; OpenAI states plainly that Astra “continues to be our best model across the board.” Nothing here says Astra loses. It says Astra at low effort is an expensive way to buy 30.3%.

The tier that is missing, and the one that moved

GPT-5.6 was Sol, Terra and Luna. GPT-6 is Astra, Sol and Luna. There is no GPT-6 Terra.

That is not a rename of the old middle tier. Astra sits above where GPT-5.6 Sol sat, and GPT-6 Sol has inherited the middle slot at a price well below the tier name’s previous rate. If your code pins gpt-5.6-terra today, the nearest GPT-6 model by role is Sol, not a same-named successor. Our naming explainer is now generation history rather than a current map.

The price lineage for the two names that survived:

Same names, different models, different economics. Anything in your config that treats a tier name as a stable capability level needs rereading.

Picking a tier

The routing pattern in row four is the one that pays. Run the cheap tier, validate the output programmatically, and escalate only what fails. If Luna clears 80% of a queue at $0.02 per task and Sol mops up the rest at $0.41, your blended cost is about $0.10, not $0.41.

One latency footnote before you assume the cheap tier is also the quick one. Artificial Analysis, a third party rather than either vendor, measures the max reasoning variants at 115.2 output tokens per second and 102.15 seconds to first token for Sol, and 153.9 tokens per second and 124.23 seconds to first token for Luna. Those are max effort figures and will not describe a low effort call. We unpack what a two minute first token does to an API contract in our latency piece.

Measure it on your own traffic

Vendor cost-per-task numbers come from vendor harnesses. Yours will differ, and the only comparison that decides anything is the one run on your prompts.

The usage block on every response carries what you need:

{
  "model": "gpt-6-luna",
  "usage": {
    "input_tokens": 41200,
    "input_tokens_details": { "cached_tokens": 39800 },
    "output_tokens": 2140,
    "total_tokens": 43340
  }
}

Cost for that call, at Luna rates: 1,400 uncached input at $0.10/M, 39,800 cached at $0.01/M, 2,140 output at $0.50/M. That is $0.00014 plus $0.000398 plus $0.00107, or roughly $0.0016. Multiply by the number of calls a task takes, not by the number of tasks.

Three rules make the measurement trustworthy:

1. Count whole tasks, not calls. Sum usage across every step in a run, including retries and the ones that failed.
2. Hold effort constant per row. A Luna-at-max versus Sol-at-low table tells you nothing unless you say so in the header.
3. Log the cached token count separately. A tier comparison run on a cold cache flatters the expensive model, because the cheap model’s advantage is largest on repeated prefixes.

In practice this is one saved request, a variable for the model id, and an assertion on the usage fields. Apidog handles that shape well: define the call once, swap the model through an environment variable, and run the set as a scenario so the usage numbers land in one report instead of three terminal windows. The same scenario doubles as a regression check when a tier is repriced, which on this release cadence is a question of months.

The short version

Per token, Luna is a hundred times cheaper than Astra on input. Per task, on OpenAI’s own published benchmarks, the ranking is not that clean: Sol at xhigh effort beat Astra at low effort on AutomationBench while costing roughly a quarter as much, and Luna at max effort landed within striking distance of models costing ten times more per task.

Start at Luna, escalate on failure, reserve Astra for work where being wrong costs more than being slow. Then measure it yourself, because every number above was produced on somebody else’s workload.

For the wider picture across both launches in the same 48 hours, see our September 2026 AI model price war roundup.