Codex vs Cursor, We Ran the Same Ticket

Codex is a delegation agent: you hand it a task and it works alone, in your terminal or in an OpenAI sandbox. Cursor is an editor you sit inside, steering an agent file by file. OpenAI ships Codex in every ChatGPT plan, Cursor sells its own tiers from zero to $200 a month. Same price at the entry point, opposite workflows.

Updated August 19, 2026 · by the AITerm team

What actually separates Codex from Cursor?

Not the model, and not the benchmark. Codex vs Cursor comes down to one question: who holds the diff. Cursor keeps you in the loop on every file so you catch a wrong turn in ten seconds, and Codex takes the whole task away and hands back a finished branch you review once.

Everything else follows from that one decision.

Cursor is a fork of VS Code. It indexes your repository the moment you open it, using a Merkle tree over file hashes, AST-aware chunking and a custom embedding model, with the vectors stored in a hosted database. The Towards Data Science teardown of that pipeline puts the scale at over a trillion vectors across roughly 80 million namespaces.

That index is Cursor's real product, and people credit the model for it.

Codex has no index. It reads what it needs per task, in your terminal against your working tree, or in an OpenAI sandbox that clones the repository fresh. Locally it runs behind a real sandbox: modes are read-only, workspace-write and danger-full-access, approvals are untrusted, on-request or never, and the enforcement is kernel level through Seatbelt on macOS and Landlock plus seccomp on Linux.

Look, that sandbox is the reason people trust Codex with longer leashes. Cursor's own CLI documentation is blunt that its safeguards are still evolving and that you should run it in trusted environments only.

You're probably thinking this is just terminal against IDE, the same axis as Claude Code against Cursor. It is not, and we wrote that comparison separately for a reason. Codex is the one tool here designed around walking away from the screen.

We gave both the same ticket

One ticket, both tools, same machine, same repository, cold start each time. The task was real work from our backlog: add a new user-facing string to AITerm, wire it through the settings toggle that uses it, and update the welcome tour step that mentions it. Nothing clever, just wide.

Wide is the point. Every visible string in AITerm goes through a helper and has to exist in seven language files, so a change that looks like one line is actually eleven files and a build that fails loudly if you miss one. So, no clever prompting: the protocol was boring on purpose.

Cursor got there first. Twenty-one minutes from prompt to green build, with nine moments where we accepted a diff, corrected a path or told it to keep going. It missed one language file, the build caught it, we pointed and it fixed it in forty seconds.

Codex took thirty-eight minutes. Two interventions: one approval for the build command, one nudge when it started rewriting the tour version constant we had not asked it to touch. All seven language files were correct on the first pass, and it ran the full build twice on its own before reporting.

Honestly, our first attempt at this test was worthless and we ran it anyway. We gave Codex a cold clone with no build instructions while Cursor had a warm index and our conventions file open, then we wrote down that Codex was twice as slow. It was our setup that was twice as slow.

The rerun above gave both tools the same conventions file. Read the numbers as one ticket on one codebase, because that is what they are.

Is Codex cheaper than Cursor?

At the sticker, they tie. Codex comes with ChatGPT Plus at $20 a month, Cursor Pro is $20 a month, and both have cheaper and much more expensive tiers around that. The difference is what you exhaust and how it feels when you do.

Cursor Pro includes roughly $20 of model usage, Pro Plus around $70, Ultra around $400, on plans priced at $20, $60 and $200. When Cursor moved from request counting to credits, the effective Pro allowance dropped from around 500 requests to roughly 225 at the same price, and heavy users report $40 to $50 a month once overages land.

Codex has no pool to overspend. It has a window: OpenAI publishes 10 to 100 local messages per 5 hours on GPT-5.6 Sol depending on plan, more on the smaller models, and CLI, IDE and web all draw from the same allowance. In practice, that means a heavy terminal afternoon eats the budget your teammate was going to use on the web client.

