OpenAI Codex

Pricing

Commercial

Platforms

Web, Terminal, IDE, Desktop, Mobile, Cloud, GitHub

Website

https://openai.com/codex

Free access note

Free ChatGPT/Codex availability and student API-credit programs may apply.

Caveat

Treat this as account- and region-dependent; verify current Codex and credit eligibility before planning usage.

Verdict for 2026

Codex is not just another code completion product. It is OpenAI’s attempt to make coding agents part of the normal software delivery loop: ask for a task, let the agent work in an isolated environment, review the result, and decide whether the change is good enough to ship.

My take: Codex is most interesting when your bottleneck is not typing code, but carrying many small engineering tasks through context gathering, implementation, testing, and review. If you want a smarter editor, Cursor or Windsurf may feel faster. If you want background software work that can produce reviewable changes, Codex belongs on the shortlist.

What Codex Actually Is

OpenAI describes Codex as a coding agent that helps developers build and ship with AI. The public Codex product page emphasizes real engineering work such as routine pull requests, complex refactors, migrations, and parallel agent work in cloud environments. The platform documentation describes Codex as an agent that can read, modify, and run code, including background work in its own cloud environment.

That distinction matters. Codex is closer to a cloud software engineering workflow than a traditional editor plugin. You should evaluate it by the quality of tasks completed, not by how magical it feels while typing.

What Changed With GPT-5.5, Skills, and Automations

OpenAI’s newer Codex positioning matters because it turns Codex from “one coding assistant” into a wider operating layer for engineering work. The public Codex page now centers GPT-5.5, parallel agents, cloud environments, worktrees, the macOS Codex App, CLI/IDE surfaces, GitHub-oriented code review, Skills, and Automations.

My take: the important update is not only a stronger model. It is the packaging around the model. Skills let teams encode repeatable workflows such as debugging, migration review, release-note drafting, or security checks. Automations make Codex useful for recurring work, but they also need explicit boundaries. GitHub PR and diff generation move the output into a reviewable software delivery path instead of leaving it as a chat transcript.

That makes Codex adoption more like introducing a new engineering system than installing an editor extension. Before using it heavily, decide who may create Skills, which repositories may run cloud work, which Automations are allowed, how worktrees are named, what commands count as proof, and when a human must approve before the agent continues.

June 2026 Codex Capabilities To Re-evaluate

The newest Codex updates make the product less “cloud coding agent only” and more like a cross-device work system. The capabilities that changed most recently are practical, not cosmetic:

• Appshots for richer context: Codex on macOS can attach an app window to a thread with a hotkey, including a screenshot and available text. My read: this reduces the setup cost for UI debugging, design implementation, logs, docs, and “what I am seeing right now” tasks.
• Goal mode across app, IDE, and CLI: Goal mode is generally available across the Codex app, IDE extension, and CLI. This is important because Codex can now be evaluated against an outcome and success criteria rather than a single prompt-response loop.
• Browser annotation improvements: in-app browser annotations and advanced annotation mode make Codex more useful for frontend work, because visual feedback can be tied to a live browser state instead of being described vaguely in text.
• Locked computer use on Mac: eligible Mac Computer Use users can keep Codex working remotely after the Mac locks, subject to regional constraints. This is useful for long-running debugging, but it raises the bar for host governance, credentials, and approvals.
• Computer Use and remote control for Windows: OpenAI has added Windows Computer Use in the Codex app for eligible users, and users can steer work on a Windows host from ChatGPT mobile or Codex on Mac while the Windows machine remains the host for files, shell, app server, and local context.
• Codex Profiles: eligible users can see Codex identity, activity over time, profile details, usage stats, and token activity. This turns usage from “the agent did something” into a more auditable operating signal.
• Active account sessions: ChatGPT active-session controls now include first-party OpenAI sessions where available, including ChatGPT, Codex, and API Platform sessions. That matters for teams because agent access is also account-session risk.

My practical conclusion: Codex is now strongest when the work involves a live environment, a local app, a browser, or a host machine that must stay connected while a human steers from elsewhere. It is also riskier than a plain code agent: once Codex can see apps, click, type, browse, run commands, and be controlled remotely, the adoption checklist must include host security, session review, approval policy, and auditability.

Mid-June 2026 Codex Updates

