Codex Review (Verified August 2026)

Codex is worth $20 a month only if you will use it as a coding system, not as autocomplete: local repository work, isolated worktrees, cloud delegation, and code review under one account. If you mainly want inline suggestions, GitHub Copilot Pro costs $10 a month; if you want a terminal-first agent without the wider ChatGPT workflow, Claude Code Pro costs $20 monthly.

What Codex is

Codex is OpenAI's software-development agent: you give it access to a repository and a goal, and it can inspect files, edit code, run commands, test its work, and return a diff for review. The product is broader than a model or chat window. The same account reaches a terminal client, an IDE extension, local projects in the ChatGPT desktop app, isolated Git worktrees, hosted cloud environments, GitHub pull-request review, and remote control from another device. That breadth is its reason to exist. If all you need is code completion while typing, most of Codex is unnecessary.

Codex vs Claude Code, Cursor, and GitHub Copilot at a glance

Codex is the best fit of these four when local execution, asynchronous cloud work, and review need to share one operating model. The specialists make more sense when your workflow has one dominant surface.

The price row does not settle the decision. Codex Go is cheaper than the three specialist paid plans, but OpenAI describes it as lightweight access. Plus is the practical baseline for a developer expecting regular agent work. Claude Code earns its place when the terminal is the product. Cursor earns it when the editor is the product. Copilot earns it when completion, GitHub policy, and a $10 entry price matter more than a unified local-to-cloud agent.

For a deeper two-way decision, the site's Codex vs Claude Code comparison separates terminal behavior, autonomy, and cost in more detail.

Who Codex is for, and who should skip it

Codex is for developers and technical leaders who want one agent to move between hands-on local work and delegated work without rebuilding the workflow each time.

A funded founder with two active products gets the clearest value. Keep an urgent payment bug local in the IDE, hand a dependency upgrade to a worktree, send a test-suite cleanup to the cloud, and review each result from the same desktop workspace. The advantage is not that Codex can edit a file. Every serious coding agent can. The advantage is that the jobs can run in different execution environments and return as reviewable diffs.

A mid-market CTO with a growing pull-request queue should consider Codex when review knowledge is trapped in a few senior engineers. GitHub Code Review can apply repository-specific rules from AGENTS.md, focus comments on P0 and P1 issues, and start a follow-up cloud fix from a pull-request comment. Business is the sensible floor for organizational data because OpenAI does not train on Business inputs or outputs by default, and the plan adds workspace administration. The annual minimum is two seats, or $480 a year.

A senior operator coordinating engineering from more than one device benefits from Remote only if an awake development host is already part of the setup. A phone can start or steer work on that host, but the phone is not replacing the host. This is useful for checking an overnight migration or responding to an alert away from a desk. It is not a serverless cloud substitute.

A solo technical builder who mainly lives in a terminal should compare Claude Code first. Claude Pro costs $20 monthly, and Claude Code is intentionally centered on the terminal while still connecting to IDEs and command-line tools. Codex can work there too, but paying for its wider surface area is wasteful if local terminal sessions are the only surface you intend to use.

A developer who mainly wants inline completion should skip Codex as the primary purchase. GitHub Copilot Pro is $10 a month and keeps the interaction inside existing editors and GitHub. Cursor Pro is $20 a month and makes sense when chat, inline edits, and agent work should all live inside an AI-native editor.

A regulated team that cannot yet approve cloud repository access should not force the adoption. Codex can run locally with an API key, but API-key mode excludes Codex cloud, GitHub Code Review, and Slack. Use local CLI or IDE automation while security reviews the connected workflow, or choose the Business or Enterprise controls that match the data policy.

Capability 1: the local CLI and IDE coding loop

Codex is strongest locally when the task has a bounded outcome and an executable check. “Improve checkout” is vague. “Trace duplicate payment-webhook delivery, add an idempotency guard, run the payment tests, and show the smallest diff” gives the agent a target, a boundary, and proof.

The Codex CLI works against the repository already on your machine. It can read files, edit them, and run the same test, lint, type-check, and Git commands you use. Permissions and sandbox settings decide what it may change or execute without approval. That local model is important for a sensitive repository: the work happens in the environment you control rather than in a newly configured hosted container.

Here is the workflow that turns a local agent from a chat box into a useful engineering loop.

