GPT-6 Luna vs GPT-5.6 Luna: Calculating the Real Cost of a Successful Codex Task

You are not trying to decide which Luna generation sounds newer; you need to know which model should run the next batch of Codex tasks and when to switch after a failure. By the end, you can choose a first candidate from per-attempt cost, then use acceptance rate, retries, and manual-repair time to calculate the real cost of each successful task.

Start here: test gpt-6-luna first for most automatically verifiable tasks

gpt-6-luna is the better first candidate when the scope is clear and tests, lint, or an acceptance script can reject a bad result quickly. Its lower per-attempt token cost lets you build a baseline cheaply, then decide whether complex work should move back to gpt-5.6-luna.

Your situation	What to do first	What would change the recommendation
Small fixes or batch changes with automated tests	Start with gpt-6-luna	It fails repeatedly, or manual repair erases the price advantage
Cross-file features, refactors, or interface changes	Run paired tests on both models	Use gpt-5.6-luna for this class if it materially cuts retries and repair time
Input is near or above 272K	Remove irrelevant files, shorten history, or split the task first	If context cannot be reduced, compare with long-context rates
You are using ChatGPT or Codex plan allowances	Use the plan dashboard and credit rules, not the API table	Apply the token prices below only after moving to an API key or custom provider

Public information does not yet include paired results for both models on the same Codex version, repository, and reasoning effort. Price can determine your testing order, but your own task data should determine the default model.

The interface limits are similar, so they do not predict coding quality

The two models have similar core interfaces and context limits, so the specification sheet cannot tell you which one will be more reliable in your codebase. Both support text and image input, text output, the Responses API, reasoning tokens, and reasoning effort from none through max; each has a 1,050,000-token context window, a maximum input of 922,000 tokens, and a maximum output of 128,000 tokens.

Item	gpt-6-luna	gpt-5.6-luna
Official positioning	Efficient model for focused, high-volume tasks	Model for cost-sensitive, high-volume workloads
Knowledge cutoff	2026-05-18	2026-02-16
Context window	1,050,000 tokens	1,050,000 tokens
Default reasoning effort	medium	medium

Those specifications do not prove that either model will have a higher acceptance rate, finish faster, or require fewer retries in your codebase. Codex outcomes also depend on task shape, context quality, tool permissions, client version, reasoning effort, and the acceptance criteria you apply.

Below 272K, gpt-6-luna has the lower token rates

When complete input context is at or below 272K, gpt-6-luna costs half as much for input, cache reads, and cache writes, while its output rate is about 41.7% of gpt-5.6-luna. The table was verified on 2026-09-25, uses USD per 1 million tokens, and compares only OpenAI Standard with BetterToken API billing—not ChatGPT or Codex plan allowances or credit billing.

At or below 272K: calculate directly from this table

Use this tier directly when the complete input context of each request stays at or below 272K; do not apply the long-context multipliers.

Model ID	Provider	Input	Cache read	Cache write	Output
gpt-6-luna	OpenAI Standard	$0.10	$0.01	$0.125	$0.50
gpt-6-luna	BetterToken	$0.068	$0.0068	$0.085	$0.34
gpt-5.6-luna	OpenAI Standard	$0.20	$0.02	$0.25	$1.20
gpt-5.6-luna	BetterToken	$0.136	$0.0136	$0.17	$0.816

BetterToken prices are dynamic, so view current prices on the day you publish or buy and use the values shown then. BetterToken is not an OpenAI product. The prices above are for its GPT group used through APIs, Codex, and tools that support a custom Base URL; they are not ChatGPT or Codex subscription allowances.

OpenAI Batch and Flex are priced at 50% of Standard for these models, so they are lower than the BetterToken rates shown here. They are outside this comparison. The table must not be read as a claim that BetterToken is cheaper than every OpenAI processing option.

Above 272K: reduce the input first, then use long-context rates if needed

If the task can be split, remove irrelevant files, shorten history, or divide the work before crossing the threshold because the entire request becomes more expensive. The threshold uses the complete input context, including cached portions; above 272K, input, cache reads, and cache writes cost 2× the short-context rate, while output costs 1.5×:

Model ID	Provider	Input	Cache read	Cache write	Output
gpt-6-luna	OpenAI Standard	$0.20	$0.02	$0.25	$0.75
gpt-6-luna	BetterToken	$0.136	$0.0136	$0.17	$0.51
gpt-5.6-luna	OpenAI Standard	$0.40	$0.04	$0.50	$1.80
gpt-5.6-luna	BetterToken	$0.272	$0.0272	$0.34	$1.224

Separate four token categories to reproduce the cost of one attempt

To calculate one Codex attempt, keep uncached input, cache reads, cache writes, and output separate. The shared usage profile below demonstrates the method; replace these hypothetical numbers with your own billing details to get your actual per-attempt cost:

• 32,000 uncached input tokens;
• 160,000 cache-read tokens;
• 16,000 cache-write tokens;
• 8,000 output tokens;
• a complete input context at or below 272K for every request, so short-context rates apply.

The formula is:

Task cost = uncached input / 1,000,000 × input price
          + cache read / 1,000,000 × cache-read price
          + cache write / 1,000,000 × cache-write price
          + output / 1,000,000 × output price

