Complete Guide to OpenAI Codex (2026)

Codex asks you to work differently from an editor assistant. Instead of waiting beside your cursor for the next prompt, it can take a bounded coding task, work through the repository, run checks, and bring back a diff for review.

That sounds simple until several tasks finish at once and the bottleneck moves from writing code to judging it. This guide looks at that handoff: what Codex is now, which GPT-5.6 tier fits the job, how to write work it can finish, and where a human still has to make the call.

What Codex Is Now

Codex is OpenAI's coding agent across several surfaces: the ChatGPT desktop app, CLI, web, IDE access, cloud tasks, code review, and mobile access. On July 9, 2026, OpenAI folded the standalone Codex desktop app into ChatGPT desktop.

That does not turn Codex into ordinary chat: it keeps a dedicated coding experience beside Chat and Work, while the terminal and cloud options remain available for the jobs that suit them.

That distinction matters when you decide which tasks to hand off. Codex is useful when a task can be stated with enough context to run independently, then returned as output you inspect. It is less useful when the job is still a conversation with yourself.

Start with a focused task, name the relevant files and expected behaviour, and review the changes and tests before you merge.

Choosing a GPT-5.6 Tier

OpenAI released GPT-5.6 Sol, Terra, and Luna for general availability on July 9, 2026 across ChatGPT, Codex, and the API. Availability was checked against that release on July 28, 2026.

Sol is the flagship coding tier. Its reasoning modes, context capacity, and API pricing can change by product surface, so verify the current release and account documentation before selecting it for a long-running task.

Tier	Best Fit	Availability in Codex
GPT-5.6 Sol	Hard multi-file coding	Check your plan screen
GPT-5.6 Terra	Balanced everyday coding	Check your plan screen
GPT-5.6 Luna	Fast, lower-cost tasks	Check your plan screen

Model access and usage limits follow the plan and workspace controls, so the model picker is the final authority for your account. Sol supports the highest reasoning effort. Terra balances capability, speed, and cost, while Luna is the lighter tier for fast, lower-cost work.

Where You Use Codex

Use ChatGPT desktop when you want the dedicated coding workspace alongside your Chat and Work context. Use the CLI when you are already in the repository and want an interactive terminal session.

Use cloud tasks when a bounded job can run away from your machine, and use the mobile surface to steer or check an active task when you are away from the desk. The Codex desktop guide covers the app workflow; the Codex mobile guide covers what a phone can responsibly do.

Keep the work surface matched to the task. A quick codebase question may belong in the CLI, a long-running refactor may suit a cloud task, and a full review still deserves a real screen. Productivity comes from handing off work you can specify, then spending your attention on the result.

Writing Tasks Codex Can Finish

The task description does most of the steering. "Fix the login bug" leaves Codex to guess which screen is broken, what the right behaviour is, and how you will test the result.

A better handoff names the symptom, the likely files, the boundary, and the proof: show an error when the email field is empty, keep validation in the existing helper, and run the login-form test. Codex can still inspect the repository, but it starts with a finish line.

That format works for bug fixes, test gaps, repeated edits, dependency-free refactors, and research inside a codebase. It works less well for a feature whose product rules are still unsettled.

If you cannot tell a teammate what "done" means, the agent will fill the gap with assumptions. Write the decision first, or keep the session interactive until the open questions are settled.

State the forbidden moves as plainly as the desired result. Tell Codex not to add a package, edit generated files, touch a migration, or expand the task beyond the named route.

Name the command that proves the work and any check it cannot run in its sandbox. These limits make review faster because an unexpected file or skipped command is visible at once.

Cloud tasks are most useful when the work can run without your machine. Give each task its own narrow outcome and let Codex return a diff while you do something else. Running three agents does not make one vague request better; it gives you three vague results to review.

Parallel work pays off when the jobs are separate, such as one test repair, one small refactor, and one codebase question that produces a written answer.

For a first task, pick work you understand well and could finish yourself in an hour. Compare the returned diff with the route you expected, note where Codex needed more context, and use that finding in the next handoff.

This is a safer way to learn the agent than starting with auth, a database migration, or a release job where a plausible mistake carries a real cost.

Terminal, PR Review, and CI

Codex CLI brings the agent to your terminal, where it can work with the project you have open and ask for approvals according to the mode you choose. That is the right surface for a live investigation, a narrow fix, or a local review before you push.

The repository's test suite, branch protections, and human release judgment remain the shipping gates.

For pull requests, Codex can review GitHub changes and return comments for you to assess. Give it project instructions that name real risks, then treat the review as another input rather than a merge approval.

OpenAI also documents Codex workflows with GitHub Actions, which makes CI-style automation possible for bounded jobs. Keep credentials, network access, and write permissions as narrow as the job allows.

Reviewing Delegated Work

When a task finishes, start with the file list before reading the summary. A request for one form should not quietly rewrite shared auth code, add a package, or rename a public API. Then read the diff, run the named checks, and inspect any test that Codex added.

Generated tests can pass while proving the wrong behaviour, especially when the agent wrote both the code and its proof from the same mistaken assumption.