1. 1

   Give it a narrow failure

   Open the repository, start codex, and describe one observable problem. Name the failing test, route, error, or changed behavior. Ask it to inspect before editing when the cause is uncertain.

2. 2

   State the safety boundary

   Tell Codex what must remain unchanged, which migrations or public interfaces are off-limits, and which commands count as validation. Durable repository rules belong in AGENTS.md; task-specific constraints belong in the prompt.

3. 3

   Require executable proof

   Ask for the relevant tests, type checks, or lint command. A diff without a passing check is a proposal. A diff plus the exact check is a result another engineer can evaluate.

4. 4

   Review the diff, then review the review

   Inspect the changed files and run /review against uncommitted changes. The dedicated reviewer reports findings without modifying the working tree, so you can decide whether a second editing pass is justified.

The Codex IDE extension is better for smaller edits where the relevant context is already open. Attach a selection or file, ask for the change, and inspect the result beside the code. When the task expands from one component to a cross-repository migration, delegate it rather than turning an editor chat into an unbounded session.

The wall is context discipline. Large repositories encourage agents to read more than the task needs, which raises usage and adds irrelevant instructions. Nest AGENTS.md close to the code it governs, name the target files or service, and ask for a short plan before a broad edit. More context is not automatically better context.

Capability 2: worktrees and cloud delegation

Codex turns from an assistant into a work coordinator when separate tasks get separate environments. A Git worktree is another checkout of the same repository, letting one task change a branch without colliding with the branch in your main folder. Codex can use worktrees locally and isolated containers in the cloud.

Consider a three-part release: upgrade the payments SDK, repair a flaky browser test, and add audit logging. The payments change needs close attention because it touches a public contract, so keep it local. Give the flaky test an isolated worktree. Send audit logging to Codex cloud, where the environment checks out a selected branch or commit, runs the setup script, executes the task, and returns a summary and diff. Review all three before anything merges.

Cloud environments are reproducible only when the setup is explicit. Pin runtime versions, install dependencies in the setup script, and put the repository's validation commands in durable instructions. Codex caches a configured container for up to 12 hours, which can shorten follow-up setup, but changing setup, maintenance, variables, or secrets invalidates that cache.

The hosted wall appears at the network and secret boundary. Setup scripts have internet access, while agent internet access is off by default unless you enable limited or unrestricted access. Secrets are available to setup scripts and then removed before the agent phase. That design is safer than leaving every credential in reach, but it means a task that must call a protected service during execution needs a different architecture. An environment variable remains available through the chat, which increases exposure, or the task needs an approved tool or service boundary.

Capability 3: local and GitHub code review

Codex Code Review is most useful as a focused second reviewer, not as a substitute for CI or ownership. Local /review and GitHub review solve related but different problems.

Local Code Review can inspect the diff against a base branch, all uncommitted changes, a specific commit, or custom criteria. It does not change the working tree. That makes it useful immediately before a commit: ask for correctness, data-loss risk, and missing tests, then choose which findings deserve edits.

GitHub Code Review needs Codex cloud configured for the repository. Mention @codex review on a pull request, or enable automatic reviews. The GitHub workflow deliberately posts only P0 and P1 findings, keeping comments focused on severe risk rather than formatting preferences.

The valuable part is repository-specific judgment. Put a ## Code Review Rules section in the applicable AGENTS.md, keep root rules broad, and place service rules in a nested file. A payment service could say that webhook processing must remain idempotent and name the safe retry path. A public API service could prohibit removing a response field until the compatibility window closes. These are the checks experienced reviewers repeat because a generic static analyzer cannot infer the history.

OpenAI reports that rule-guided variants recovered 98% of required custom findings in its primary evaluation, versus 58.3% for the baseline control. That is a vendor-run result, not an independent benchmark, but it supports a narrow conclusion: concise repository rules can materially improve a review targeted at known invariants. OpenAI also states that tests, branch protections, and required approvals remain the hard enforcement.

The complete review-to-fix loop looks like this:

1. 1

   Encode two or three consequential rules

   Choose invariants a senior reviewer repeatedly explains. Leave formatting and deterministic checks in CI.

2. 2

   Request the review

   Use @codex review on a representative pull request, or turn on automatic reviews after the rules are producing useful signal.

3. 3

   Challenge the evidence

   Read the cited file and line, reproduce the risk, and dismiss findings that do not survive inspection. Severity labels do not make a claim correct.

