Skip to main content

05 - Codex: which model and how much reasoning to pick

Astra, Sol, Terra or Luna? The Codex models in November 2026, plan limits, credits and how to pick a reasoning level without wasting quota.

What do you think about this article?

05 - Codex: which model and how much reasoning to pick
OpenAI Codexfedericocalo.dev

At a Glance

Astra, Sol, Terra or Luna? The Codex models in November 2026, plan limits, credits and how to pick a reasoning level without wasting quota.

You have Codex installed and a task in front of you, and before writing the prompt you have to decide two things: which model, and how much reasoning. The Codex documentation, opened on 13 November 2026, lists four models: Astra (the most capable), 6.1 Sol (performance close to Astra at lower cost), 6.1 Terra (fast, suited to writing and on-screen work) and 6 Luna (the most efficient, for focused, repeated tasks). The criterion the same source proposes is to keep the lightest setting that meets your quality threshold. In practice: start from Sol for real work, drop to Luna for anything bounded (small edits, extraction, triage), and go up to Astra only when the task is ambiguous and a mistake costs more than the price difference.

The choice shows up on the bill: in the credit price list, a million output tokens cost 250 credits on Sol and 12.5 on Luna, twenty times less. The flip side is that the cheap model gets complex tasks wrong more often, and a failed attempt costs its price plus your time. Part five of the OpenAI Codex series; it helps to have read part 4, because the settings we discuss live in the config.toml file.

The numbers come from the Pricing, Models and Model selection pages, which the price list itself calls estimates, and model names rotate every few weeks. I have not measured the quality of any model and I am not affiliated with OpenAI.

The four models, as the source describes them

ModelIdentifierDescription in the documentation
Astragpt-6-astraThe most capable for complex work across code, apps and research; advanced reasoning, computer use, stronger judgment
6.1 Solgpt-6.1-solPerformance close to Astra at lower cost; suited to repeated, long-running work. Default context of 500,000 tokens in Codex
6.1 Terragpt-6.1-terraFast and efficient for clear writing, visual understanding and computer use. Requires Codex CLI 0.159.0 or later
6 Lunagpt-6-lunaThe most efficient for focused, high-volume tasks: summarization, extraction, focused coding

The limits table and the credits table contain other rows as well, and here the names are confusing. "GPT-6 Sol" (gpt-6-sol) is the indicated replacement for the retired gpt-5.4; the "GPT-5.6 Sol", "Terra" and "Luna" rows carry a lower version number and have different rates (Sol 5.6: 100 credits for input and 500 for output per million tokens). On the GPT-5.6 Sol row the Pricing page warns that the promotional rate is valid at least through 21 November 2026. If a script or a calculation uses one of these names, check that it is the right row: the generation name changes the price.

Reasoning is a second dial, and it costs

The effort levels are Light, Medium, High and Extra High, plus two modes: Max, which gives the model more time on a single task, and Ultra, which uses subagents for the separable parts of the work. Luna goes up to Max and does not support Ultra; some paid plans do not include Extra High for Astra. In the desktop app and the IDE extension the lowest level is called Light, in the CLI it is called Low. You change it in the session with /model (then "More reasoning…" to see Max and Ultra), or at startup with codex --model gpt-6.1-sol, or permanently in config.toml.

The Models page also gives the starting points: for Sol, the default level of your client; for Luna, High; for Astra, Light. It explains why the logic is not "more reasoning is better": higher effort can improve results on complex tasks, but it takes more time and consumes more tokens. On "add this test", reasoning more wastes quota; on "find why this calculation diverges in production", the waste is not doing it. The same page warns that the levels do not correspond exactly from one model generation to the next, so yesterday's "High" is not today's "High": retry a task you know at a lower level and adjust based on the result.

The two properties in the configuration file

In the config.toml file (the same for the desktop app, the CLI and the IDE extension) the settings are two top-level keys. model is a string with the model identifier, for example "gpt-6.1-sol"; if you do not write it, the client uses a recommended model that changes with versions, so two colleagues without the key can work with different models. model_reasoning_effort is a string with the level the model declares: low, medium, high, xhigh, max or ultra, with the available levels depending on the model and the client.

