OpenAI shipped a new Codex on May 16, 2025 — not to be confused with the original 2021 code-completion model of the same name. This one is an agentic coding tool that runs tasks in isolated cloud sandboxes, with deep GitHub integration and support for parallel async execution. A month in, the fundamental value proposition is clear: it solves a different problem than Claude Code.
The short version: Claude Code is for the work you’re doing right now, interactively, in your terminal. Codex is for the work you want to delegate and come back to — implementing a feature, writing a test suite, refactoring a module — while you’re doing something else.
What Codex Actually Is#
Codex runs inside OpenAI’s infrastructure in a sandboxed environment. It has access to your GitHub repo (you grant it), can read the full codebase, write code, run tests, and open a pull request — without touching your local machine.
The key architectural difference from Claude Code:
- Cloud-hosted: Tasks run on OpenAI’s servers, not your laptop or GPU server
- Async: You submit a task, it runs, you review the PR — no need to supervise
- Parallel: Multiple tasks can run simultaneously on different parts of the codebase
- GitHub-native: Output is a PR, not a local file diff you stage yourself
The model powering it is codex-1, fine-tuned specifically for software engineering — optimized for following coding conventions, writing idiomatic code, and passing test suites rather than general reasoning.
Getting Started#
Codex is available to ChatGPT Pro, Team, and Enterprise subscribers and via the API. There’s no CLI to install — you connect your GitHub account through the ChatGPT interface and point it at a repository.
The flow is straightforward:
- Connect GitHub in ChatGPT settings
- Open Codex from the sidebar
- Select a repo and describe the task
- Codex creates a branch, does the work, opens a PR
- You review and merge
The GitHub Integration in Practice#
The integration is tighter than most “AI on your codebase” tools. Codex doesn’t just read your current files — it reads existing PRs and commit history to infer project conventions before writing anything.
I tested it on an ML training codebase. Task: “add a linear warmup scheduler to the training loop for the first 10% of steps, and write a pytest test for it.”
The output PR:
- Added
WarmupSchedulertoschedulers.py, matching the class structure already in that file - Wired it into
train.pyconsistent with how existing schedulers were integrated - Wrote
tests/test_schedulers.pywith parametrized tests matching the project’s existing pytest patterns - Updated the README under the “Training” section
The test suite passed. The code was idiomatic. Total elapsed time: ~4 minutes.
That’s the ceiling of what Codex does well: well-scoped, self-contained tasks where “done” is verifiable by a test suite.
Parallel Tasks: The Real Differentiator#
The feature that changes how you work is parallelism. Claude Code is sequential — you do one thing, review it, move on. Codex lets you run several independent tasks at once.
In practice: submit five small tasks at 9 AM (add tests for this module, fix this edge case, refactor this utility, add this config option). By 9:30, you have five PRs to review. Instead of two hours of coding, you spend thirty minutes reviewing.
For ML engineers specifically, this is useful for the backlog of “should do but never get to” work: test coverage gaps, config validation, deprecation warnings, type annotation gaps. Well-defined but boring enough to defer indefinitely.
Where It Falls Short#
It can’t see runtime behavior. A loss curve not converging, a subtle numerical instability, a training loop that’s slower than expected — Codex has no visibility into actual training runs. It can only work on things expressible as “write code, then verify with tests.”
Debugging is not its strength. Interactive debugging — read a stack trace, add a print, run again, iterate — is where Claude Code’s interactive loop wins. Codex isn’t built for this kind of back-and-forth.
Review burden is real. Running 10 tasks in parallel means 10 PRs to review. The time savings in generation get partially clawed back in review. Don’t generate more than you can read.
Codex vs. Claude Code: Complementary, Not Competing#
After a month of using both, the mental model is simple:
| Task | Tool |
|---|---|
| Debugging a failing test right now | Claude Code |
| Understanding how a codebase works | Claude Code |
| Implementing a well-specified feature | Codex |
| Writing tests for an existing module | Codex |
| Refactoring a file interactively | Claude Code |
| Running 5 small tasks while in meetings | Codex |
| Working over SSH on a remote GPU server | Claude Code |
Codex doesn’t replace the interactive debugging loop. It replaces the kind of execution work where the thinking is already done — you know what you want, you just need the code written and tested.
One Month In#
Codex is genuinely useful, which puts it in a small category of AI coding tools. The GitHub-native output (branch → PR) is the right interface for production work. codex-1’s quality on well-scoped tasks is high enough that you’re reviewing PRs rather than fixing AI-generated messes.
The limitations are real: no interactive debugging, no runtime visibility, constrained to test-verifiable changes. But within those constraints, it’s the fastest way to clear a backlog of well-specified engineering tasks.