OpenAI’s mid-June Codex updates are not cosmetic. They make Codex feel more like an operating system for software work across ChatGPT, the Codex App, CLI, IDE, cloud tasks, connected hosts, and repository history.

The updates I would re-evaluate first:

• Rate limit resets can bank up to 15 windows: unused weekly rate limit resets can accumulate, which matters for bursty agent work. My read: this is useful for teams that run intense batches of Codex tasks, but it is not a substitute for narrow prompts, proof commands, and review discipline.
• Codex availability expanded to EEA, UK, and Switzerland: the rollout footprint is broader. Teams still need to check workspace, plan, regional, and admin eligibility before assuming every developer can use the same surface.
• Historical Codex thread search: searching previous Codex threads inside the Codex App makes long-running agent work easier to audit and resume. This is a real productivity feature because useful coding-agent work often spans multiple weeks, failed attempts, and follow-up reviews.
• Model and reasoning effort sync across CLI, IDE, and cloud tasks: OpenAI now lets eligible Codex surfaces follow settings from the Codex App. That turns Codex into a centralized configuration plane, not just a set of separate clients.
• Remote-session error visibility: better reporting for remote-session failures matters when Codex is working through a connected host. It reduces the “agent stopped somewhere else and nobody knows why” failure mode.
• Multi-repository tasks: cloud tasks can access all required repositories for multi-repo work. This is important for monorepo-adjacent systems, shared packages, app/API split projects, and platform migrations.
• Projects content as Codex context: ChatGPT Projects content can become source context for Codex tasks. This is powerful, but it also means teams should define what project notes, specs, customer details, and internal docs are appropriate to inject into coding tasks.

Compared with Claude Code, this reinforces the product split. Claude Code is closer to a local terminal runtime with explicit permissions, hooks, MCP, subagents, and shell proofs. Codex is becoming a ChatGPT-native runtime with shared account context, cloud/local task routing, thread search, mobile steering, connected hosts, and centralized model/reasoning settings. For serious work, run both against the same issue and judge the result by diff quality, proof commands, review time, and the clarity of the final explanation.

The Bigger Shift: ChatGPT-Native Agent Runtime

The closest Claude Code comparison is no longer “terminal agent versus OpenAI agent.” The better comparison is runtime design. Claude Code is productizing a terminal-centered agent runtime; Codex is productizing a ChatGPT-native software-work runtime that spans model selection, app surfaces, tool access, cloud delegation, local execution, and review.

The official Codex and ChatGPT release material points in this direction. GPT-5.5 is the high-capability layer for long-running work, with OpenAI describing 400K context availability in Codex and stronger agentic coding performance. Codex-Spark is positioned as a low-latency path for quick coding interactions. The Codex App adds Computer Use, an embedded browser, plugins, MCP servers, Git review, IDE sync, worktrees, mobile steering, memory, Automations, and local or cloud execution. Programmatic access tokens and Hooks GA move it further from a chat UI and closer to a governed runtime.

The runtime pieces are worth separating:

• Model layer: GPT-5.5 is the serious coding agent model. OpenAI’s launch material highlights a 400K context window in Codex, improved long-horizon agentic coding, stronger terminal-use benchmarks, and Fast mode for everyday work. Codex-Spark matters for the opposite reason: lower latency keeps small edit and Q&A loops from feeling like heavyweight delegation.
• App surface layer: Codex now appears across ChatGPT, Codex App, CLI, IDE, web/cloud tasks, GitHub, mobile remote access, and connected desktop/SSH hosts. That makes surface routing a product feature: the same task should not always start in the same UI.
• Tool and connector layer: plugins, MCP servers, Computer Use, browser flows, image generation, docs access, and connected services make Codex less isolated. The value is reach; the risk is permission sprawl.
• Control layer: Hooks GA, access tokens, approvals, worktrees, Automations, and Git/PR review are the parts that make Codex operational rather than conversational.
• Memory and continuity layer: OpenAI’s direction around memory, connected app context, mobile steering, and recurring Automations suggests Codex is being designed for work that spans sessions, not only one prompt.

My take: Codex is strongest when you treat it as an OpenAI-managed runtime for software work, not as a smarter autocomplete tool. The adoption question is therefore similar to Claude Code but with a different center of gravity: who controls the connected apps, which plugins and MCP servers are allowed, when cloud execution is acceptable, which Automations may run, and how human review stays in the loop.

