How to use GPT-5.6 in Codex

On July 9, 2026, OpenAI made GPT-5.6 generally available across ChatGPT, Codex, and the API, with a global rollout over roughly 24 hours. If you opened Codex after that, you were looking at a new default frontier family: three models named Sol, Terra, and Luna, six reasoning effort levels, and an ultra mode that runs four agents in parallel. The limited preview that started June 26 is over; everything here is live for regular accounts.

Try Apidog today

That is a lot of new surface for a tool many developers run on autopilot. Whether you use Codex in the cloud, in your IDE, or through the Codex CLI, it now asks questions that did not exist last week:

• Which tier should handle this task?
• How much reasoning effort does a bug hunt deserve?
• Is a wide refactor worth ultra mode’s parallel agents, or will a single careful Sol run do?

This guide covers what changed, how to pick between the three models for agentic coding, when ultra mode earns its extra token burn, and how to check the API code Codex writes before you ship it. For that last step, use Apidog to test endpoint calls rather than trust generated code blindly.

TL;DR

• GPT-5.6 reached Codex at GA on July 9, 2026. Sol, Terra, and Luna are selectable, subject to your ChatGPT plan.
• Sol is the deep-reasoning flagship. Terra is the balanced pick. Luna is built for fast, cheap, high-volume work.
• Ultra mode runs four agents in parallel and is available in Codex from Plus upward. Per OpenAI, it lifts Terminal-Bench 2.1 from 88.8% to 91.9%.
• Ultra trades higher token and usage burn for faster wall-clock results. Use it for wide refactors, not one-file fixes.
• Six reasoning effort levels (none, low, medium, high, xhigh, max) let you tune depth against cost per task.
• GPT-5.6 writes shorter output than GPT-5.5, so remove old “be concise” directives from your Codex instructions.
• Pair Codex with Apidog to verify the endpoints your agent generates or consumes.

What landed in Codex on July 9

GA day put the full GPT-5.6 family into Codex at once. The model picker now lists the new generation, with what you can select tied to your ChatGPT plan. The same day, Sol, Terra, and Luna arrived in GitHub Copilot too, so the major agentic coding tools converged on the same family within hours.

Three parts of the lineup matter for Codex users:

1. The number is the generation; the names are tiers. Sol, Terra, and Luna are durable capability tiers that advance on their own cadence.

• gpt-5.6-sol is the flagship with the deepest reasoning. The bare gpt-5.6 alias routes to it.
• gpt-5.6-terra is the balanced middle tier, positioned as competitive with GPT-5.5 at roughly half the price.
• gpt-5.6-luna is the fastest and cheapest option, aimed at high-volume, latency-sensitive work.

1. Ultra mode is a setting, not a model.
   
   It fans a task out to four agents working in parallel by default. In Codex, it is available from the Plus plan upward.

2. Effort levels are now a first-class control.
   
   Six levels, from none to max, replace the coarser knobs of the GPT-5.5 era.

One thing has not changed: Codex still behaves like Codex. Your instruction files, approval settings, and workflow carry over; the models underneath got smarter and more configurable.

Picking a model: Sol, Terra, or Luna for coding

Codex is an agentic coding tool, so the question is not “which model is best?” It is “which model fits this task’s depth?”

Model	Coding sweet spot	When to pick it
gpt-5.6-sol	Multi-step agentic work: debugging across files, architecture changes, long tool-call chains	The task would take you hours, and getting it wrong is expensive
gpt-5.6-terra	Day-to-day coding: features, tests, reviews, medium refactors	Your default. Most sessions should start here
gpt-5.6-luna	Boilerplate, commit messages, quick scripts, first-pass drafts	Speed matters more than depth

A practical default workflow:

Start with Terra at medium effort.
↓
Move to Sol at high effort when the task spans multiple files,
requires deep investigation, or has expensive failure modes.
↓
Use Luna for fast, mechanical, or high-volume work.

On agentic coding specifically, OpenAI’s launch numbers give Sol 88.8% on Terminal-Bench 2.1, rising to 91.9% with ultra mode. Treat these as launch-day claims from the vendor; independent verification takes weeks.

For balance, on SWE-Bench Pro, OpenAI’s own reporting shows Claude Fable 5 ahead at 80.3% against Sol’s 64.6%, so GPT-5.6 is not a clean sweep across coding benchmarks.