So, price the attention. On our ticket the developer time gap was fourteen minutes in Codex's favour, which at any honest loaded rate dwarfs the subscription difference between every tier both companies sell.

That saving is conditional and we should say so plainly. Fourteen minutes you spend staring at a progress indicator is fourteen minutes you did not save.

What happens when a task runs for twenty minutes?

Codex compacts. When the session approaches the context limit it summarises its own history and keeps going, which is how it sustains work for hours on a single task rather than stopping at a wall. Cursor never gets there, because you are in the loop often enough that sessions stay short by construction.

Here's the thing about compaction: it is a summary, not a save state. Sessions are written as JSONL transcripts under your Codex home directory, and resuming replays that transcript to rebuild context rather than restoring the model's actual state.

Most of the time you never notice. When you do notice, it is not subtle.

Issue 16278 in the openai/codex repository describes a compaction timeout leaving a session unrecoverable, with resume hanging too. Issue 29426 reports the desktop client auto-compacting short resumed sessions while context usage sat far below the window. Both are the same class of problem: the thing keeping your long session alive is also the thing that can end it.

In practice, this is where the two tools stop being comparable. A twenty minute Cursor session is twenty minutes of your attention, and a twenty minute Codex session is twenty minutes of somebody else's, which only helps if you have somewhere to put yours.

Our anonymous daily ping puts the median AITerm user at around three concurrent agent sessions. Three, because one long-running agent alone is a worse deal than doing the work yourself.

Can you run Codex inside Cursor?

Yes. The Codex IDE extension installs into any VS Code compatible editor and OpenAI lists Cursor explicitly, using the cursor: URI prefix in Quick Open instead of vscode:. The extension is free, Codex still needs a paid ChatGPT plan or an API key, and it sits alongside Cursor's own agent rather than replacing it.

Turns out the versus in Codex vs Cursor is doing a lot of work it has not earned.

The setup we see most often in the wild is not a switch at all. People keep Cursor for the editing surface, tab completion included, and route long or repetitive tasks to Codex from the terminal or the sidebar, paying for both because $40 a month is cheaper than one bad afternoon.

And yes, Cursor ships its own terminal agent now. You install it with a shell one-liner, the command is agent rather than cursor-agent, and it runs headless with a print flag for CI. So the clean terminal-against-IDE story that every comparison article tells has been false for a while on both sides.

Leaving Cursor, what actually changes

People searching for a way out of Cursor are usually not looking for a better model. They are looking for a bill that does not move. Searches for Cursor alternatives grew through 2026 while the pricing model changed repeatedly, and the complaints cluster on three things: unpredictable overages, editor lock-in, and context limits that arrive mid-sprint.

Most Cursor alternatives lists answer that with another editor, usually Windsurf, because swapping one IDE for a cheaper IDE is the smallest change. Codex is the larger change, and it is the one that removes the credit pool entirely rather than repricing it.

Moving to Codex fixes the first, half fixes the second, and changes the shape of the third.

The bill stops surprising you because there is no pool to drain: you hit a window, wait, and continue. Lock-in loosens because Codex has no editor of its own, so your editor becomes whatever you want, VS Code, Neovim, Zed, anything with git. And the context limit does not disappear, it becomes compaction, which is better for long tasks and worse for repository-wide questions where Cursor's index shines.

Fair question: what do you actually lose? Tab completion, mostly, and it is a bigger loss than people admit in the first week.

You also lose the review-as-you-go rhythm. With Codex, a bad assumption in minute two surfaces in minute thirty-eight, and you read a full diff to find it. That is a real cost and the reason we still keep an editor agent for exploratory work.

Here are our numbers instead of adjectives, since we make the window those sessions run in. AITerm is 45 MB of Swift rendering through CoreText, and with 20 panes streaming agent output it sits at roughly 140 MB of RAM on an M2 Air, where our old Electron setup reached about 1.9 GB doing the same work. Keystroke latency stayed under 8 ms while output was heavy.

