OpenAI Codex

Overview

OpenAI Codex is OpenAI’s software-engineering agent suite: the same agent harness surfaces in the Codex CLI (local terminal), the IDE extension (VS Code and compatible editors), the Codex desktop app (macOS and Windows), Codex Cloud (async agents in ChatGPT at chatgpt.com/codex), and ChatGPT on the web. It is not the 2021 “Codex” completion model that once powered early GitHub Copilot—today’s product is a full coding agent that inspects repos, edits files, runs commands, reviews diffs, and can hand work to isolated cloud environments.

Maker: OpenAI. Job: turn natural-language engineering tasks into real repository changes with human control over permissions, models, and review. Sign-in is usually a ChatGPT account (Free–Enterprise), so usage is bundled into ChatGPT plans; optional API-key auth bills Platform token rates for local/CI work.

The CLI is open source (Apache-2.0) at github.com/openai/codex—Rust-heavy harness, 90k+ stars, frequent releases. Install via install script, npm i -g @openai/codex, Homebrew cask, or GitHub Release binaries. Open harness means you can inspect the agent loop, file issues, and run non-interactive modes in CI.

Key features

• One agent, many surfaces — Same ChatGPT-linked account and agent loop across terminal, IDE panel, desktop app, and Cloud. Start a task in the editor, continue in CLI, or delegate to cloud without re-explaining the whole job.
• Codex CLI agent loop — Interactive terminal session: explore code, plan, edit, run local tools (tests, linters, package managers), show diffs, accept steering mid-turn. Slash commands include /init, /status, /permissions, /model, and /review.
• AGENTS.md project instructions — Layered markdown instructions Codex reads before work (global + repo overrides). Teams encode build/test commands, style rules, and “do not touch” paths so every session starts with consistent context.
• Permissions & sandboxing — Explicit control over when Codex may edit files or run shell commands. Sandbox modes and writable roots limit blast radius; useful for untrusted tasks or shared machines.
• Model choice & reasoning effort — Switch models and reasoning effort per task. Common 2026 options include frontier GPT-5.x models for hard work and dedicated gpt-5.3-codex (and related Codex-optimized variants) for cost-sensitive volume. Mini models stretch rate limits on routine edits.
• Code review mode — Dedicated review against uncommitted changes, a commit, or a base branch. Reports prioritized findings without mutating the tree—fit for pre-PR hygiene.
• Skills, plugins & MCP — Package repeatable workflows as skills; install plugins (GitHub, Slack, Figma, calendars, docs, etc.); connect Model Context Protocol servers so Codex can call external tools with session-visible tool lists.
• Subagents & parallel work — Delegate focused sub-investigations, then fold results into the main session. Desktop app workflows emphasize multi-task / multi-agent management (worktrees, parallel threads).
• Codex Cloud — Async agents in OpenAI-managed sandboxes tied to GitHub repos. Launch a long refactor or PR task, leave the machine, return to a completed diff. CLI can browse/submit cloud work via codex cloud.
• IDE extension — In-editor chat, file edits with diff review, @file references, cloud delegation from the panel, and skills. Official marketplace extension integrates with VS Code’s agent/session surfaces.
• Desktop apps (macOS & Windows) — Manage threads, review diffs, annotate UI, capture app/browser context, run multi-agent work outside the terminal.
• Automation hooks — Non-interactive codex exec, MCP server mode, GitHub Action, and SDK/app-server for CI and product integrations.
• Web search, images & browser tools — Live search for current docs; screenshot/design inputs; browser tools on supported surfaces for UI feedback.
• Integrations — GitHub PRs/issues, Slack, Linear, and marketplace plugins where reviews and tickets already live.

Pricing

As of mid-2026, Codex is included with ChatGPT plans—there is no separate “Codex-only” consumer subscription for full product access. Included usage is metered; heavy work can require a higher tier, credit top-ups (where offered), or API-key billing for local tasks.

Individual ChatGPT + Codex (public list prices, USD, mid-2026):

Plan	Price	Codex positioning
Free	$0/mo	Limited Codex access for trying small tasks
Go	$8/mo	More access than Free; light coding
Plus	$20/mo	Practical daily driver for many solos; CLI + IDE + web/app surfaces
Pro (5×)	$100/mo	~5× Plus Codex capacity for heavy solo use
Pro (20×)	$200/mo	~20× Plus capacity for all-day agent runs

Teams: ChatGPT Business seats are commonly listed around $20/user/month annual ($25 month-to-month). Since early April 2026, Business/Enterprise Codex moved toward pay-as-you-go token/credit billing (with Codex-only usage seats in some setups) rather than only fixed Codex seat licenses. Enterprise/Edu is custom (governance, audit, flexible credit pools).

Credits & windows (April 2026 restructure): On April 2, 2026 OpenAI aligned Codex metering with API-style token usage via credits (community explainers treat ~$0.04 per credit as the rough unit). Usage refills on a rolling ~5-hour window, so intensity matters more than “messages per month.” Published Plus ranges for local GPT-5.5-class work are often cited around 15–80 messages per 5-hour window (wide because task size varies); Pro multiplies that allotment. Small bug fixes may burn a handful of credits; multi-file refactors can burn dozens.