Recent Update Map: What To Link Codex Against

The recent Codex updates make more sense when you place Codex next to adjacent tool layers instead of reviewing it in isolation. OpenAI is moving Codex toward a broad work surface: GPT-5.5 for harder agentic coding, Codex-Spark for low-latency interaction, the Codex App for multi-agent management, 90+ plugins for app context, MCP for tool access, Automations for recurring work, programmatic access tokens for CI/release workflows, and Enterprise/Edu controls for RBAC, compliance API, and Codex usage logs.

Use this map when deciding what Codex should replace, complement, or avoid:

• Terminal agent layer: compare with Claude Code, opencode, Gemini CLI, Aider, and Qwen Code. Codex wins when you want OpenAI account integration, cloud worktrees, mobile steering, and managed review surfaces; terminal-first tools still win when local shell ownership and model routing matter more.
• Editor agent layer: compare with Cursor, Windsurf, Cline, Roo Code, Continue, and Zed. Codex is weaker for instant inline edits, but stronger when a request should become a thread, background task, or PR-shaped change.
• Team platform layer: compare with GitHub Copilot, OpenHands, Tabby, and Amp. Codex belongs here when governance, workspace access, worktree review, usage logs, and release automation matter.
• Routing and cost layer: compare with 9Router, OpenRouter, and NVIDIA NIM. Codex is the managed OpenAI path; routers are useful when you need provider fallback, token-cost control, or model choice outside one vendor.
• Workflow and spec layer: connect Codex with OpenSpec and the Skills Matrix. This is where Codex becomes more durable: narrow skills, explicit acceptance criteria, repeatable hooks, and proof commands make background work reviewable.

My practical recommendation: use Codex for OpenAI-native task delegation, cross-surface continuity, and reviewable cloud/local work. Keep editor agents for tight edit loops, routing tools for cost and provider resilience, and spec/skill tools for making Codex tasks less ambiguous.

Late-June 2026 News Watch

The late-June signal is that Codex is becoming more inspectable and more tied into ChatGPT as an operating surface. I would not describe this as “just a better model.” The useful direction is workflow evidence: replayable work, clearer developer controls, richer project context, and more surfaces where a human can steer the task before the final diff lands.

For teams comparing Codex with Claude Code and Cursor, this changes the evaluation question. Codex should be tested on whether it can preserve the reasoning trail, reuse project context safely, and move between app, CLI, IDE, cloud task, GitHub, and mobile approval without losing the acceptance criteria. If Record & Replay or Developer Mode style controls are available in your workspace, treat them as review infrastructure, not novelty features.

My take: Codex is strongest when the task has a clear owner, a narrow target, proof commands, and a human review step. The more Codex connects to ChatGPT projects, hosts, plugins, and automations, the more important it becomes to define what context is allowed into a coding task and what evidence must come back out.

What Changed With ChatGPT App Integration

The recent OpenAI direction makes Codex less like a single tool and more like a ChatGPT-connected coding surface. According to OpenAI’s ChatGPT release notes from May 14, 2026, Codex remote access is available in preview inside the ChatGPT mobile app. The important point is not just “Codex is on mobile.” It is that a phone can now act as a control surface for active Codex work running on a connected Mac host.

From the official release notes and Codex remote-connection docs, the mobile flow can start or continue threads, answer Codex questions, change direction, approve actions, review findings, and inspect live context such as project state, approvals, plugins, screenshots, terminal output, diffs, and test results. Setup starts from the Codex App on the host and continues in ChatGPT after scanning a QR code. The host still matters: it must remain awake, online, signed in, and running Codex for remote access to continue.

My read: this changes Codex’s product shape. Codex is no longer just “ask an agent to work in the cloud” or “run a CLI locally.” It is becoming an operating layer around software work: desktop for parallel threads, CLI for terminal control, IDE extension for editor context, web/cloud for delegated tasks, GitHub integration for repository work, and ChatGPT mobile for steering approvals when you are away from the machine.

How the Surfaces Fit Together