We know how that sounds coming from us. Take the claim narrowly: nothing about choosing Codex requires a particular terminal, and worktrees plus one task per session work in whatever you have open right now.

Benchmarks stopped being the answer

The frontier models on SWE-bench Verified now sit within about one point of each other, with Claude Opus 5 around 96 percent and GPT-5.6 Sol around 96.2 percent as of August 2026. OpenAI stopped reporting Verified scores earlier in the year and points at SWE-bench Pro instead, because the older benchmark no longer separates anything.

Read that twice before you pick a tool on a leaderboard.

Honestly, we still check the scores. We just stopped letting them decide anything, because a one-point gap on a saturated benchmark is noise next to how a tool retrieves context and when it asks permission.

So, our position, and you are allowed to disagree: for the work in front of you, the harness decides the outcome far more than the model does. The harness is the context strategy, the sandbox policy, the approval flow, the retrieval, and the window you watch it in. Two tools running the same model produce different results, and everyone has seen that happen without changing what they benchmark.

This is the same argument we make in the pillar for this cluster, applied to a different pair. It keeps being true.

Which one belongs in your week

The short version: Cursor sells you speed on the clock, Codex sells you back your attention, and the second one only cashes if you have somewhere to spend it. Pick Codex vs Cursor on how your week is shaped, not on a leaderboard that is one point wide.

In practice, most people reading this already know which one they are. The test is whether your last three tickets had a definition of done before you started them.

If you run the same-ticket test on your own repository, tell us what you measured: hello@aiterm.app.

Going further

Sources

1. Codex rate card, OpenAI Help Center, 2026: the move from message-based to token-based credit pricing, and how credits map to model tokens.
2. Agent approvals and security, OpenAI Codex documentation, 2026: the read-only, workspace-write and danger-full-access sandbox modes, the untrusted, on-request and never approval policies, and kernel-level enforcement through Seatbelt on macOS and Landlock plus seccomp on Linux.
3. Codex IDE extension, OpenAI Codex documentation, 2026: compatibility with VS Code forks including Cursor, and the cursor: URI prefix for install.
4. Cursor Agent CLI, Cursor blog, 2026: the terminal and headless agent, the shell installer and the print mode for CI.
5. Cursor CLI overview, Cursor documentation, 2026: the agent command, ACP server mode over stdio, and the explicit warning that safeguards are still evolving.
6. Remote compact task timeout leaves the session unrecoverable, openai/codex issue 16278: compaction failure blocking resume on long-context workflows.
7. Codex Desktop auto-compacts short resumed sessions, openai/codex issue 29426: compaction firing while context usage sits far below the window.
8. How Cursor actually indexes your codebase, Towards Data Science, 2026: Merkle trees, AST-based chunking, the custom embedding model, the turbopuffer vector store, and the trillion-vector scale figure.
9. How Cursor indexes codebases fast, Engineer's Codex, 2026: simhash seeding between similar repositories and the roughly 92 percent clone similarity inside an organisation.
10. Context compaction deep dive, Codex CLI, Claude Code and OpenCode, 14 April 2026: automatic compaction on long sessions, JSONL session transcripts, and why resume replays history rather than restoring state.
11. SWE-bench Verified leaderboard, Vals AI, August 2026: frontier scores clustered around 96 percent and the saturation of the benchmark.
12. Best AI coding agents, August 2026, Morph: the one-point spread across leading models and the shift of reporting toward SWE-bench Pro.
13. The complete guide to Cursor pricing, Flexprice, 2026: Hobby, Pro, Pro Plus and Ultra tiers, the included model usage per tier, and the multiplier structure.
14. What happened to Cursor pricing, Finout, 2026: the request-to-credit change, the drop in effective Pro allowance, and reported effective costs for heavy users.
15. OpenAI Codex pricing, plans, token costs and usage limits, CloudZero, 2026: Codex included in every ChatGPT tier, the Go, Plus, Pro and Business prices, and the 5-hour local message allowances per model.