Mind the name: "Extra High" in the interface is xhigh in the file. The default value of the second key is not a fixed number in the documentation: it depends on the chosen model, which is why it is worth writing it when you want repeatable results.

Why write these particular values? Because a project file that fixes model and level makes the cost predictable and the comparison between two runs meaningful. What goes wrong is shown by the test file below: a retired name (the section on retirements lists six) fails or falls back to another model, and a level written the way you see it in the interface rather than the way the file wants it is not among the documented values. The script reads a config.toml in text form with tomllib and compares the values with the sets that the Models and Configuration Reference pages declare; the two lists at the top of the file are a copy of the documentation of 13 November and must be updated when it changes. It does not run Codex and does not read your real file.

# Check a sample config.toml against what the Codex documentation
# (Models and Configuration Reference pages, 13 November 2026) declares.
import tomllib

DOCUMENTED_EFFORTS = {"low", "medium", "high", "xhigh", "max", "ultra"}
RETIRED_MODELS = {"gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark"}

def check(name, text):
    cfg = tomllib.loads(text)
    problems = []
    model = cfg.get("model")
    if model is None:
        problems.append("model missing: the client picks the recommended model")
    elif model in RETIRED_MODELS:
        problems.append(f"model = {model!r} is among the retired models")
    effort = cfg.get("model_reasoning_effort")
    if effort is not None and effort not in DOCUMENTED_EFFORTS:
        problems.append(f"model_reasoning_effort = {effort!r} is not among the documented values")
    outcome = "; ".join(problems) if problems else "no problem found"
    print(f"{name}: {outcome}")

check("daily-work", 'model = "gpt-6.1-sol"\nmodel_reasoning_effort = "medium"\n')
check("narrow-tasks", 'model = "gpt-6-luna"\nmodel_reasoning_effort = "high"\n')
check("effort-only", 'model_reasoning_effort = "low"\n')
check("old-guide", 'model = "gpt-5.4"\nmodel_reasoning_effort = "extra-high"\n')

# Output:
# daily-work: no problem found
# narrow-tasks: no problem found
# effort-only: model missing: the client picks the recommended model
# old-guide: model = 'gpt-5.4' is among the retired models; model_reasoning_effort = 'extra-high' is not among the documented values

The first two lines of the output are the healthy cases, where the only thing to note is the choice of Luna with high, the starting point the page indicates for that model. The third shows the model property omitted, which the script flags because the choice passes to the client. The last line shows a configuration copied from an old guide, and it has to be fixed at the two points the script names. It is a check of form: it does not tell you whether the model is available on your plan, and only your dashboard can show that.

Limits per plan, in messages

For Plus and Standard Business, the limits are expressed as local messages every five hours, with weekly limits that may apply on top. Values from the Pricing page (estimates, ranges):

ModelLocal messages per 5 hours (Plus / Standard Business)
GPT-6 Astra5-45
GPT-6.1 Sol15-160
GPT-6 Sol15-150
GPT-6.1 Terra35-285
GPT-6 Luna350-3,000

The width of the ranges is the most important piece of information: the source says it depends on the model, on the size and complexity of the tasks, on the context, on the tools used and on the cache, and that prompt length alone is not enough to estimate consumption. Pro plans, for now, have no five-hour limit; Enterprise and Edu plans with flexible pricing have no fixed limits and scale with credits. Fast mode consumes 2.5 times the included usage (2 times with purchased credits); Ultrafast 8 times for Astra and for 6.1 Sol (6 times with purchased credits). If speed is a luxury and not a necessity, leave it off.

To know where you stand, the usage dashboard of the account shows limits and reset times, and in a CLI session the /status command shows how much is left. If you hit the limit in the middle of a turn, the page says the agent may continue that turn, within fair use.

Credits: what it costs to go beyond

Once the included quota is used up, credits pay for usage. The rates are in credits per million tokens (input, cached input, output), at Standard speed:

ModelInputCached inputOutput
GPT-6 Astra250251,250
GPT-6.1 Sol502.5250
GPT-6.1 Terra251.25125
GPT-6 Luna2.50.2512.5

