Codex Model Selection skill for Codex

A model choice is done well when it is the lightest setting that meets an explicit quality bar on representative tasks, it is pinned where repeatability matters (automation, CI), and it is not hard-coded in places that break when a model retires.

Ground truth first

Model ids change and retire on a schedule. Before recommending a slug, check what this installation and account can use:

codex --version
codex debug models | jq -c '.models[] | select(.visibility=="list")
  | {slug, default: .default_reasoning_level, efforts: [.supported_reasoning_levels[].effort]}'

In a session, /model lists only models available to the signed-in account and workspace, and /status confirms the active model. API-key sessions follow the API organization’s model access instead of the ChatGPT plan.

Current lineup (official docs, October 2026)

Model	Slug	Positioning	Start with
GPT-6 Astra	gpt-6-astra	Most capable; hardest end-to-end work, broad context, judgment	low (shown as Light), raise if needed
GPT-6.1 Sol	gpt-6.1-sol	Near-Astra quality at lower cost; repeated and long-running work	client default, often medium
GPT-6.1 Terra	gpt-6.1-terra	Fast and efficient; writing, visual understanding, scoped fixes; needs CLI 0.159.0+	client default
GPT-6 Luna	gpt-6-luna	Most efficient; focused, high-volume, well-specified tasks	high

Retired for ChatGPT sign-in: gpt-5.5 (Oct 14 2026), gpt-5.4 and gpt-5.4-mini (Aug 31 2026), gpt-5.3-codex-spark (Sep 14 2026); gpt-5.2 and gpt-5.3-codex are deprecated. API-key sessions are not affected by these ChatGPT-plan retirements. Re-check the models page before relying on this table.

Decide

Task	Model	Effort
Rename, small refactor, lint fixes, extraction, formatting	Luna	low-medium
High-volume, well-specified batch jobs (classification, summaries)	Luna	medium-high
Typical feature or bug fix with tests	Sol	medium
Scoped fix with clear verification, docs writing, screenshot work	Terra	default
Unfamiliar codebase, cross-cutting refactor, design trade-offs	Astra or Sol	medium-high
Hard debugging with conflicting evidence, concurrency, security review	Astra	high-xhigh
Single extremely hard problem, time is not a concern	supporting model	max
Large task that splits into independent parts	supporting model	ultra (uses subagents)

Rules of thumb:

• Most tasks do not need max or ultra. max gives one agent more thinking time; ultra delegates parts of the task to subagents in parallel and multiplies usage. Luna supports up to max, not ultra.
• Raise effort before switching to a bigger model when the failure is shallow planning; switch model when the failure is missing knowledge or judgment.
• Lower effort when output is correct but slow.
• Effort levels do not map one-to-one across model generations; re-test after an upgrade.

Configure

# ~/.codex/config.toml
model = "gpt-6.1-sol"
model_reasoning_effort = "medium"     # low | medium | high | xhigh | max | ultra (model-dependent)
plan_mode_reasoning_effort = "high"   # used by /plan; unset = built-in preset
review_model = "gpt-6-astra"          # used by /review; defaults to the session model

Per profile (Codex 0.134.0+ uses one file per profile):

# ~/.codex/deep.config.toml   ->  codex --profile deep
model = "gpt-6-astra"
model_reasoning_effort = "high"

Per run:

codex -m gpt-6-luna -c model_reasoning_effort='"low"' "fix the lint errors in src/utils"
codex exec -m gpt-6.1-sol "summarize risky changes since v2.3.0"

Interactive: /model switches model; choose More reasoning… to reach max or ultra where supported. IDE extension: model switcher under the composer, or /model and /reasoning.

Speed tiers

/fast toggles the Fast service tier when the model’s catalog entry offers one; persist with service_tier = "fast". Fast mode consumes included plan usage at 2.5x the Standard rate (2x for purchased credits). Ultrafast (Astra and Sol on eligible plans) consumes 8x included usage (6x credits). Use them when a human is waiting, not for overnight batches.

Compare before standardizing

- [ ] 1. Pick 3-5 representative tasks with known-good outcomes
- [ ] 2. Fix the inputs, AGENTS.md and repo commit
- [ ] 3. Run candidate model/effort pairs, one variable at a time
- [ ] 4. Score: tests pass, diff size, review fixes needed, wall time, tokens
- [ ] 5. Keep the lightest setting that passes every task

For headless comparisons, capture usage from codex exec --json (the turn.completed event carries input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens):

# Run in a disposable clone: each iteration resets the working tree to $BASE.
for m in gpt-6-luna gpt-6.1-sol; do
  git reset -q --hard "$BASE" && git clean -fdq
  codex exec -m "$m" --sandbox workspace-write --json "$(cat ../task.md)" > "../run-$m.jsonl"
  npm test --silent >/dev/null 2>&1 && echo "$m tests: pass" || echo "$m tests: fail"
  jq -c 'select(.type=="turn.completed") | .usage' "../run-$m.jsonl"
  git diff --stat "$BASE" | tail -1
done

Never run that loop in a checkout with work you care about; ask before resetting anything outside a scratch clone.

Gotchas

• A retired slug in config.toml, a profile file, an SDK script or a CI job fails at start-up. Grep for model ids when a retirement is announced: rg -n 'gpt-5\.(2|3|4|5)' ~/.codex .codex .github scripts.
• model_reasoning_effort values the model does not advertise are rejected or ignored; check supported_reasoning_levels in the catalog.
• In the desktop app and IDE, the lowest effort is labelled Light; in config it is low.
• review_model and plan_mode_reasoning_effort silently change cost of /review and /plan; document them in team config.
• Higher effort is not a substitute for a precise prompt with done-criteria.

Output template

**Recommendation:** gpt-6.1-sol, effort medium (default); escalate to gpt-6-astra high
for tasks tagged `arch` or `security`.
**Evidence:** 5 tasks; Luna low failed 2/5 (missed edge cases), Sol medium passed 5/5
at 38% of Astra's tokens; Astra high passed 5/5, 2.1x slower.
**Config change:** model/model_reasoning_effort in ~/.codex/config.toml; deep profile
added at ~/.codex/deep.config.toml.