• Codex App: the command center. OpenAI describes it as a desktop experience for GPT-5.5 parallel threads with worktrees, Automations, Git functionality, review, terminal actions, browser flows, Computer Use, Skills, plugins, MCP servers, and IDE sync.
• Codex CLI: the local terminal interface. OpenAI’s docs say it can read, change, and run code in the selected directory, authenticate with ChatGPT or an API key, and use approvals before edits or commands.
• IDE extension: the editor bridge. It matters when you want Codex close to VS Code, Cursor, or Windsurf rather than only in a terminal or separate app.
• Cloud tasks: the delegation layer. Codex can work in isolated environments and return changes that you review, merge, or pull down.
• ChatGPT mobile app: the remote control layer. It is for steering active work, approving actions, and reviewing diffs or test output from a connected host, not for replacing the host.
• GitHub and ChatGPT app connection: useful for repository understanding and code search. OpenAI’s GitHub connector docs distinguish read-only ChatGPT repository analysis from Codex workflows that generate, edit, push, or create PR-oriented changes.

The product implication is simple: Codex is strongest when you treat it as a workflow system, not a single interface. The same coding agent can appear in different places depending on the job: local control in CLI, review in app, context in IDE, remote approval on phone, and repository-level work through GitHub-connected flows.

Private Asset Notes

The visuals on this page are private Coding Agent Tools assets. They are drawn from the product model described in OpenAI’s public Codex pages, but the layout, text hierarchy, and diagrams are original site material rather than copied official screenshots.

Best For

• Teams already using ChatGPT or OpenAI models heavily.
• Developers who want to delegate coding tasks rather than only receive inline help.
• Repositories where isolated cloud worktrees and background tasks are useful.
• Teams that want a ChatGPT-native agent runtime with models, tools, memory, Automations, hooks, plugins, MCP, and PR review in one operating layer.
• Security and infrastructure teams evaluating OpenAI’s Trusted Access paths for Codex Security or deeper computer-use-heavy workflows.
• Work that benefits from parallel attempts, code review, and explicit verification.
• Developers who want to keep Codex work moving from phone, desktop, IDE, terminal, and GitHub-connected contexts.
• Teams comparing Codex with Claude Code, GitHub Copilot coding agent, and opencode.

Not Best For

• Developers who mainly want low-latency autocomplete.
• Projects that cannot allow code or build context into a managed cloud environment.
• Teams without clear review, tests, or permissions.
• Highly ambiguous product work where the agent cannot infer acceptance criteria.
• People expecting mobile Codex to run independently without an awake connected host.

Where It Beats Cursor

Codex can beat Cursor when the unit of work is an issue or pull request, not a local edit. A good Codex task is something like: fix this failing test, update this API client, migrate this small module, add coverage for this behavior, or investigate why this command breaks.

The advantage is parallelism and background execution. You can ask an agent to work while you stay focused on review, product judgment, or another task. That is a different productivity model from Cursor’s interactive editing loop.

Where Cursor Still Wins

Cursor still wins for immediate code reading and tight edit loops. If you are exploring unfamiliar code, selecting a block, asking for an explanation, and making a small inline change, an editor-first product remains more direct.

Codex asks you to think in tasks and threads. Cursor asks you to think in edits. The difference sounds small, but it changes how you write prompts, how you review output, and how you manage risk.

Codex vs Claude Code vs opencode

Codex and Claude Code are the closest commercial comparison: both are about delegating software engineering tasks to an agent. I would compare them on your own repository using the same task and the same acceptance criteria.

Claude Code may feel more natural if your team wants terminal-local control and an agent that lives close to your shell workflow. Codex is compelling if you want OpenAI-native cloud task execution, parallel background work, Codex App thread management, and tighter integration with ChatGPT accounts, mobile approvals, and connected services.

opencode is the open-source counterweight. It is the better philosophical fit when you want inspectability, model choice, and more ownership of the agent loop. Codex is the stronger candidate when you want a managed product experience and are comfortable with the OpenAI ecosystem.

Adoption Checklist