The page specifies that Codex credits have no separate line for cache writes, and that API token prices are a different matter: they are not for estimating how many tasks the subscription includes. To see the order of magnitude I wrote a script that applies the table to a hypothetical session: 200,000 input tokens and 20,000 output tokens. The tokens are my choice, not a measurement, and the results depend only on them. The calculation uses exact fractions (Fraction), so rates with a decimal part, like 2.5 or 1.25, do not accumulate rounding errors; the credits function multiplies each item by its rate and divides by a million. The second scenario moves 180,000 of the input tokens into the cache, an assumption of a stable prefix that in practice depends on how you work.

# Compute the credit cost of a session from the Pricing page rates
# (credits per million tokens, Standard speed).
from fractions import Fraction as F

# model: (input, cached input, output) - data copied from the
# "Token rates" table read on 13 November 2026
RATES = {
    "GPT-6 Astra":   (F(250),  F(25),    F(1250)),
    "GPT-6.1 Sol":   (F(50),   F(5, 2),  F(250)),
    "GPT-6.1 Terra": (F(25),   F(5, 4),  F(125)),
    "GPT-6 Luna":    (F(5, 2), F(1, 4),  F(25, 2)),
}

def credits(model, new_in, cached_in, out):
    r_in, r_cache, r_out = RATES[model]
    millions = F(1, 1_000_000)
    return (new_in * r_in + cached_in * r_cache + out * r_out) * millions

def show(x):
    return f"{float(x):g}"

print("Session A: 200,000 new input tokens, 20,000 output tokens")
for name in RATES:
    print(f"  {name:14s} {show(credits(name, 200_000, 0, 20_000)):>6s} credits")

print("Session B: same tokens, but 180,000 of the 200,000 input tokens are cached")
for name in RATES:
    print(f"  {name:14s} {show(credits(name, 20_000, 180_000, 20_000)):>6s} credits")

print("Output ratios relative to Sol 6.1")
sol = RATES["GPT-6.1 Sol"][2]
for name, (_, _, o) in RATES.items():
    print(f"  {name:14s} {show(o / sol)}x")

# Output:
# Session A: 200,000 new input tokens, 20,000 output tokens
#   GPT-6 Astra        75 credits
#   GPT-6.1 Sol        15 credits
#   GPT-6.1 Terra     7.5 credits
#   GPT-6 Luna       0.75 credits
# Session B: same tokens, but 180,000 of the 200,000 input tokens are cached
#   GPT-6 Astra      34.5 credits
#   GPT-6.1 Sol      6.45 credits
#   GPT-6.1 Terra   3.225 credits
#   GPT-6 Luna      0.345 credits
# Output ratios relative to Sol 6.1
#   GPT-6 Astra    5x
#   GPT-6.1 Sol    1x
#   GPT-6.1 Terra  0.5x
#   GPT-6 Luna     0.05x

On the Sol model the same session costs 15 credits, on Luna 0.75, on Astra 75: the ratios are those of the table. The second scenario shows how much the cache weighs: on Sol the session drops from 15 to 6.45 credits, because a cached token costs one twentieth of a new one (2.5 against 50). The Pricing page reports a typical task on GPT-5.6 Sol of 2-15 credits, but for a typical task on 6.1 Sol it gives no figure. I cannot give a conversion into currency: the page does not say what a credit is worth, and I do not make it up. Plus and Pro can buy additional credits when they reach the limits; Business, Edu and Enterprise with flexible pricing buy workspace credits.

The cache rewards whoever keeps the beginning of the context stable. An AGENTS.md that does not change from one session to the next (part 4) is exactly that prefix, and for the same reason the Pricing page recommends keeping it small in large projects and turning off the MCP servers you do not need, because each one adds context to every message. I have not measured the effect on real costs: it is a deduction from the rates.

