Codex CLI review (2026): strong terminal agent, variable usage

Codex CLI is worth using in 2026 if you want an auditable terminal agent and already have an eligible ChatGPT plan. Version 0.146.0 can inspect repositories, edit files, run commands, review diffs, and automate work through codex exec; GPT-5.6 Sol, Terra, and Luna now cover distinct quality and cost tiers. The August 5 verdict is positive, with two cautions: usage still varies by context and reasoning, and strict sandbox rules can reject harmless commands. OpenAI has cut Terra’s credit rate by 20% and Luna’s by 80%, added daily, weekly, and cumulative account views through /usage, and documented Fast mode’s speed premium. In our reproducible Sol test, Codex found all six seeded defects with no false positives, then recovered safely after three PowerShell reads were denied.

This page answers one question: is Codex CLI a good terminal coding agent now? For plan quota alone, use our separate US$20 Cursor vs Codex vs Claude Code usage comparison. For a direct harness comparison, read Codex vs Claude Code agent-loop testing.

Verdict after the August 2026 pricing update

Score: 8.6/10.

Codex CLI has crossed the line from “credible alternative” to a strong daily terminal agent. The best parts are practical:

• It works interactively or through reproducible codex exec commands.
• Permissions and sandbox modes are visible rather than hidden behind the model.
• GPT-5.6 Sol can recover from a denied command without immediately asking for broader access.
• MCP is first-class and shared with the Codex app and IDE extension on the same host.
• ChatGPT sign-in makes a useful trial easy for existing subscribers.
• /usage makes daily, weekly, and cumulative account activity visible without leaving the CLI.

The remaining caution is not basic capability. It is resource control: which model, reasoning level, tools, context, subagents, and fast mode a task is allowed to consume.

What Codex CLI is now

OpenAI’s current CLI documentation describes a local agent that can inspect and modify repositories, run installed development tools, and participate in scripts or CI through codex exec. The July 29 0.146.0 release added session naming, thread pinning and forking, plugin-manifest support, remote Code Mode connections, and several authentication and MCP fixes.

The model menu has also changed. In August 2026, the relevant GPT-5.6 choices are:

Model	Codex credit rate per 1M input / cached input / output tokens	API price per 1M input / output tokens	Practical role
GPT-5.6 Sol	125 / 12.5 / 750 credits	US$5 / US$30	Hard reviews, debugging, migrations, architecture
GPT-5.6 Terra	50 / 5 / 300 credits	US$2 / US$12	Everyday implementation with a lower budget
GPT-5.6 Luna	5 / 0.5 / 30 credits	US$0.20 / US$1.20	Repetitive, bounded, high-volume tasks

The current Codex pricing table and OpenAI’s July 30 price announcement were checked on August 5, 2026. Terra’s token and credit rates fell 20%; Luna’s fell 80%; Sol stayed unchanged. ChatGPT and Codex subscription prices and quota budgets did not increase, so a cheaper model stretches the same allowance rather than creating a larger fixed pool.

What the new rates mean for a real trace

Applying the August 5 rates to our recorded 37,897 uncached input, 33,280 cached input, and 1,050 output tokens produces 5.94 Sol credits, 2.38 Terra credits, or 0.238 Luna credits. These are arithmetic normalizations of one trace, not a claim that the cheaper models would find the same six defects.

credits = (uncached_input × input_rate
         + cached_input × cached_rate
         + output × output_rate) / 1,000,000

The public fixture below supplies the token counts, prompt, files, and scored result. Our separate AI coding usage measurement guide explains how to pair a trace like this with before-and-after account-meter snapshots.

Plan limits, /usage, and Fast mode

OpenAI now publishes broad local-message ranges for each five-hour window. Plus is listed at 10–100 Sol, 25–200 Terra, or 250–2,000 Luna messages; Pro 5x multiplies those ranges by five, and Pro 20x by twenty. These are not task guarantees. Local messages share a window with cloud chats, weekly limits may apply, and model choice, context, reasoning, tools, and caching all change consumption.