API / model rates (Platform, per 1M tokens, mid-2026 references): dedicated gpt-5.3-codex around $1.75 input / $14 output; frontier GPT-5.5-class around $5 / $30; intermediate GPT-5.4 and mini tiers fill the middle. Cached input is much cheaper than fresh input—session continuity matters. Fast mode (where offered) multiplies credit burn for speed.

What people actually spend: OpenAI-facing guidance and third-party breakdowns often land heavy daily Codex users near $100–$200 per developer per month all-in. Occasional users can stay on Plus at $20 if they scope tasks and prefer lighter models. CI/automation usually prefers API keys (no ChatGPT window, pure token billing).

Limits & gotchas

• Rolling windows, not monthly buckets — You cannot “save” a month of credits for one weekend crunch; capacity ages out over ~5 hours. Intense morning sessions borrow from afternoon capacity.
• Task size ≠ “one message” — Since token/credit metering, a one-line fix and a repo-wide refactor are not equal. Large context + lots of tool output + long generated files dominate cost.
• Model choice multiplies spend — Frontier models and high reasoning effort finish hard tasks better but burn credits faster. Mini / dedicated Codex models stretch Plus for routine edits.
• AGENTS.md bloat — Huge instruction files and many MCP servers inflate every turn’s input. Keep instructions tight; enable tools only when needed.
• Cloud vs local trade-offs — Cloud sandboxes need GitHub/environment setup and may not mirror every private dependency or secret. Local CLI uses your machine’s tools but shares your disk and network risk—permissions matter.
• API key ≠ full ChatGPT workspace — API auth is great for scripts/CI; some Cloud/workspace-only features stay tied to ChatGPT plan login.
• UI/frontend variance — Community reports often say Codex is strong on logic, debugging, and backend refactors; pixel-perfect UI still needs design context, screenshots, and human taste.
• Plugin maturity lag — Versus Claude Code’s community tooling ecosystem, some developers still find Codex skills/plugins less mature for elaborate multi-step frameworks—though OpenAI’s open CLI and marketplace are closing gaps.
• Approval fatigue vs autonomy — Strict permission modes slow flow; loose modes risk unwanted edits or shell commands. Tune per repo and task risk.
• Not a host/deploy platform — Codex writes and reviews code; you still own CI, hosting, secrets, and production ops.

Community sentiment

On Reddit (r/codex, r/ChatGPTCoding, r/ClaudeCode) and developer blogs in 2026, Codex is most often compared to Claude Code, then Cursor/Copilot.

What fans highlight: token efficiency and usable limits on ChatGPT Pro; speed and uptime; open-source CLI transparency; desktop app for parallel tasks; debugging quality on GPT-5.x; ability to stay productive on Plus/Go with disciplined model choice; cloud handoff for long jobs.

What critics highlight: Claude Code’s plan mode and community harnesses (skills frameworks) still feel richer for some; frontend quality can lag; credit math after the April 2026 change is harder to forecast than old per-message caps; Windows workflows still mix WSL vs native sandbox choices.

A common pattern is dual-wielding: Codex for volume/cost, Claude or Cursor for plan/UI moments. Leaderboards flip by release; teams care more about limits, harness UX, and repo fit.

Who should use it

• Solo developers already on ChatGPT Plus/Pro who want CLI + IDE + cloud agents without a second $20–$200 coding subscription.
• Terminal-first engineers who prefer an agent loop in-repo (explore → edit → test → review) over a full AI IDE fork.
• Teams standardizing on OpenAI that need GitHub/Slack/Linear plugins, admin controls, and Business/Enterprise governance.
• CI/platform engineers automating reviews or batch tasks via codex exec, GitHub Action, or API-key token billing.
• Cost-sensitive power users who will actively pick lighter Codex models and tight scopes to stay inside windows.
• Less ideal: no-code builders; orgs that cannot send code to OpenAI; pure autocomplete users (Copilot/Cursor tab may suffice).

Alternatives

• Claude Code — Anthropic’s terminal/IDE agent; often preferred for plan-heavy workflows and community skills depth.
• Cursor — AI-native IDE (VS Code fork) with Composer/Agent and multi-model choice inside the editor.
• GitHub Copilot — GitHub-native autocomplete + agent features; strong if your world is PRs and Microsoft/GitHub enterprise.
• Windsurf — Agentic IDE alternative with cascade-style flows for teams already in that ecosystem.
• Aider — Open-source CLI pair programmer; bring your own models/API keys, git-native commits.
• OpenCode — Open agent CLI option; some users route ChatGPT/Codex subs through third-party harnesses.
• Amazon Q Developer — AWS-centric coding assistant for shops standardized on Amazon identity and cloud.
• Devin — Fully autonomous SWE-agent product for longer unattended tickets (different price and trust model).

Verdict

OpenAI Codex in 2026 is a serious multi-surface coding agent—not the old completion-model brand. Strengths: open CLI harness, ChatGPT-bundled pricing, strong GPT-5.x debugging/implementation, and Cloud for async work. Weaknesses: credit/window complexity after April 2026 metering, thinner plugin ecosystem vs Claude Code for some teams, and mandatory human review on UI, security, and architecture.

Bottom line: If you already pay for ChatGPT Plus or Pro and live in terminal or VS Code, start here before stacking another full-price agent. If your team’s workflow is built around Claude’s plan/skills culture or you need an AI-first IDE first, compare Claude Code and Cursor side-by-side on your repo for a week—model leadership moves, but harness fit sticks.