Best Model for Codex: GPT-6.1 Sol, GPT-6 Luna or GPT-5.6?

Short answer: use GPT-6.1 Sol for complex coding and agent work, and GPT-6 Luna for focused, repeatable tasks. GPT-6.1 Sol (gpt-6.1-sol) is the model Codex recommends now for hard work; OpenAI describes it as near-Astra performance at a lower cost than Astra. GPT-6 Luna (gpt-6-luna) is the pick for narrow jobs you can check automatically, and you take GPT-6 Astra when you need OpenAI's most capable model. GPT-5.6 Sol, Terra and Luna still work during the rollout, and the comparison below helps you choose among them.

Updated October 24, 2026: added GPT-6.1 Sol and GPT-6 Luna, which Codex now recommends.

Which model does Codex recommend now?

Codex's model guide now names GPT-6.1 Sol for complex coding and agentic work, and GPT-6 Luna for focused, repeatable tasks (checked October 24, 2026). GPT-6 Astra stays OpenAI's most capable model, at five times the input and output price of GPT-6.1 Sol.

Those are standard API prices in USD per million tokens. All three models take a 1,050,000-token context window and return up to 128,000 output tokens. GPT-6.1 Sol is the value pick in the family: $2 input and $10 output costs the same as GPT-5.6 Terra on input and less on output. A run that reports 100,000 input and 20,000 output tokens costs $0.40 on GPT-6.1 Sol and $2.00 on GPT-6 Astra.

To switch, type /model in an interactive CLI session, or name the model when you start Codex:

codex --model gpt-6.1-sol
codex exec -m gpt-6.1-sol "Run the tests and explain any failure"

GPT-5.5 no longer works in Codex for ChatGPT sign-in as of October 14, 2026; API-key sessions are unaffected. If your saved commands still name it, move them to gpt-6.1-sol first.

Sol vs Terra vs Luna at a glance

Within GPT-5.6, the strongest model for Codex depends on the shape of the task. Choose GPT-5.6 Sol when the work is ambiguous, difficult, or expensive to get wrong. Choose GPT-5.6 Terra for normal feature work, debugging, tests, and refactors. Choose GPT-5.6 Luna for clear, repeatable, high-volume work with objective checks.

If you are unsure and quality matters more than latency or token cost, start with Sol. Do not leave every task there by habit. The practical strategy is to find the cheapest model and lowest reasoning effort that still passes the same repository test.

If Luna is your likely tier, the Claude Haiku 4.5 vs GPT-5.6 Luna coding comparison adds the direct low-cost cross-provider rates, caching math, context limits, and a reproducible test you can copy.

Within GPT-5.6, the short answer is Sol for depth, Terra for daily work, Luna for throughput. These are task roles, not quality labels that apply to every prompt.

Codex is the agent; GPT-5.6 is the model family

Codex is the coding agent that gathers repository context, calls tools, applies patches, asks for approvals, and runs checks. Sol, Terra and Luna are the GPT-5.6 models you can still pick in Codex. A model comparison should not be confused with the separate Claude Code vs Codex product comparison.

The harness still affects the result. The same model can behave differently when one run has AGENTS.md or equivalent repository instructions, shell access, a writable sandbox, and a deterministic test command while another run has only a pasted code snippet. Compare models inside the same Codex client and permission profile whenever possible.

OpenAI documents gpt-5.6 as an alias for gpt-5.6-sol. Exact IDs are better for evaluations and automation because they make the selected tier visible:

gpt-5.6-sol
gpt-5.6-terra
gpt-5.6-luna

Specifications and direct OpenAI API prices

These are the GPT-5.6 rates that still apply during the rollout; the GPT-6 rates are in the table above.

Prices are direct OpenAI standard API rates in USD per million tokens for the short-context case. They are not OmniaKey retail rates. Check the three model pages and the live model catalog for current OmniaKey availability and pricing before setting a production budget.

All three models list text and image input, text output, streaming, structured outputs, function calling, prompt caching, and Responses API support. Provider-native tools or ChatGPT features do not automatically become available through every custom provider, client, or gateway. Verify the exact path you plan to use.

For requests above 272K input tokens, OpenAI currently charges twice the short-context input rate and 1.5 times the short-context output rate for the full request. Cache writes cost 1.25 times uncached input. A shared 1.05M context window therefore does not mean that filling it is equally economical or useful on every task.

Choose Sol for difficult, open-ended work

Sol is OpenAI's frontier GPT-5.6 tier and the strongest first choice when the model must discover the path rather than follow one. Start with Sol when:

• the root cause crosses services, queues, databases, or permission limits;
• requirements conflict or important constraints are unstated;
• a migration affects billing, authentication, security, or durable data;
• the repository has weak tests and the model must first reproduce the failure;
• review quality matters more than response speed;
• a plausible but wrong answer would be expensive to unwind.

OpenAI's Codex guidance now gives that role to GPT-6.1 Sol. Inside GPT-5.6, Sol is still the tier for complex, open-ended, high-value work that needs extra analysis, judgment or polish. It is also the only member of this family currently listed for Codex cloud. That makes Sol the simplest GPT-5.6 default when a cloud task is a hard requirement.

Sol is not automatically the best choice for every large repository. Repository size is not task difficulty. A well-scoped change in a large monorepo can still be a Terra task, while a ten-line authorization bug in a small service can justify Sol.

Choose Terra for everyday coding

Terra is the pragmatic default once the task is understood. OpenAI positions it as the balanced GPT-5.6 model for everyday work, with capability competitive with GPT-5.5 at lower cost. Start with Terra when:

• implementing a feature from clear pass/fail criteria;
• fixing a reproducible bug with a focused test;
• writing or updating unit and integration tests;
• refactoring across known call sites;
• reviewing a normal pull request;
• maintaining documentation, types, and configuration alongside code.

Terra's direct short-context input rate is half of Sol's, and its output rate is 60% of Sol's. For teams running many ordinary coding tasks, that gap is large enough to make Terra the better starting point even when Sol can also complete the work.

Escalate from Terra when it repeats the same failed approach, misses a cross-system constraint, cannot explain the root cause, or produces a patch that passes narrow tests but does not satisfy the real requirement. Escalation should be tied to what the model can prove, not to the number of files in the diff.

If the open question is Terra versus Claude's daily default rather than Terra versus Sol, use the Claude Sonnet 5 vs GPT-5.6 Terra coding comparison. It compares protocol fit, long-context billing, and completed-task cost without turning this family selector into a cross-provider ranking.

Choose Luna for clear, repeatable work

Luna is the fast, cost-sensitive tier. It is a strong fit when both the input and the definition of done are precise:

• classify issues or assign tickets using a fixed schema;
• extract fields from logs, reports, or source files;
• transform repetitive configuration or documentation;
• make isolated mechanical edits with deterministic tests;
• summarize bounded search results for a parent task;
• run high-volume checks where false positives and misses are measured.

Luna is not the right default for ambiguous architecture, subtle security review, or an unexplained production failure. A cheap failed run followed by Terra or Sol can cost more than starting at the appropriate tier.

The safest Luna tasks are reversible and easy to verify. Give the model explicit inputs, an output schema, stop conditions, and a deterministic pass/fail check.

What one representative task costs

Consider an uncached run that reports 100,000 input tokens and 20,000 output tokens. It stays below the 272K long-context threshold.

This arithmetic is not a completed-task benchmark. It excludes cache writes, built-in tool charges, retries, variable reasoning usage, and developer correction time. The useful metric is:

completed-task cost = successful run
                    + failed attempts
                    + retries and tool charges
                    + human correction time

Luna wins only when it still produces an accepted result. Sol can be cheaper for a difficult task if it avoids several failed lower-tier attempts.

Adjust reasoning effort before changing everything else

Model tier and reasoning effort are separate controls. OpenAI recommends using the lowest effort that produces the required result and increasing it for work that needs more planning, analysis, or checking.

A practical sequence is:

1. Start a familiar task at the model's normal or medium setting.
2. If the answer is directionally right but under-investigated, raise effort on the same model.
3. If the model cannot resolve the problem or misses required judgment, move up a tier.
4. If it passes comfortably, repeat at lower effort or on a cheaper tier.
5. Change one variable at a time so the result remains interpretable.

Do not assume a high-effort Luna run equals Sol, or that low-effort Sol equals Terra. Measure the accepted outcome, latency, tokens, and correction time for each configuration.

Local Codex and Codex cloud are different surfaces

OpenAI currently lists all three GPT-5.6 models for Codex CLI and the IDE extension. Sol is also listed for Codex cloud; Terra and Luna are not. Availability may also depend on whether Codex uses ChatGPT sign-in, an OpenAI API key, or a custom provider.

With API-key billing, usage follows API rates rather than included ChatGPT plan credits. A custom provider can expose supported models to local Codex through a compatible Responses endpoint, but that does not unlock ChatGPT-only or cloud-only features.

Use the OmniaKey Codex CLI guide for supported configuration. If the model lists correctly but a stream or tool call fails, use the GPT-5.6 compatibility kit. Model selection is here; setup and troubleshooting are in the kit.