4. 4

   Fix narrowly

   When a finding is valid, @codex fix the P1 issue can start a cloud task with the pull request as context. Review its diff and rerun the same hard checks before merge.

Capability 4: remote steering across devices

Codex Remote is valuable when the development machine is elsewhere, but the host remains the computer doing the work. Remote can connect an awake Mac or Windows host to ChatGPT on iOS, Android, or another supported desktop. The host supplies the repository, shell, credentials, tools, sandbox settings, and approval policy.

Picture an on-call engineer away from a laptop when a background job starts failing. From a phone, they can open the project on an always-on host, ask Codex to inspect the logs and trace the failing path, and wait for a diagnosis. A safe prompt stops at evidence and a proposed patch. The engineer can review the diff on a larger screen, hand the chat to another host if needed, and run the normal deployment controls.

Remote also supports projects on SSH hosts and can hand a chat and Git state between connected hosts, using a worktree on the destination. This is useful when the dependencies live on a dedicated development machine. It is fragile when the laptop sleeps, the network drops, or the desktop app closes. For continuous unattended work, use an always-on host or Codex cloud instead of treating a personal laptop as infrastructure.

The site's Codex Remote analysis covers the host and control-plane tradeoff in more detail.

Codex pricing: every current tier

Codex pricing is simple in dollars and complicated in usage. The current official Codex pricing page lists eight buying routes, while the exact amount of work inside a subscription varies with model choice, context, reasoning, tools, retrieval, and caching.

For the plan-level detail and credit mechanics, use the site's dedicated Codex pricing guide. Prices were consistent across OpenAI's live pages on 2 August 2026. Included-message ranges were not.

ChatGPT Work and Codex share usage. Local messages and cloud chats also share a five-hour window, and OpenAI says additional weekly limits may apply. Plus and Pro users can buy credits after their included allowance. Business, Edu, and Enterprise workspaces on flexible pricing can buy workspace credits. The subscription is therefore a bundle with a variable capacity ceiling, not a fixed number of completed engineering tasks.

API cost per scoped task

API pricing is easier to model because it is token-based, but API-key mode loses the cloud integrations that distinguish Codex. Use this comparison only for local or scripted work.

Assume one scoped task consumes 100,000 uncached input tokens and 20,000 output tokens in short context. At standard rates:

• GPT-5.6 Luna costs $0.044: 0.1 x $0.20 input plus 0.02 x $1.20 output.
• GPT-5.6 Terra costs $0.44: 0.1 x $2 input plus 0.02 x $12 output.
• GPT-5.6 Sol costs $1.10: 0.1 x $5 input plus 0.02 x $30 output.

At those assumptions, $20 buys about 455 Luna tasks, 46 Terra tasks, or 19 Sol tasks after rounding up to the task that reaches the threshold. The subscription comparison is not apples-to-apples: Plus includes connected Codex surfaces, while API-key mode excludes cloud tasks, GitHub review, and Slack. The calculation is useful for a CI job or SDK workflow, not for valuing the entire product.

The limitations that should decide the purchase

Codex has six material limits, and any one can overturn the purchase for the wrong buyer.

1. Usage capacity is not predictable enough

The dollar price is fixed, but work capacity is not. Context length, model, reasoning, retrieval, tools, and caching change usage. Two official OpenAI pages currently publish conflicting Plus ranges. Credits soften the ceiling, but they do not make a $20 plan predictable for a developer trying to budget a month of agent work.

Decision impact: do not buy Pro on a promise of “more.” Use Plus, observe the signed-in dashboard for a full work cycle, and upgrade only when interruptions cost more than the price difference.

2. API-key access is a local product, not a substitute subscription

API Key supports the CLI, SDK, and IDE extension, with model usage billed at API rates. It does not include Codex cloud, GitHub Code Review, or Slack. A company cannot avoid the workspace plan, pay tokens, and still expect the entire connected product.

Decision impact: API Key wins for CI and controlled local automation. A ChatGPT plan wins when delegation and connected review are part of the outcome.

3. Cloud secrets disappear before the agent works

Cloud secrets are available to setup scripts and removed before the agent phase. That is a deliberate security boundary, but it blocks a common assumption: storing a production credential as a secret does not mean the agent can call the protected service while solving the task. Environment variables persist, yet expose more to the session.

