AI Productivity: The Evolution of OpenAI Codex and How to Evaluate Alternatives
In 2026, Codex is OpenAI's coding agent platform spanning CLI, cloud agent, IDE, and API. Toris, a Claude Code user, tracks its evolution to verify alternatives and hedge risk.
Joohwan Yu · Founder, Full Stack Developer
Toris · Published
Contents
Q. What is OpenAI Codex in 2026? It is not a code-specialized model but OpenAI’s coding agent platform, spanning four surfaces: CLI, cloud agent, IDE extension, and API.
Toris is a one-person studio that uses Claude Code as its main tool, but we keep an eye on competing tools. When an entire development workflow sits on top of a single tool, the maturity of the alternatives is itself a risk hedge. As founder and developer, the reason I watch Codex is not to switch right away, but to keep checking how far our harness assets, such as rule files, can be ported, and at what point a delegation-style workflow would change our profit and loss.
The name “Codex” has come to mean something completely different over the last few years. Codex in 2021 was the name of the code-specialized model that powered GitHub Copilot, but as of early 2026 Codex refers to OpenAI’s entire coding agent brand. The CLI that runs in the terminal, the remote agent that performs work asynchronously in the cloud, and the IDE extension are all grouped under the Codex umbrella.
From a developer’s perspective, this post covers how Codex has evolved, how it connects to ChatGPT subscriptions (Plus/Pro) and the API, how local CLI and cloud execution differ, and where it fits well in a real workflow. Many parts change quickly, so specific figures and model names are pinned to “as of early 2026.”
Codex’s three transformations
The history of Codex can be summarized in one line: “model → CLI → cloud agent.”
Generation 1: the Codex model (2021)
The first Codex was a model that fine-tuned GPT-3 on a code corpus. It was the engine behind GitHub Copilot’s early autocomplete, and was briefly exposed in the API through endpoints such as code-davinci-002. But after the GPT-4 family absorbed coding ability, the concept of a standalone “Codex model” disappeared once. In other words, the Codex we talk about now shares only a lineage with this first generation and is effectively a different product.
Generation 2: Codex CLI (2025)
In 2025, OpenAI revived Codex as an open-source coding agent that runs in the terminal. This is the Codex CLI. It is in the same category as Claude Code, Aider, and Cursor’s agent mode: an agent that reads a local repository, edits files, and runs commands. There were three key points.
- Local execution: The code doesn’t leave my machine, and it runs shell commands directly.
- Model choice: It uses OpenAI’s reasoning-family models as the backend.
- Approval/sandbox model: The user controls what the agent executes.
Generation 3: cloud / asynchronous Codex agent (2025-2026)
The biggest change is that Codex left the local machine. Cloud Codex clones the repository into an isolated remote container and does the work there. This is where the asynchronous (async) workflow comes from: you throw over “fix this bug,” do something else, then receive the finished diff or PR. The decisive difference from the local CLI is that you can throw multiple tasks in parallel. With IDE extensions (VS Code family) added, the same Codex can now be called consistently from three places: terminal, cloud, and editor.
The surfaces where Codex is exposed
As of early 2026, there are broadly four paths by which developers encounter Codex.
| Surface | Where it runs | Characteristics | Good for |
|---|---|---|---|
| Codex CLI | Local terminal | My machine, shell access, open source | Iterative development, local debugging |
| Codex cloud agent | Remote isolated container | Async and parallel, creates PRs | Large refactors, background tasks |
| IDE extension | Inside the editor | Shared context, inline review | Code review, small edits |
| Responses/Agents API | My infrastructure | Programmatic integration | Building your own tools and pipelines |
What matters here is that these surfaces are not separate products but different ways of calling one agent. The design goal is a flow where a conversation started locally can be handed to the cloud, or where you pick up in the CLI after reviewing in the editor.
ChatGPT subscriptions and the API: where does the billing go?
Where Codex usage rights are tied is surprisingly confusing from a developer’s standpoint. As of early 2026, the big picture is this.
- Included in ChatGPT Plus / Pro subscriptions: There is a path to use the Codex CLI and cloud agent with just a ChatGPT login, without a separate API key. Pro gives more generous usage than Plus and access to heavier reasoning models. Specific limits keep being adjusted, so I don’t list numbers here; it’s right to check the official page.
- API-key based (usage billing): When running Codex in your own pipeline or CI, you use a platform API key with per-token billing. This side is predictable pay-as-you-go, which suits team automation.
So just remember the two branches: individual developers use it on top of a ChatGPT subscription, and organizations/automation attach through the API. For reference, this flat-rate subscription rivalry was compared from a real-use perspective in Claude Code $200 vs Codex $200.
Getting started with the local CLI
After installing, you call the CLI directly from the repository root. A session looks roughly like this.
# Install (as of early 2026, distributed via npm)
npm install -g @openai/codex
# Run interactively from the repository root
cd my-project
codex
# Throw a one-line task right away (non-interactive)
codex exec "Standardize error handling in src/api and add tests"
# Run with a specified approval mode
codex --approval-mode auto-edit "Fix all type errors"
In interactive mode, the agent reads files, presents an edit plan, and asks for approval before running shell commands (such as running tests). The key here is the sandbox + approval model.
Sandbox and approval model
The Codex CLI sets up several approval levels so the agent can’t spray shell commands on its own judgment. Names and detailed behavior change with each version, but conceptually it’s this spectrum.
- Read-only (suggest): Both file edits and command execution need human approval every time. The most conservative.
- Auto edit (auto-edit): File edits are automatic, shell commands need approval. Practical for local refactoring.
- Full auto (full-auto): Both edits and execution are autonomous inside an isolated sandbox. Network blocking is the default.
Cloud agents run in an isolated container to begin with, so this autonomy burden is much lighter. Conversely, when turning on full-auto in the local CLI, it is safer to always check network blocking and directory scope. The perspective of designing what permissions and environment to give an agent is covered in more depth in AI Harness Engineering.
AGENTS.md: giving the agent context
Codex reads the AGENTS.md placed in the repository to recognize project rules. It plays the same role as Claude Code’s CLAUDE.md and has effectively settled in as a common convention across the agent ecosystem. A rough sketch looks like this.
# AGENTS.md
## Project overview
Next.js 15 + TypeScript blog. Package manager is pnpm.
## Commands
- Dev server: `pnpm dev`
- Tests: `pnpm test` (always run after changes)
- Lint/typecheck: `pnpm lint && pnpm typecheck`
## Code rules
- Components are functional + named exports
- No any; state only with zustand
- Commit messages follow Conventional Commits
## Do not
- Do not auto-generate public/markdown
- Do not modify environment variable/secret files
With this one file, you don’t have to repeat instructions like “run the tests” or “don’t use any” every time. The effect is especially big for cloud agents: in async execution where a person can’t step in midway, this document is effectively the only guardrail.
Toris also manages rule files as the first-line guardrail for agent operation. The fact that rule-file conventions are converging even across different tools is a good signal for us, because it means context assets built up in one tool have a lot of room to be ported to another.
A practical feel for cloud / async agents
The usage pattern of cloud Codex requires a different mindset from local.
- Fire-and-forget: Throw each of several issues over as a task, and receive them as PRs when done. Parallelism is productivity.
- Isolation by default: Each task clones the repository into its own container and runs there. It doesn’t contaminate my local state.
- Results are subject to review: A person reviews and merges the diff/PR the agent made. A structure of trust but verify.
The limits are clear too. The cloud container doesn’t have my local environment (installed tools, secrets, a running DB) as is. So if the setup script or dependency specification is sloppy, there are cases where the agent can’t even run the build. You can think of environment reproducibility as the success rate of the cloud agent.
So by Toris’s standard, the prerequisite for adopting cloud delegation is environment reproducibility. For a project whose build can’t stand up from a single setup script, I judge that delegation only adds review debt, not productivity.
Strengths and weaknesses
Strengths
- Speed and parallelism: You can run multiple async tasks at once, which is overwhelming for work like “the same fix across several repos.”
- The OpenAI model ecosystem: The reasoning-family models are strong at code and planning, and connect naturally to other OpenAI products with the same account.
- One agent, many surfaces: CLI, cloud, IDE, and API are grouped under the same brand, so there is little friction moving context.
- Open-source CLI: The local CLI is open, so it’s easy to pick apart its behavior and confirm trust.
Weaknesses (as of early 2026)
- Fast change: Model names, approval mode names, and usage limits change often. You always have to check the docs for the latest.
- Cloud environment reproducibility: As mentioned, cloud execution can spin its wheels on projects with complex dependencies or environments.
- A tendency toward ecosystem lock-in: Subscriptions, models, and surfaces are converging on OpenAI, which creates friction with a multi-provider strategy.
- Review burden: The higher the autonomy, the more diffs a person has to verify. In the end the bottleneck moves to review.
Where to fit it in a development workflow
In sum, splitting use by surface like this is reasonable as of early 2026.
- Local CLI: Iterative development and debugging while I watch beside it. Work that needs shell access.
- Cloud agent: Bulk, parallel handling of tasks with clear specs that can be isolated. For burning down small issues.
- IDE extension: Work where editor context matters, such as PR review and small inline edits.
- API: When embedding coding ability programmatically into CI or your own pipelines.
Toris uses the local-CLI-style workflow as its main one, and our position is to validate cloud-delegation style starting with repetitive tasks that have clear specs and can be isolated.
Codex is now not an “autocomplete model” but a coding agent platform spanning multiple surfaces. The market is reshaping quickly along with competitors such as Claude Code, so to get a sense of the whole landscape, read Claude Code trends and the 2026 AI coding agent landscape together.
How Toris applies this
We don’t stop at analyzing competing tools; we convert them into profit and loss for our workflow. Our adoption criterion is how portable our existing harness assets, such as rule files and verification loops, are, and we repeat the comparative re-evaluation against our main tool each time a major release comes out. If you need this kind of tool selection and automation design, Toris’s AI and workflow automation consulting can look at it with you.
▶️ Related videos
References
Advertisement