• Define which repositories Codex may access and which files are off limits.
• Decide who can author or install Codex Skills, and review them like project automation rather than casual prompts.
• Treat Automations as scheduled engineering work: give them narrow scope, clear proof commands, and a human review path.
• Start with small, reviewable tasks rather than broad product work.
• Require each task to include expected tests or verification commands.
• Decide which surface owns which job: CLI for local changes, app for parallel threads, cloud for delegation, IDE for editor context, and mobile for approvals.
• Compare Codex output against Claude Code or opencode on the same issue.
• Track review time, not just generation speed.
• Decide whether cloud execution fits your security and compliance requirements.
• If using mobile remote access, treat the connected Mac or SSH host as production infrastructure: keep it awake, patched, credential-scoped, and governed by the same approval policy as local Codex work.

Quality Signal

The strongest Codex signal is a small pull request that explains the problem, keeps the diff narrow, runs the expected checks, and is easy for a human reviewer to accept or reject.

The weakest signal is a large change that appears impressive but shifts complexity into review. If the agent saves typing but increases uncertainty, it is not improving engineering throughput.

Watch Outs

Do not treat Codex as a substitute for product judgment. It can execute a task, but the task still needs crisp boundaries. Ambiguous prompts create ambiguous diffs.

Also separate “agent can run in the cloud” from “agent is safe to run on every repository.” Sensitive codebases need explicit access policy, secret handling, audit expectations, and review gates.

Source Notes

• OpenAI’s Codex product page describes Codex as a coding agent for building and shipping with AI, including complex refactors, migrations, and parallel cloud environments.
• OpenAI’s Codex product page positions Codex around GPT-5.5, the Codex App, parallel agents, Skills, Automations, and connected engineering surfaces.
• OpenAI’s May 21, 2026 ChatGPT release notes describe Codex Appshots, Goal mode across app/IDE/CLI, in-app browser annotations, locked computer use, and browser-use improvements.
• OpenAI’s May 29 and June 1, 2026 ChatGPT release notes describe Windows Computer Use, remote control for Windows-hosted work, browser performance improvements, and Codex Profiles.
• OpenAI’s June 2, 2026 ChatGPT release notes describe active account session controls that can include ChatGPT, Codex, and API Platform sessions where available.
• OpenAI’s June 11 and June 16, 2026 ChatGPT release notes describe historical Codex thread search, model and reasoning effort sync across CLI/IDE/cloud tasks, remote-session error visibility, multi-repository tasks, EEA/UK/Switzerland availability, and rate limit resets that can bank up to 15 windows.
• OpenAI’s mid-June 2026 Codex and ChatGPT project updates describe using ChatGPT Projects content as source context for Codex tasks, which is useful for continuity but raises context-governance questions.
• OpenAI’s GPT-5.5 announcement describes GPT-5.5 for agentic coding and Codex-Spark for lower-latency coding interactions.
• OpenAI’s ChatGPT release notes describe Codex App updates such as Computer Use, an embedded browser, image generation, plugin expansion, MCP support, memory, Automations, programmatic access tokens, Hooks GA, remote SSH, and mobile remote control.
• OpenAI’s Enterprise/Edu release notes describe Codex App governance details such as RBAC, compliance API support, Codex usage logs, connector controls, and workspace-level access management.
• OpenAI’s “Codex for almost everything” update describes image generation, 90+ plugins, expanded Automations that can reuse existing threads, and deeper app/MCP integrations.
• OpenAI’s “Work with Codex from anywhere” update describes mobile steering, remote host requirements, and scoped programmatic access tokens for CI, release, and internal automation workflows.
• OpenAI’s Codex Skills help page explains how Skills package instructions, scripts, and assets for repeatable Codex workflows.
• OpenAI’s Codex pull-request and diff docs describe how Codex work can be converted into reviewable GitHub-oriented changes.
• OpenAI’s Codex platform documentation describes Codex as an agent that can read, modify, and run code in the background using a cloud environment.
• OpenAI’s Codex CLI help page describes Codex CLI as an open-source command-line tool that brings reasoning models into the terminal.
• OpenAI’s May 14, 2026 ChatGPT release notes describe Codex remote access in the ChatGPT mobile app for starting or continuing threads, approving actions, and reviewing diffs, terminal output, screenshots, and test results.
• OpenAI’s Codex App and remote connection docs describe the desktop app as a command center for parallel threads and explain that mobile access depends on a connected host that stays awake, online, and running Codex.
• OpenAI’s GitHub connector docs distinguish ChatGPT’s read-only repository analysis from Codex workflows that generate, edit, push, or produce PR-oriented code changes.