A practical routing policy

Store the selected model ID, effort, task class, and verification command with the result. Without those fields, a team cannot tell whether a later regression came from the model, the prompt, the harness, or the repository.

How to switch models in Codex

In an interactive Codex CLI session, use /model. For a fresh CLI run, pass the exact model:

codex --model gpt-5.6-sol
codex --model gpt-5.6-terra
codex --model gpt-5.6-luna

The same selector works with non-interactive runs, for example:

codex exec -m gpt-5.6-terra "Run the repository checks and explain any failure"

These commands select a model; they do not configure authentication or a provider. Complete the supported setup first. Use exact IDs for saved tasks and evaluations, and treat the gpt-5.6 alias as Sol only when that moving family default is acceptable. For the GPT-6 models, swap in gpt-6.1-sol, gpt-6-luna or gpt-6-astra.

Evaluate on accepted repository changes

Build a small task set from work your team actually performs:

1. A routine implementation with deterministic tests.
2. A reproducible bug whose root cause crosses at least two modules.
3. A mechanical transformation across many files.
4. A review task with known seeded defects.
5. A risky architecture or migration decision.

Run each task from the same commit with the same instructions, tools, permissions, and checks. Repeat runs because agent results vary. Record pass rate, elapsed time, input and output tokens, tool calls, retries, and human correction minutes.

Promote Terra or Luna only where they match Sol's accepted result. Keep Sol where the additional judgment changes the outcome. This produces a selection policy based on your repository rather than a generic leaderboard.

For the broader provider decision, use the coding-model family guide. It compares Claude, GPT, and Gemini without mixing that question into this GPT-5.6 selector.

Final verdict

GPT-6.1 Sol is the model Codex recommends now for complex, open-ended work. GPT-6 Luna is the default for fast, repetitive, objectively verifiable tasks, and GPT-6 Astra is there when the work needs OpenAI's most capable model. Inside GPT-5.6, Sol is still the strongest tier, Terra the everyday default and Luna the cheapest.

Start with the task's risk and ambiguity, not the largest model name. Then use your own results to move repeated work toward the cheapest tier and lowest effort that remains reliable.

Frequently asked questions

Which model should I pick in Codex right now?

GPT-6.1 Sol for complex coding and agent work, GPT-6 Luna for focused, repeatable tasks you can check automatically, and GPT-6 Astra when you need OpenAI's most capable model. The GPT-5.6 tiers still work during the rollout if your team already standardized on them.

What is the best GPT-5.6 model for Codex?

Choose Sol when unsure or when the task is complex and open-ended. Choose Terra for everyday feature work, debugging, tests, and refactors. Choose Luna for clear, repeatable, high-volume tasks with objective checks.

Is GPT-5.6 Sol still the Codex default?

Codex now recommends GPT-6.1 Sol. The gpt-5.6 API alias still resolves to gpt-5.6-sol, and Codex's model picker and default Power choices vary by plan, sign-in method, client and rollout, so do not assume one account's default applies to another. Use the full model ID when reproducibility matters.

Is Terra better value than Sol for coding?

Terra is usually the better starting value for well-specified daily coding because its direct API rate is lower. Sol is better value when deeper judgment avoids failed attempts, review debt, or a costly wrong implementation. GPT-6.1 Sol now beats both on price: $2 input and $10 output per million, against Terra's $2 and $12.

Which GPT-5.6 model is cheapest?

Luna has the lowest GPT-5.6 price: $0.20 input, $0.02 cached input and $1.20 output per million short-context tokens. Across the newer GPT-6 line, GPT-6 Luna is cheaper again at $0.10 input, $0.01 cached input and $0.50 output.

Do Sol, Terra, and Luna have the same context window?

Yes. All three list a 1,050,000-token context window, 922,000 maximum input, and 128,000 maximum output. Equal context capacity does not mean equal reasoning depth, speed, or task reliability.

Can all three models run in Codex cloud?

Not according to the current Codex model page. Sol is listed for Codex cloud; Terra and Luna are listed for the local CLI and IDE extension but not cloud. Check current OpenAI availability before standardizing a workflow.

Sources checked

Checked October 24, 2026.

• OpenAI: models and recommendations
• OpenAI: Codex models and model selection
• OpenAI: GPT-5.6 Sol
• OpenAI: GPT-5.6 Terra
• OpenAI: GPT-5.6 Luna
• OpenAI: API pricing
• OpenAI: GPT-6.1 Sol
• OpenAI: GPT-6 Luna
• OpenAI: GPT-5.6 model guidance
• OpenAI: Codex authentication