The live task log can warn you before the final diff arrives. If Codex spends time in unrelated folders or retries the same failing command, the task may be drifting.

Step in when the route is plainly wrong or the work is stuck in a loop. If the agent is making steady progress inside the stated boundary, let it finish and respond to the result; constant mid-task steering can create a second set of assumptions.

Review effort does not disappear when agents run in parallel. Three completed tasks mean three diffs, three test results, and three chances for work to overlap.

Staggering the handoff can be better than launching everything at once, because the first result may alter the base or expose a rule the later tasks need. Codex saves writing time only when you keep enough attention for that queue.

Pull-request review follows the same rule as delegated coding work. Treat a Codex comment as a claim to test. Reproduce the bug, trace the code around the diff, and ignore advice that does not fit the product or repository.

Project instructions such as AGENTS.md can tell the reviewer which risks matter here, but they do not replace the person who knows why the feature exists.

A finished task can be reviewed in four passes:

1. Compare the changed-file list with the task boundary before reading the summary.
2. Read the diff for altered behaviour, missing error paths, and edits unrelated to the request.
3. Run the named checks yourself and inspect whether any generated test proves the intended result.
4. Verify the feature in the surface where a user or operator will encounter it.

Keep the agent's task log as supporting evidence. It can show which commands ran, what failed, and where the model changed direction. It cannot prove the final state of your repository after another task lands. Run checks against the exact diff you intend to merge, especially when several agents worked from nearby commits.

Where Codex Does Not Fit

Skip Codex when the task cannot leave your machine or network, when policy rules out a cloud-connected agent, or when the work is mostly product decisions that nobody has made yet. It also loses its advantage when you cannot state what success looks like. A vague task can return a polished-looking diff that solves the wrong problem.

In my documented workflow, Codex runs beside Claude Code as a second agent and independent reviewer, while Cursor cloud agents help verify auto-deployed development environments. That division is practical rather than ideological: choose the surface that exposes enough context for the next decision.

Where Codex Fits

Codex earns its place when you can define the job, let it work, and give the returned diff a real review. It is a poorer fit when every step depends on a product decision or when policy keeps the repository away from cloud-connected tools.

It works well beside Cursor: Cursor can own visual editor or cloud-agent verification, while Codex takes terminal, cloud-task, and review jobs that can run outside the editor.

Codex Surface	Different Surface
Delegated task and later review	Interactive debugging partner
ChatGPT model access	Non-OpenAI policy requirement
Desktop, terminal, web, and mobile	One editor-only feature
Delegated tasks and PR review	No cloud-connected coding
CLI or bounded CI workflow	Offline or air-gapped work
Human review and test gate	Agent-owned release decision

FAQ

Is Codex included in ChatGPT plans?

Codex uses the agentic-usage allowance on your ChatGPT plan. Which GPT-5.6 tiers you can select, along with usage limits and workspace controls, depends on the plan, so check the Codex plan screen before assigning an important task.

Which GPT-5.6 tier does Codex use?

Codex offers the GPT-5.6 family: Sol is the flagship coding tier, Terra balances capability and cost, and Luna is the fastest, lowest-cost tier. Sol supports the highest reasoning effort. Context limits, reasoning settings, and per-plan model access are set by your account, so the Codex model picker is the authority.

Codex vs Claude Code, when does each fit?

Codex spans ChatGPT, terminal, cloud-task, and review surfaces. Claude Code centers on Anthropic's terminal workflow. Compare permissions, account route, review handoff, and the same bounded task before treating either product description as a decision.

Does Codex still exist as a separate app?

Codex still exists as a dedicated coding experience, but the standalone Codex desktop app was folded into the ChatGPT desktop app on July 9, 2026. In that app, Codex remains its own view alongside Chat and Work. The Codex CLI, web and supported mobile surfaces remain separate ways to reach the same product.

Can Codex run in my terminal or CI?

Yes, Codex CLI runs in your terminal with configurable approvals for local coding work. OpenAI also publishes Codex workflow examples that use GitHub Actions, so teams can incorporate it into CI-style automation. Keep permissions narrow, treat generated changes as reviewable output, and make repository tests the final gate.

Compare OpenAI Codex

• Cursor vs Codex compares the editor-first and delegated-agent workflows.
• Claude Code vs OpenAI Codex compares the two terminal and agent workflows directly.
• ChatGPT desktop Codex covers the visual task workspace.
• Codex mobile covers responsible mobile task steering.

Use those guides to separate client setup from the review process. The same task still needs a clear boundary, approval mode, and repository check.

Codex Verdict

Codex is the best fit when a coding job can be bounded, delegated, checked, and returned as a diff or pull request. Its CLI supports close local work, while cloud tasks and review let separate jobs continue away from the editor. The gain comes from moving suitable work out of the typing queue without lowering the review standard.

Choose a more conversational terminal agent when the task is still being discovered, and choose an AI-first editor when visual file work dominates. Skip cloud-connected Codex work when policy requires the code to stay on controlled infrastructure.

This guide was last updated in July 2026. Facts were checked against official OpenAI sources on July 27, 2026.