How to choose, in practice

  • Daily work on real code: Sol with Medium reasoning. The selection guide associates it with complex technical work and with products you expect to review, and suggests comparing it with Astra on the same task.
  • Narrow, repeated tasks (renaming, extracting data, triaging reports, bounded edits): Luna, twenty times cheaper on output. The subagents guide suggests Luna for fast, read-only agents (part 7).
  • Concise writing from supplied material, bounded corrections, on-screen computer use: Terra, to compare with Sol at equal input and level.
  • Ambiguous problems, deep analysis, high risk: Astra. The page says that if cost and latency do not matter, you can use Astra as the default; for anyone paying by quota, cost and latency almost always matter.

The order of the items follows the rising risk of the task, not the price, but the two coincide: the higher you go, the more you pay and the longer you wait. The criterion that ties them together is always the same, the quality threshold you need. The page indicates how to measure it: choose the acceptance criteria first, run regression tests for code, and measure also the time spent reviewing or repairing the result, not only the generation time. Run the same prompt on Luna and on Sol, on three tasks already solved in your repository and with a test that defines "done". If Luna passes them, for that class of work you have saved an order of magnitude; if it fails, you have the measure of what you buy by going up. Note the result with the date and redo it when the price list changes.

Recent retirements: why not to copy names from an old guide

  • gpt-5.4 and gpt-5.4-mini: retired from Codex with ChatGPT sign-in on 31 August 2026. Indicated replacements: gpt-6-sol and gpt-6-luna, where available on your plan.
  • gpt-5.3-codex-spark: retired on 14 September 2026.
  • GPT-5.5: retired from Codex with ChatGPT sign-in on 14 October 2026, at 12:00 PDT (19:00 UTC); sessions with an API key do not change. Replacements: 6.1 Sol for Plus, Pro, Business, Enterprise and Edu; 6 Luna for Free and Go.
  • gpt-5.2 and gpt-5.3-codex: already deprecated with ChatGPT sign-in, with no retirement date on the page.

If a script, a custom agent or a configuration file pins one of these names, by now it fails or falls back to another model without telling you; the Models page asks you to replace them in workspace settings and in scheduled tasks as well. Search for model names in your files with a simple grep once a month, or use the script from the configuration section: it is one of the cheapest and most useful maintenance chores. With an API key, availability instead follows the organization and the project of the API, and GPT-5.5 remains available.

Frequently asked questions

Which Codex model should I use by default?

For daily work on real code, 6.1 Sol with medium reasoning; Luna for narrow, repeated tasks, because it costs one twentieth on output; Astra only for ambiguous problems where a mistake costs more than the price difference.

Why do model names in an old guide not work?

Because models are retired every few weeks: gpt-5.4 and gpt-5.4-mini on 31 August 2026, GPT-5.5 on 14 October 2026 for ChatGPT sign-in. Check the Models page before copying an identifier.

What is not demonstrated here

I have not compared the quality of the models or measured how many messages a real task consumes. I do not know what a credit is worth in currency. I could not verify the contexts of Astra, Terra and Luna because the page declares only that of Sol. The limits are estimates from the source; your account's usage dashboard is the only measure that counts for you. The two scripts run without Codex, on data copied from the pages: they prove the arithmetic and the shape of the file, not the behavior of the tool.

The same series also includes installation and the first task (part 2), sandbox and approvals (part 3), cloud, subagents, skills and MCP (part 7) and the comparison with Claude Code, Copilot and Cursor (part 8).

Sources

  • Pricing - limits per model, credit rates, Fast and Ultrafast modes, GPT-5.6 Sol promotion, consulted on 2026-11-13
  • Models - descriptions, identifiers, reasoning levels, retirements and replacements, the model key in config.toml, consulted on 2026-11-13
  • Model selection - criteria for choosing and comparing models, consulted on 2026-11-13
  • Configuration Reference - values of model_reasoning_effort, consulted on 2026-11-13
  • Subagents - models suggested for subagents, consulted on 2026-11-13

The pages were downloaded in full and read at the passages cited. The scripts were run with Python 3.14 (python3 -I), twice each, with identical output; the cost results were confirmed with a second floating-point calculation.

← Part 4: AGENTS.md and config.toml Part 6: codex exec and the SDK →

Commenti

Caricamento commenti...

Sign in to comment

New articles and tools on Telegram too

The Telegram channel flags the site's new articles and tools.

Did you like this article?

Explore other content on the blog or discover my projects