Inside a ChatGPT-authenticated CLI session, /usage opens daily, weekly, or cumulative token activity and can expose an earned rate-limit reset when one is available. /status remains the quick view for the active model, policy, context, and remaining limits.

Fast mode is a latency trade, not a better model: for GPT-5.6 in Codex it targets 1.5× speed and consumes credits at 2.5× the Standard rate. API Fast mode is priced differently—OpenAI says GPT-5.6 Sol can run up to 2.5× faster at 2× the Standard API token price. Do not use the CLI multiplier to estimate API billing.

TopInsight’s reproducible six-defect audit

We tested Codex CLI on July 30, 2026 with:

• Windows 11 10.0.26200
• Node.js 24.16.0
• Codex CLI 0.146.0 through npx
• gpt-5.6-sol at medium reasoning
• ChatGPT authentication
• read-only sandbox
• a 47-line TypeScript checkout function and a written five-requirement specification

The fixture seeded six concrete defects: zero and fractional quantities were accepted, an unknown SKU raised the wrong error, a whole discount percentage was applied as a multiplier, the required 0–100 discount range was not validated, and inventory was not restored after payment failure. Math.round correctly satisfied the integer-cents requirement and served as a false-positive trap.

Reproduction command:

npx -y @openai/codex@0.146.0 exec `
  --skip-git-repo-check `
  --ignore-user-config `
  --ignore-rules `
  --ephemeral `
  -s read-only `
  -m gpt-5.6-sol `
  -c 'model_reasoning_effort="medium"' `
  --json `
  "Read REQUIREMENTS.md and checkout.ts. Perform the requested review. Return only concrete requirement violations with line references and concise fixes. Do not edit files."

The complete fixture, rubric, and scored result are public.

Result	Observed
Seeded defects found	6 / 6
False positives	0
Wall time	47.0 seconds
Input tokens	71,177
Cached input tokens	33,280
Output tokens	1,050
Reasoning output tokens	312
Estimated Codex credits	5.94
Estimated API-equivalent cost	US$0.238

The cost calculation treats the CLI’s reported output tokens as inclusive of reasoning tokens. It is a normalization against the public rate card, not a claim that our subscription was separately charged US$0.238.

The result that matters beyond 6/6

The first generated PowerShell command tried to read and line-number both files in one expression. The read-only policy rejected it, as well as two simpler variants. Codex then used rg -n "^" on each file to finish the review without requesting full access or editing anything.

That is both a strength and a weakness. The sandbox created friction on a harmless read, but the agent respected the boundary and recovered. On a real repository, this is preferable to silently widening permissions. It also explains why terminal-agent benchmarks that omit policy, shell, and recovery behavior are incomplete.

What Codex CLI gets right

1. The local loop is inspectable

Commands, file changes, approvals, and model choices stay visible. You can keep a task in plan or read-only mode, allow edits for implementation, then review the diff before committing. That control is the reason to prefer the CLI over pasting files into a chat window.

2. Non-interactive mode is genuinely useful

codex exec makes the same agent usable in repeatable scripts. JSONL output exposes commands, messages, failures, and token usage, which is why our test can report the blocked command and exact token counts. This is more auditable than judging a tool from a polished demo.

3. MCP support is no longer a partial compatibility story

The old version of this review incorrectly described Codex as using a different protocol. Current Codex MCP documentation supports local STDIO servers and remote Streamable HTTP servers with bearer or OAuth authentication. The desktop app, CLI, and IDE extension share MCP configuration on the same Codex host.

This does not mean every community server is reliable. It does mean “Codex uses a different protocol” is no longer an accurate objection.

4. Model routing is clearer

OpenAI’s model guidance recommends starting at the default reasoning level and increasing it only for harder work. That matches our experience. Sol medium was sufficient for the seeded audit; using max or ultra would have made the test more expensive without proving a useful daily-driver point.

For a broader workflow decision, our Claude Code vs Cursor comparison separates terminal-agent work from IDE-first editing.

What still needs discipline

1. “Included” is not the same as predictable

The official rate card now maps tokens directly to credits and the pricing page publishes five-hour message ranges, which is clearer than an average-message estimate. But users still experience the plan through moving context, cached input, reasoning, subagents, task length, and additional weekly limits.

A recent r/codex thread about Sol as a “token furnace” combines real completed work with unexpectedly fast quota burn. Another controlled community accounting attempt argues that the token-based rate card does reconcile with observed credits. After the price cut, community discussion shifted to whether lower Luna and Terra rates meant larger quotas; the official answer is narrower—quota budgets stayed unchanged while those models consume fewer credits. These are user reports, not universal limits. Together they show why teams should record token profiles instead of promising a fixed number of tasks.

2. Sol can overwork a task

The r/codex launch discussion is split: some developers report a meaningful jump on complex work, while others see more token use, slower runs, or little benefit on ordinary frontend changes. A newer report describes implementation and review loops.

These anecdotes do not prove a general defect rate. They are a useful warning against assigning an open-ended objective when a bounded acceptance test would do.

3. Windows policy and shell behavior still surface rough edges

Our test emitted a warning that PowerShell shell snapshots are not supported and rejected a complex read command. Recovery worked, but Windows users should expect more harness-specific friction than a simple model benchmark reveals.

4. The default context has a cost

Even a small audit reported 71,060 input tokens because a coding agent sends more than the visible TypeScript file: system instructions, tool definitions, policy, and command results all contribute. Cached input cut the effective price sharply in our run. The right conclusion is not “71k tokens for 47 lines”; it is that agent cost must be measured at the full harness level.

YouTube enthusiasm versus Reddit friction

The current creator evidence is more useful when it shows traces and costs. Nate Herk’s Sol/Fable comparison frames Sol as the cheaper worker and Fable as the higher-cost manager on several builds. IndyDevDan’s model-stacking video argues for routing work between them instead of declaring one universal winner. Coralogix’s GPT-5.6 telemetry review focuses on the Sol/Terra/Luna cost and behavior differences.

Reddit adds what clean demos underweight: quota exhaustion, over-engineering, command loops, and large variance between workflows. Our small test reconciles the two rather than choosing a camp: Sol was accurate and recovered well, while the command trace and token report exposed real operational overhead.

Who should use Codex CLI

Use it as a primary terminal agent if:

• you already pay for ChatGPT and want to use the included Codex allowance;
• your repositories have tests, linting, and clear acceptance criteria;
• you will keep AGENTS.md, permissions, and model selection explicit;
• you value JSONL traces and non-interactive automation;
• you want shared MCP configuration across Codex surfaces.

Keep it as a secondary tool, or skip it, if:

• you need a fixed task count from a subscription;
• your workflow depends on unrestricted shell access and you do not want to maintain policy;
• you routinely give agents broad goals without validation commands;
• you cannot review large generated diffs.

A safer starting configuration

Start with three constraints:

1. Use medium reasoning until a representative task fails.
2. Keep unfamiliar repositories read-only for the first pass.
3. State the verification command and the files that may change.

For example:

Inspect the failing checkout tests first. Explain the cause with file and line references.
Do not edit files yet. After I approve the diagnosis, change only the checkout module and its tests.
Run the focused test file, then the full test suite. Do not commit.

This is less exciting than “build the feature autonomously,” but it gives you a measurable baseline before increasing model effort, permissions, or parallelism.

Final recommendation

Codex CLI is a strong terminal coding agent in August 2026. GPT-5.6 Sol is capable enough for difficult review and debugging work, Terra and Luna are now materially cheaper for bounded work, the CLI has a serious permission model, codex exec is auditable, and MCP support is real. Our controlled review was accurate and recovered safely from a denied command.

Do not buy or renew a plan based on “unlimited agent” expectations. Measure a representative task, record full-harness token usage, and route ordinary work to Terra or Luna when Sol’s extra capability is unnecessary. If you are deciding among complete products rather than reviewing Codex alone, pair this page with the US$20 quota comparison and our Codex vs Claude Code agent-loop test.