AutomaterOpenAI Codex: Harness, Models, and Plans — the Daily-Driver Review
OpenAI Codex reviewed as a daily driver: the Rust CLI, cloud fan-out, IDE extension, GPT-5.6-era models, and what each ChatGPT plan actually sustains.
Go deeper. Build your own.
OpenAI Codex is no longer a model you call — it is a full agent harness: an open-source CLI, a cloud agent that works in sandboxed containers, and an IDE extension, all signed in with the ChatGPT plan you probably already pay for. This is the daily-driver review of all three surfaces, written to sit beside our Claude Code field guide the way the two products sit beside each other in a working rotation.
The verdict up front, hardware-review style. Codex has the strongest delegation-and-parallelism story in the category — nothing else ships cloud fan-out this cleanly — and it arrives bundled into plans most developers already hold. It still trails Claude Code on terminal extensibility, and its model monogamy is a real constraint. As of August 2026, it has earned a permanent lane in a multi-harness fleet, not the whole garage; the mid-2026 harness map counts it among the category’s clear survivors in a year that killed several rivals. What follows organizes the case: the three surfaces, the model line, the plan math, and where it slots into the broader harness field.
Codex, the name: three products deep
The name has meant three different things, and the SERP still serves all three eras interleaved. The 2021 Codex was a code-completion model — the engine behind the original GitHub Copilot — retired as a standalone API in March 2023. The name then sat dormant until 2025, when OpenAI revived it for something categorically different: an autonomous coding agent, launched as a CLI and a cloud agent in spring 2025, with the IDE extension and general availability following that autumn.
OpenAI Codex is OpenAI’s coding agent, not the 2021 completion model: an open-source Rust CLI for supervised local work, a cloud agent that runs delegated tasks in sandboxed containers and returns pull requests, and an IDE extension — all signed in with your ChatGPT plan and driven by Codex-tuned models.
The residue matters practically. Any tutorial mentioning code-davinci-002, “Codex API pricing” circa 2022, or Codex as Copilot’s engine is describing the dead product. That is the tell; close the tab and check the date.
One agent, three surfaces
The architecture is one agent identity worn three ways. All three surfaces share sign-in with ChatGPT, honor the same AGENTS.md project-instruction files, and draw on the same Codex model line, so a task’s context and conventions travel with it. The shared instruction file is the underrated piece: write “run make check before declaring done, never touch the generated client, prefer table-driven tests” once in the repo, and the CLI on your laptop, a cloud container, and a teammate’s IDE panel all obey it.
| Surface | Its job | Where it runs |
|---|---|---|
| Codex CLI | Supervised local work, tight iteration | Your terminal, your machine |
| Codex cloud | Delegated batches, parallel attempts | Sandboxed containers on OpenAI’s infrastructure |
| IDE extension | Review-heavy sessions, cloud-task triage | VS Code and forks, in a side panel |
Operationally this is the pitch: you can start a task at the keyboard, decide it doesn’t need you, and fan the follow-ups out to cloud containers — then review everything as diffs wherever you happen to be. No single-surface harness offers that handoff as cleanly, and the rest of this review keeps coming back to it.
Three surfaces, one shared spine: ChatGPT sign-in, AGENTS.md, and the Codex model line.
Codex CLI in the terminal
The CLI is the surface that earns the daily-driver label. The fundamentals:
- Open source and fast. The CLI is open source at github.com/openai/codex, rewritten in Rust for a single-binary install and quick startup.
- Configured in two files.
~/.codex/config.tomlholds machine-level settings;AGENTS.mdfiles — global, repo root, or per-directory — carry project instructions the agent reads before acting. - Approval modes with real teeth. Three working postures: read-only, auto (edits allowed inside the workspace, approval required to leave it), and full access. Underneath sits OS-level sandboxing — Seatbelt on macOS, Landlock on Linux — with network access off by default in the middle mode.
- Extensible, to a point. MCP servers plug in for external tools (Model Context Protocol support is first-class), and a headless
codex execmode covers scripting and CI. It is a thinner extension story than Claude Code’s hooks, subagents, and skills stack — more on that gap below.
A sketch of a working config.toml:
# ~/.codex/config.toml
model = "gpt-5.6-codex" # check `codex --list-models` for current IDs
model_reasoning_effort = "medium" # low | medium | high | xhigh
approval_policy = "on-request" # ask before commands leave the sandbox
sandbox_mode = "workspace-write" # edits allowed inside the repo only
[mcp_servers.github]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-github"]A daily-driver vignette, because the modes only make sense in motion. You open a worktree for a refactor that touches forty files, start the CLI in auto mode, and describe the target shape. The agent reads, plans, and starts editing — no prompts, because edits inside the workspace are pre-approved. Eleven minutes in it wants to run the integration suite against a local container, which means network: that surfaces one approval prompt, you grant it, and the loop continues. The sandbox contained the blast radius the whole time; your attention was only spent where the risk actually lived. In that posture the CLI feels close to Claude Code with the guardrails welded on rather than bolted on.
The headless mode completes the picture for automation:
codex exec "bump the lockfile, run tests, summarize breaking changes" --jsonThat one-liner is how Codex ends up inside CI jobs and cron scripts — same agent, no TUI, exit codes you can branch on.
Codex cloud: the delegation engine
Codex cloud is the surface with no real rival, and the reason this review exists. The model: each task runs in a sandboxed container preloaded with your repo and environment. You write a prompt, the agent works alone — internet access off by default, dependencies from your environment config — and the output arrives PR-shaped, ready for review.
The signature move is parallel fan-out. Launch several independent tasks at once, or several attempts at the same hard task, and review the survivors. Three attempts at a gnarly bug costs three prompts; you keep the best diff and close the rest. No local harness matches this, because your laptop is one container and OpenAI’s fleet is many.
The fan-out pattern: parallel attempts are cheap insurance against agent dead ends.
A worked morning: queue three tasks over coffee — a test backfill on the payments module, a dependency bump with its migration notes, a lint-debt sweep — and by standup you are reviewing three PRs instead of running three sessions. The economics of that hour are the product’s whole argument: your attention went entirely to review, the only step that needed it.
The GitHub integration closes the loop. Mention the agent on a pull request and it delivers a review; enable it repo-wide and it reads every PR; hand a well-written issue off and it comes back as a branch. For teams, Slack and SDK entry points let tasks originate wherever the conversation already is. The net effect is that Codex cloud stops being a destination and becomes a queue you feed from wherever you work.
The honest failure mode is environment setup. Cloud containers start from a base image plus whatever setup script you define — install steps, environment variables, secrets, and a network allowlist — and until that config is dialed in, tasks fail on missing dependencies, private registries, and blocked hosts rather than on anything the model got wrong. Budget a real afternoon for it, have the person who knows your build system write the setup script, and expect the first week’s failures to be plumbing, not intelligence. Teams that skip this step conclude the product is flaky; teams that do it get a delegation engine.
The IDE extension: a review console more than a Cursor rival
The extension brings the same agent into VS Code and its forks — Cursor, and Devin Desktop (formerly Windsurf) among them — as a side panel: chat, agent edits with diff-first review, and local-to-cloud handoff without leaving the editor.
Position it honestly: this is the newest surface and the least lore-rich. Most power users we know treat it as a review console — triage cloud tasks, inspect diffs in a real editor, kick follow-ups back — rather than as a replacement for an agentic IDE. The tell is where sessions start: people open the panel to finish work that began elsewhere, not to begin it. If the IDE-versus-terminal decision is live for you, our Claude Code vs Cursor shootout is the framework piece.
Strategically the extension says the quiet part: OpenAI wants Codex wherever you already work rather than betting on one surface winning. That reading fits the pattern in our OpenAI agentic stack analysis — ship every surface, let usage decide.
The models: the Codex line and reasoning effort
Since 2025 the pattern has held: each OpenAI flagship gets Codex-tuned siblings. As of August 2026 the line is built on GPT-5.6 (“Sol”), OpenAI’s current flagship, in the usual three-tier split.
| Tier | What it is | Use it for |
|---|---|---|
| Frontier Codex model | The flagship tuned for long agentic runs | Architecture, debugging, multi-hour sessions |
| Standard Codex model | The default balance of cost and capability | Everyday supervised work |
| Mini Codex model | Cheap and fast | Mechanical steps: renames, boilerplate, summaries |
“Codex-tuned” means trained against the harness’s own loop: long tool-call chains, context compaction for multi-hour sessions, and diffs that read like pull requests instead of snippets. In practice the tuning shows up as fewer stalls deep into a session and less prompt ceremony to get PR-quality output. It is the same co-design bet Anthropic makes with Claude Code, and it is the strongest argument for first-party harnesses generally: the model has seen this exact loop in training.
The reasoning-effort dial (low through xhigh) is the main cost lever, and worth configuring per lane rather than globally. Map it simply: effort up for architecture and debugging, down for boilerplate. High effort costs both latency and quota — an xhigh debugging session thinks for minutes at a stretch and debits accordingly — so leaving it pinned at xhigh is how Plus users discover their window by Wednesday. The mini tier plus low effort is nearly free by comparison and covers more of a working day than pride admits.
The trade-off to name plainly is model monogamy. The first-party experience is OpenAI models only — no BYOK escape hatch across the plan-authenticated surfaces, though the open-source CLI technically accepts OpenAI-compatible endpoints via config. That is the opposite of the decoupling norm across the harness category, and it matters if you want one harness fronting many models.
What your ChatGPT plan buys: OpenAI Codex access and pricing
The ChatGPT Codex bundle is the commercial hook: if you hold any paid ChatGPT plan, you already own a usage-limited slice of everything above. Verified as of August 27, 2026.
| Plan | Price | What it covers for Codex |
|---|---|---|
| Plus | ~$20/mo | All three surfaces with modest rolling-window limits — evening sessions and light delegation |
| Pro | ~$200/mo | The heavy tier: much larger windows, priority capacity, frontier reasoning modes |
| Business | ~$25–30/seat/mo | Plus-class limits per seat, workspace admin, training excluded by default |
| Enterprise | Custom | Pooled capacity, environment controls, compliance surface |
Usage debits through the now-standard pattern — a rolling window plus a weekly ceiling — and cloud tasks debit differently from CLI turns, since a container that works alone for forty minutes consumes what many supervised exchanges would. Two overflow paths exist when the window bites. Purchasable credits cover burst use inside the plan experience, metered per task, and API-key billing covers CLI use outside plan limits entirely, at standard token rates. Which path wins depends on shape: credits for occasional spikes, API keys for scripted or CI workloads, a Pro upgrade once overflow becomes routine — the same hybrid arithmetic every vendor now runs, covered across the market in our token plan decoder and, as a trend, in the subscription squeeze.
A worked scenario makes the tiers concrete. Suppose your week is two supervised CLI sessions plus a nightly batch of three cloud tasks. On Plus, the CLI sessions fit comfortably but the nightly batch walks into the weekly ceiling by Thursday; you either buy credits for the last two nights or let the queue wait for the reset. On Pro, the same week never touches a limit, and the question inverts: does removing the Thursday interruption justify ten times the sticker? For most people the honest answer arrives from measurement, not intuition — meter one real month on Plus, price the credit top-ups you actually bought, and upgrade only if they approach Pro’s premium.
The general rule: a Plus window sustains real but part-time agent work — an evening’s supervised session or a few queued cloud tasks daily. Pro pays for itself when Codex becomes your delegation engine, with parallel cloud tasks most days, or when reasoning-heavy sessions run long enough that Plus’s window interrupts them. If you only burst one week a month, credits beat upgrading.
What OpenAI Codex is genuinely best at
- Cloud delegation at volume. Batches of well-specified, independent tasks — test backfill, dependency bumps, lint debt — reviewed asynchronously as PRs. One engineer triaging a queue replaces an afternoon of babysitting sessions.
- Parallel attempts on hard problems. Fan out three approaches to one bug, keep the best diff. Cheap insurance against the dead-end failure mode every agent has.
- GitHub-embedded review. The code-review integration makes Codex a second reviewer on every PR — mention it and get a substantive pass, which quietly raises the floor on team review quality.
- Sandbox posture. OS-level sandboxing by default is a genuine safety edge for full-auto local runs — the difference between “the agent can’t leave the workspace” and “we ask it nicely.”
Codex vs Claude Code: the honest gaps
Where Codex trails, stated without varnish. Claude Code’s hooks, subagents, skills, and plugin ecosystem have no Codex equivalent — the customization ceiling is simply lower, and power users feel it within a week. There is no clean way to fire a formatter after every edit, spawn a specialized subagent for the database layer, or package a team workflow as an installable unit; the Codex answer to most of those is “put it in AGENTS.md and hope,” which works until it doesn’t.
The interactivity styles differ too, and the lore is consistent about it: Codex optimizes for delegate-and-review — write a complete spec, come back to a diff — while Claude Code optimizes for tight supervised pairing, thinking out loud with you mid-task. That is a supervision-style difference, not a quality ranking, but it decides which tool you reach for at 9 a.m., and it is why the two coexist so easily in one rotation — our Claude Code field guide covers the pairing style in depth. And on model choice, Claude Code decouples — compatible endpoints make it a front-end for many models — while Codex stays married to OpenAI’s line.
Where Codex leads is the previous section: cloud fan-out, parallel attempts, GitHub-native review, and default sandboxing. Claude Code has no first-party answer to the container fleet, and community workarounds don’t match the one-prompt ergonomics.
Be fair about trajectory: this gap list shrinks release by release, in both directions, and every claim in this section is dated August 2026. Re-check before repeating any of it in a purchasing memo.
Local vs cloud: the workflow patterns that work
The routing rule that holds up: keep work local when your judgment is in the loop every few minutes — design-heavy changes, unfamiliar code, anything where the spec is emerging as you go. Fan out to cloud when the spec is complete and review can wait.
- Local if: the task needs taste, the codebase is new to you, or you’d interrupt within five minutes anyway.
- Cloud if: the task is well-specified and independent, you want multiple attempts, or it’s one of a batch.
The daily rhythm that emerges: morning triage queues cloud tasks while you read overnight results, deep-work blocks run the CLI on whatever needs your judgment, and a review batch closes the day. Parallel attempts stay reserved for the genuinely gnarly — a bug that has eaten two sessions already is exactly the case for three simultaneous approaches. The failure pattern to avoid is the inverse rhythm: delegating emergent design work to cloud (it comes back confidently wrong) and babysitting mechanical work locally (you become the bottleneck on tasks that never needed you).
Run this for a month and the sprawl arrives on schedule: CLI sessions on your machine, cloud tasks in OpenAI’s queue, all of it beside your Claude Code history — three session stores and no shared search. When a teammate asks “didn’t an agent already solve this in March,” the answer lives in none of the dashboards you can grep. That is the fleet problem our multi-agent command center piece exists to solve.
Product note: Codex sessions on top of Claude Code sessions is exactly the sprawl problem Automater Lite exists for — one local-first archive with full-text search, session resume, and per-provider token metering across 10+ CLIs. Free, on automater.ai.
Codex on a team
The admin surface covers what an evaluating team lead needs first: workspace-level enablement, environment controls for cloud tasks, and usage analytics for seat-level spend visibility.
Data policy, stated carefully because it decides deals: business-tier customers are excluded from model training by default, with retention controls by tier; consumer plans carry their own training toggles. Confirm the current terms in OpenAI’s platform documentation rather than any secondhand summary, including this one.
The team pattern that works in practice: AGENTS.md conventions committed in-repo so every surface behaves consistently, cloud environments defined once by whoever knows the build system, and the review integration switched on for every PR. Teams that do those three things in week one skip most of the flailing.
Verdict by persona
- The ChatGPT Plus holder who codes: you already paid for it — turn it on, learn cloud delegation, and stay on Plus until the window genuinely bites.
- The Claude Code daily driver: add Codex as the delegation lane, not a replacement; the two harnesses’ strengths barely overlap.
- The team lead on GitHub: the review integration and issue-to-PR flow justify a Business trial on their own.
- The enterprise evaluator: data controls and sandboxing are the story; environment fit will decide your pilot, not benchmark claims.
For how Codex ranks against the whole field, our best agentic AI tools roundup holds the scoreboard.
FAQ: OpenAI Codex
What is OpenAI Codex now?
OpenAI Codex is the 2025-era agent product, not the 2021 completion model: an open-source Rust CLI, a cloud agent running tasks in sandboxed containers, and an IDE extension, driven by Codex-tuned versions of OpenAI’s flagship models and bundled with paid ChatGPT plans.
Is Codex included in ChatGPT Plus?
Yes. Plus (~$20 a month) includes Codex across CLI, cloud, and IDE with rolling-window usage limits sized for part-time agent work. When the window bites, purchasable credits cover bursts without an upgrade; sustained daily drivers usually find Pro pays for itself.
Is Codex CLI open source?
Yes — the Rust CLI is open source at github.com/openai/codex. Be precise about what that covers: the harness is open, the Codex models are not, and the polished first-party experience assumes OpenAI models behind it. Community forks exist; the models stay proprietary.
Is Codex better than Claude Code?
They win different games. Codex leads on cloud delegation, parallel attempts, and GitHub-embedded review; Claude Code leads on terminal depth — hooks, subagents, skills — and model flexibility. Most heavy users we know run both: Claude Code for supervised pairing, Codex as the delegation lane.
Can I use Codex with an API key instead of a subscription?
Yes — the CLI accepts API-key auth billed at standard token rates, which suits CI jobs, scripts, and spiky personal use. For steady daily work a plan is usually cheaper per token; run the crossover math against your own logged usage before choosing.