Decision impact: use short-lived credentials through an approved tool boundary, or design the task so setup can fetch what execution needs without leaving a reusable secret in reach. If that architecture is not acceptable, keep the task local.

4. Consumer data controls need two checks

OpenAI says content from individual ChatGPT and Codex accounts may be used to train models unless the user opts out. Codex also has separate controls for training on full environments, and changing the general ChatGPT or privacy-portal setting does not change that full-environment setting. Business, Enterprise, and API inputs and outputs are not used for training by default unless the organization opts in.

Decision impact: an individual user working with proprietary code should verify both the general data control and the Codex full-environment setting. A company that needs an organizational default should use Business, Enterprise, or API rather than relying on every employee to configure a personal account correctly.

5. Review remains advice, not enforcement

GitHub Code Review focuses on P0 and P1 findings. Custom repository rules can improve what it looks for, but the model can still miss a defect or overstate one. OpenAI's 98% result is a vendor evaluation against a defined custom-rule suite, not a guarantee for an unfamiliar repository.

Decision impact: keep required tests, branch protection, code owners, and human approval. Let Codex add signal before those gates, never replace them.

6. Remote is only as available as its host

Remote control stops when the host sleeps, loses network access, or closes the app. A personal laptop may be convenient for occasional steering, but it is a poor always-on execution target.

Decision impact: use an always-on development host for remote workflows, or move background work to Codex cloud. Do not build an incident process around a laptop that may be asleep.

Verdict: when Codex is worth it

Codex is worth paying for when at least two of these are part of your normal week:

• You want the same agent in the terminal and IDE.
• You need isolated worktrees or cloud delegation while you keep working.
• You want local review plus GitHub P0/P1 review with repository rules.
• You need to steer work from another device or hand it between hosts.

If only one applies, choose the specialist. Claude Code is the cleaner choice for a terminal-centered agent. Cursor is the better choice when the editor is the center of gravity. GitHub Copilot is the economical choice for completion and GitHub assistance.

For most individual developers, Plus at $20 a month is the correct Codex tier. Free and Go are evaluation routes. Pro 5x at $100 makes sense only after measured limit pressure is interrupting work. Pro 20x at $200 belongs to sustained multi-agent use, not an occasional coding session. Business starts at an effective $480 annual minimum for two seats and is the right floor when administration and no-training-by-default matter. API Key is for metered local or programmatic work, with the explicit trade that cloud features disappear.

The final rule is blunt: buy Codex for the connected workflow, not because an OpenAI model can write code. Models change. The operating system around the work is what you keep paying for.

Frequently asked questions

Is Codex really good for coding?

Codex is good for scoped repository work when the prompt names an outcome, constraints, and executable checks. It can inspect, edit, run tools, and return a diff. It still needs tests and human review for production changes.

Is Codex better than ChatGPT?

Codex is not simply a rival to ChatGPT. It is the developer-oriented workflow inside the wider ChatGPT product, with repository access, diffs, terminal commands, worktrees, cloud environments, and code review.

What does Codex review do?

Local /review inspects a base-branch diff, uncommitted changes, a commit, or custom criteria without modifying the working tree. GitHub Code Review posts focused P0 and P1 findings and can apply repository rules from AGENTS.md.

Is Codex as good as Claude Code now?

Codex is the stronger system when local, cloud, app, review, and remote surfaces need to work together. Claude Code remains the sharper shortlist choice for a developer who wants the terminal to stay at the center of every interaction.

What are the cons of Codex?

The main cons are variable usage, conflicting official allowance ranges, cloud features that require a ChatGPT plan, cloud setup and secret constraints, separate consumer data controls, and Remote's dependence on an awake host.

Which is better, Codex or Claude?

Choose Codex when you need a connected multi-surface workflow. Choose Claude Code when you mainly need a terminal-first coding agent. At monthly billing, the serious individual entry point is $20 for either Codex Plus or Claude Pro.

What is the Codex review command?

Use /review in Codex CLI or the IDE extension. Choose a base-branch review, uncommitted changes, a specific commit where available, or custom instructions. The reviewer reports findings without editing the working tree.

How does Codex review GitHub pull requests?

Connect the repository to Codex cloud, enable Code Review in settings, and mention @codex review on the pull request. Automatic reviews can run when pull requests open for review, and scoped AGENTS.md rules can add repository-specific checks.

Get the Claude Code and Codex setup checklist when you join the newsletter.