Model ID	Provider	Input cost	Cache-read cost	Cache-write cost	Output cost	Total per attempt
gpt-6-luna	OpenAI Standard	$0.003200	$0.001600	$0.002000	$0.004000	$0.010800
gpt-6-luna	BetterToken	$0.002176	$0.001088	$0.001360	$0.002720	$0.007344
gpt-5.6-luna	OpenAI Standard	$0.006400	$0.003200	$0.004000	$0.009600	$0.023200
gpt-5.6-luna	BetterToken	$0.004352	$0.002176	$0.002720	$0.006528	$0.015776

With this hypothetical token structure, one gpt-6-luna attempt costs about 46.6% of one gpt-5.6-luna attempt. BetterToken applies the same price multiplier to both models, so the ratio between the two models is identical on both providers. This is still a cost per attempt, not a cost per successful task.

Count cache reads separately or you will overstate or understate cost

Do not charge cache reads at the ordinary input rate, and do not omit them from the bill. Codex repeatedly reads repository context, conversation history, and tool output; cached tokens are usually cheaper, but their volume can be large, so one combined “input” number gives the wrong answer.

For every run, retain separate values for input, cached input, cache write, and output. If an access layer exposes only a final dollar amount and not the four token categories, it becomes much harder to explain why one model or task costs more than another.

Choose the default model by cost per successful task

A cheaper call does not guarantee a cheaper completed task; include the API cost of failures, rollbacks, and retries. The more useful metric is:

Cost per successful task = total API cost of all attempts / accepted tasks

Track at least these dimensions:

• Acceptance rate: the share of tasks that pass the predefined criteria without a developer rewriting the solution;
• Retries: repeated prompts, rollbacks, or fresh model runs for the same task;
• Elapsed time: time from task start to an acceptable diff, not merely first-token latency;
• Manual repair: whether and how long a developer had to edit generated code;
• Token mix: uncached input, cache reads, cache writes, and output.

Using the hypothetical OpenAI Standard costs above, the per-attempt ratio is 0.010800 / 0.023200 ≈ 46.6%. If the token profile stayed identical, gpt-6-luna would still have a lower expected API cost whenever its acceptance rate exceeded roughly 46.6% of the gpt-5.6-luna acceptance rate. This is only a break-even relationship derived from hypothetical prices, not a measured quality claim. The threshold changes when token use, retries, or task mix changes.

Fix five conditions before trusting the comparison

Running each model once is not a valid comparison; both must start from the same state, receive comparable tasks, and face the same acceptance criteria. These five steps reduce bias from caching, run order, and human judgment.

1. Freeze the environment

Use the same Codex version, starting Git commit, configuration, tool permissions, reasoning effort, prompt, and acceptance command for both models. Do not call one model through OpenAI Standard and the other through a different access path, then attribute every latency or failure difference to the model.

2. Separate task categories

At minimum, keep three task classes distinct:

Task class	Example	Suggested acceptance criteria
Small fix	A well-defined defect in one or a few files	Targeted tests pass; unrelated files remain unchanged
Cross-file change	Feature, refactor, or coordinated interface change	Full tests and lint pass; requested behavior is present
Review and diagnosis	Find a bug, explain risk, propose a fix	Finds the known issue and points to concrete code evidence

Do not collapse all three into one average. Two models may be nearly equal on small fixes but differ materially in retry rate on cross-file work.

3. Define acceptance before running the model

Before testing, fix the required tests, allowed directories, dependency policy, and failure conditions. Lowering the bar after seeing an output makes the acceptance rate meaningless.

4. Alternate model order

Do not always run the same model first. Alternate the order, or use equivalent independent tasks when possible, so first-run caching, environment repair, and operator familiarity do not systematically favor one model.

5. Preserve per-task records

A useful row contains: task ID, task class, model ID, provider, processing tier, reasoning effort, start and end time, the four token categories, attempt count, pass/fail result, failure reason, manual-repair minutes, and final cost. Aggregate by task class only after retaining the raw rows.

When to keep gpt-6-luna and when to switch to gpt-5.6-luna

Keep gpt-6-luna as the default candidate while its acceptance rate remains high enough to preserve the price advantage and manual-repair time is comparable. When the results differ by task class, route the work instead of forcing one global model on every task.

What you observe	Recommended action
gpt-6-luna acceptance exceeds roughly 46.6% of gpt-5.6-luna acceptance, with similar token profiles and repair time	Keep gpt-6-luna; its expected API cost is lower
gpt-6-luna falls below that break-even point, or retries and repair make total cost higher	Move that task class to gpt-5.6-luna
gpt-6-luna wins on small fixes but gpt-5.6-luna causes less rework on cross-file changes	Route by task class rather than choosing one universal default
The difference mostly comes from provider latency, errors, or rate limits	Rerun through the same access path before blaming the model
Input frequently exceeds 272K	Optimize context and test again; do not treat a pricing-tier jump as a quality difference

The 46.6% threshold applies only to the hypothetical token profile above. If output length, cache usage, or retry count differs, recalculate the break-even point from each model’s actual per-attempt cost.

Recommendation: baseline with gpt-6-luna, then decide from successful-task cost

If you must choose one model today, start clear, automatically verifiable work with gpt-6-luna. Keep a representative sample of complex tasks for a same-condition gpt-5.6-luna control; do not stop at comparing the price of one call.

After a batch of comparable tasks, calculate acceptance rate, average retries, manual-repair time, and cost per successful task. Keep gpt-6-luna as the default when it remains cheaper; if gpt-5.6-luna removes enough rework to cover its higher token rate for a specific task class, route only that class to it.

Official references

Use these three official pages to recheck model specifications and OpenAI pricing.

• GPT-6 Luna model page
• GPT-5.6 Luna model page
• OpenAI API pricing