Model selection happens through the model picker in your Codex settings. The exact layout varies by surface: cloud, IDE extension, or CLI. OpenAI’s developer docs list the current model IDs and where each surface exposes them.

Do not leave Sol on max effort for everything. You will hit your limits sooner and wait longer for answers Terra could have produced.

Ultra mode in Codex

Ultra mode is the headline feature for Codex users. It runs four agents in parallel by default and consolidates their results.

The goal is wall-clock speed on large tasks. The trade-off is intentional: token and usage burn increase because four agents are doing the work of one.

Use ultra mode when work can be split

Ultra mode is a strong fit for:

• Wide refactors that touch many files, where parallel exploration genuinely divides the work.
• Migration passes, such as framework upgrades or API version bumps, with many similar but not identical call sites.
• Time-boxed debugging where you want several hypotheses investigated at once.

For example, a prompt that exposes parallel work might look like this:

Upgrade this repository from API v1 to API v2.

Split the work into independent tracks:
1. Find and update server-side API calls.
2. Find and update frontend client calls.
3. Update tests, fixtures, and mocks.
4. Identify breaking changes and summarize unresolved risks.

Run the test suite after changes and report modified files.

Prefer one agent when the task is serial

A single Sol run is usually better for:

• Single-file changes and focused bug fixes.
• Tasks with a serial dependency chain, where step three requires step two’s output.
• Anything late in your billing window.

Ultra consumes your Codex usage limits noticeably faster, and running out mid-week hurts more than a slower refactor.

The three-point Terminal-Bench gain is real but modest. The stronger argument is time: if a refactor takes 40 minutes as a single run and finishes in a fraction of that with four agents, the extra tokens can be a fair trade during a deadline.

Codex ultra mode is a time lever more than a quality lever. See how GPT-5.6 ultra mode works for a deeper look, including how to write task prompts that four parallel agents can split cleanly.

Reasoning effort for coding tasks

GPT-5.6 exposes six effort levels:

none → low → medium → high → xhigh → max

In Codex, effort is a per-model setting. On Plus, Sol runs at medium effort and up.

Use this mapping as a starting point:

Effort level	Suitable coding tasks
none / low	Renames, formatting, mechanical edits, generating tests from a clear template
medium	Standard feature work, code review, writing straightforward endpoints
high	Multi-file debugging, performance investigation, unfamiliar codebases
xhigh / max	Race conditions, memory corruption, or problems the team has been investigating for days

Treat a GPT-5.6 upgrade as a tuning pass, not just a model swap.

1. Pick several representative tasks from your backlog.
2. Run them with your current effort level.
3. Repeat at one level lower.
4. Compare correctness, test results, latency, and usage.
5. Keep the lowest effort level that reliably completes the task.

OpenAI’s migration guidance is worth taking literally: GPT-5.6 often matches previous-generation output at reduced effort, which creates headroom on your usage allowance.

Also update your instructions. GPT-5.6 writes notably shorter answers with fewer generic introductions than GPT-5.5 did. Remove leftover directives such as:

Be concise.
Skip the preamble.
Do not explain your work.

Stacking brevity rules on an already-brief model can produce terse, underexplained diffs. Prefer instructions that focus on implementation quality instead:

Before editing, identify affected files and dependencies.
Make the smallest safe change.
Run relevant tests.
Summarize changed files, validation performed, and remaining risks.

What each ChatGPT plan gets in Codex

Access is plan-gated, and OpenAI adjusts these details often. Treat this table as a snapshot from OpenAI’s help center, subject to change.

Plan	GPT-5.6 models	Ultra mode in Codex	Notes
Free / Go	Terra (in ChatGPT)	No	Codex is not included in the free tiers
Plus	Sol, Terra, Luna	Yes	Sol at medium effort and up; per-model effort control
Pro	Sol, Terra, Luna, Sol Pro	Yes	Higher limits; ultra also in ChatGPT Work
Business / Enterprise	Sol, Terra, Luna, Sol Pro	Yes	Ultra via ChatGPT Work; admin controls

Two takeaways:

1. Plus already gets the full model picker and ultra mode in Codex. The gap between Plus and Pro for coding is about limits and Sol Pro, not raw capability.
2. API billing has no plan gating. Any API account can call all three models self-serve at $5/$30 for Sol, $2.50/$15 for Terra, and $1/$6 for Luna per million input/output tokens.

Verify what Codex writes: pair it with Apidog

Much of what a coding agent produces in a working session is code that talks to APIs:

• Route handlers
• Client calls
• Webhook consumers
• Test fixtures
• API mocks

GPT-5.6 makes Codex faster at producing that code. It does not make the code correct.

An agent that confidently writes a wrong endpoint call can be more dangerous at 91.9% on a benchmark than at 60%, because developers may review its output less carefully.

Use a verification loop that keeps the speed without the blind trust.

1. Give Codex your OpenAPI spec

Put the spec file in the repository, or reference it in your Codex instructions. This lets the agent generate against your actual contract instead of guessing field names.

For example:

The API contract is in ./openapi.yaml.

Before changing API clients, handlers, or tests:
- Read the relevant OpenAPI paths and schemas.
- Do not invent fields, status codes, or content types.
- Update affected tests and fixtures.
- Run the API test suite after edits.

2. Let Codex write the integration

Use Terra or Sol at medium-to-high effort to generate:

• Endpoint handlers
• Typed API clients
• Request validation
• Integration tests
• Webhook consumers

3. Test generated endpoint calls before merging

Import the same spec into Apidog. Then hit every endpoint Codex generated or consumed and check:

• Status codes
• Request parameters
• Request and response schemas
• Authentication behavior
• Content types
• Error responses and edge cases

Download Apidog free. A spec-driven test pass catches silent mismatches an agent can introduce, such as a renamed field or an incorrect content type.

4. Mock APIs that do not exist yet

If Codex is building against an API that is not deployed, mock it from the spec. This gives the integration work something contract-shaped to run against instead of relying on guessed responses.

If you want the verification loop inside the agent instead of alongside it, wire the Apidog CLI directly into Codex so the agent runs API test suites as part of its task loop. The setup is covered step by step in how to use the Apidog CLI in Codex.

What is still settling

GPT-5.6 in Codex is days old, and some rough edges come with that.

• Rollout unevenness. GA rolled out over roughly 24 hours, and some surfaces or regions may still be catching up. If a model or setting is missing from your picker, whether in the IDE or the Codex CLI, check OpenAI’s release notes before filing a bug report.
• Specs are still secondhand. The reported 1M-token context window and 128K maximum output come from early documentation coverage rather than a confirmed spec sheet. Treat them as reported until OpenAI’s pages settle.
• Benchmarks are vendor-reported. The Terminal-Bench and other launch numbers are OpenAI’s own. Independent evaluations will follow over the coming weeks.
• Plan details move. OpenAI has a history of adjusting limits and access in the weeks after a launch. The help center article above is the source of truth.

None of this is a reason to wait. It is a reason to run GPT-5.6 on a handful of representative tasks from your backlog before committing your team’s default settings.

FAQ

Which GPT-5.6 model should I set as my Codex default?

Terra. OpenAI positions it as competitive with GPT-5.5 at roughly half the cost, and it handles day-to-day feature work comfortably.

Switch to Sol when a task spans many files or needs long reasoning chains. Drop to Luna for boilerplate and quick scripts.

Can I use GPT-5.6 in Codex without a paid plan?

Not directly. Codex requires a paid ChatGPT plan, and free-tier ChatGPT access to GPT-5.6 is limited to Terra.

There are legitimate low-cost and trial routes, and the API itself has no plan gating. The options are collected in how to use Codex free.

Does ultra mode burn through my usage limits faster?

Yes, by design. Ultra runs four agents in parallel, so a single task consumes several times the tokens of a normal run in exchange for faster completion.

Reserve it for large, parallelizable jobs and check your remaining allowance before starting one.

Is ultra mode the same as Sol Pro?

No.

Pro mode, or Sol Pro in ChatGPT, is a quality-first reasoning setting on a single model. Ultra is a multi-agent execution mode that parallelizes work.

Pro aims for a better answer; ultra aims for a faster wall-clock result on big tasks.

Where this leaves you

Codex got a real upgrade on July 9: a smarter flagship, a cheaper strong default, per-model effort controls, and a parallel mode that shortens big jobs.

A practical baseline for most developers is:

Default: Terra at medium effort
Hard tickets: Sol at high effort
Wide, parallelizable refactors under deadline: Ultra mode
Mechanical or high-volume tasks: Luna

Whatever settings you land on, the agent’s output still needs the same scrutiny as a fast human’s. Give Codex your OpenAPI spec so it builds against the real contract, then verify every generated endpoint in Apidog before it reaches a branch anyone depends on.

Faster code generation only pays off when the checking keeps pace.