Copilot vs Codex: you may already be paying for both

Contents

Copilot vs Codex: which should you use?

Two of the questions Google surfaces most often for this comparison are “Does GitHub Copilot have Codex?” and “Does Copilot have a version of Codex?”

The answer is on GitHub’s own plans page, and it reframes the whole comparison: Copilot Pro, at $10 a month, lists access to third-party agents and names Codex as one of them.

One widely cited write-up prices the pair at about $30 a month combined. It is $10, if you buy it from the right side.

	Verdict
Faster and leaner	Copilot — about a minute, 468 lines, the tightest result of eight tools
Better behaved	Codex — ran unattended, checked its own syntax, admitted what it could not verify
Best overall	Buy Copilot Pro at $10 and reach Codex through it, unless you are already paying for ChatGPT

What happened when both built the same thing

One message, six numbered requirements, no follow-ups. Two deliberate traps: annual plans had to display a monthly-equivalent figure rather than the number typed in, and cancelled items had to leave the running total while staying visible.

Both passed. I verified by serving each app and using it — entering a $2,400 annual plan to check $200.00 appeared, cancelling to watch the total move, hard-reloading for persistence.

Axis	GitHub Copilot	OpenAI Codex	Winner
Requirements met	6 of 6	6 of 6	Tie
Time	~1 min (imprecise)	2 min 44 sec	Copilot
Lines written	468	585	Copilot
Files	One index.html	One index.html	Tie
Ran unattended	Yes	Yes	Tie
Output	Browser artifact	Files on disk	Codex
Checked its own work	No	Syntax check only	Codex
Wrote tests	No	No	Neither
Cost of this build	$0 free tier	$0 free tier	Tie
Alley Rating	Not rated	4.4	—

Two caveats before that reads as a scoreboard.

Copilot’s timing is imprecise and I will not pretend otherwise. Codex was driven in a terminal where I could time it properly. Copilot ran in a browser chat with no completion signal I could poll. About a minute is honest; to the second would not be.

Copilot returned an artifact in the browser, not files. Every other tool I have given this brief wrote a folder. I had to extract Copilot’s output before I could run it. On a one-shot build that is a mild inconvenience; in a real workflow it is the difference between something a build step can consume and something you copy out by hand.

G

GitHub Copilot: what it did

It wrote the least code of anything I have measured. 468 lines for six requirements, under Codex’s 585 and Cursor’s 581, and less than a fifth of Antigravity’s 2,894. For a tool whose reputation is autocomplete rather than architecture, producing the tightest complete result of eight is not what I expected.

It handled both traps. $2,400 a year rendered as $200.00 a month, labelled “Billed annually — shown as monthly equivalent”. Cancelling moved an item into its own section, struck through, out of the total but still visible. It stored the raw cost and cycle and derived the monthly figure at render, which is the correct model.

It asked for nothing. No approval gate, no clarifying questions, one message to a finished app. Claude Code needed eight exchanges to reach the same place.

It wrote no tests, and it verified nothing about its own output.

And it added a theme toggle nobody requested, alongside the Reactivate button that all eight tools have now invented.

What it costs. Free at $0 with 2,000 completions a month and no card — that tier ran my entire test. Then Pro at $10 a month with $15 of monthly credits, Pro+ at $39 with $70, Max at $100 with $200. Every paid tier lists more credit value than it costs.

O

OpenAI Codex: what it did

It was the more disciplined of the two, which is a different thing from being faster.

On the same brief it met all six requirements in 2 minutes 44 seconds, unattended, in 585 lines across one file. It added cancel, restore and delete and then stopped — no currency switcher, no command palette, none of the sprawl that Antigravity produced for the same spec.

It checked its own syntax and volunteered that the folder was not a git repository so it had no git status to report. That is a small thing that tells you something real: it distinguishes between what it verified and what it could not.

On a harder task it was genuinely impressive. Given a deliberately awkward refactor — rename a field end to end across SQL, an n8n workflow JSON and Python — it found and changed all 33 references across seven files in a single run, with no corrective prompt. I verified that against git rather than reading its summary.

And on that same task it did the worst thing I have seen a coding tool do. It edited my project rules file without asking, deleting the very line that made its change wrong, because that file sat inside the workspace and everything inside the workspace is ungated by default. The boundary it was told about held. The one it had to infer did not.

Codex on the harder refactor
References renamed	33 across 7 files, one run
Corrective prompts needed	None
Verified against	git, not its own summary
Rules file edited without asking	Yes — deleted the line that made it wrong
Its own diff badge	Reported 6 files where git showed 7

Its own summary undercounted too: it reported six changed files where git showed seven. The work was right; the account of the work was not.

What it costs. Bundled with ChatGPT rather than sold separately, so the free ChatGPT tier includes usable access — my whole test ran on it. Full detail in the Codex review and pricing.

Neither is sold as a developer tool

This is the structural fact that makes a straight price comparison misleading, and both sides share it.

Copilot is a GitHub subscription. You are buying a seat on a developer platform that happens to include an AI assistant, alongside code review, cloud agents and the rest.

Codex is a ChatGPT subscription. You are buying a consumer AI product that happens to include a coding agent, alongside everything else ChatGPT does.

	GitHub Copilot	OpenAI Codex
Sold as	A GitHub seat	Part of a ChatGPT plan
Free tier	Yes — 2,000 completions, no card	Yes — usable, ran my whole test
Entry paid	$10 Pro	Reached via a ChatGPT plan
Metering	Credits, $15–$200 by tier	Within the ChatGPT plan
Standalone developer seat	No	No
Includes the other?	Yes, on Pro	No

That last row is the whole comparison. Copilot contains Codex; Codex does not contain Copilot. If you are choosing between two subscriptions and one of them includes the other, the arithmetic stops being symmetrical.

The caveat I keep repeating because it matters: access is not allowance. Copilot’s paid tiers run on credits, and credits are what run out. Reaching Codex through Copilot Pro at $10 is real, and it is not the same as an unlimited Codex plan.

How they differ in shape

The benchmark measures a narrow thing, so here is the difference it does not capture.

Copilot is reactive. Its core product is sub-second inline completion and next-edit suggestions while you type, inside VS Code, JetBrains or Visual Studio. My one-shot app brief does not test that at all — the interesting thing is that a tool built for autocomplete still produced the leanest complete app of eight.

Codex is delegative. You describe an outcome, it works, you review the result. It runs in a terminal, a desktop app or the web rather than inside your editor, and it is built for tasks you can specify and walk away from.

Those are complementary rather than competing, which is why the “use both” recommendation keeps appearing. Copilot handles the hundreds of small completions you need while typing; Codex handles the bigger thing you would rather hand over.

One difference that does bite in practice: model choice. Copilot lets you pick across providers on paid tiers. Codex runs OpenAI models. If being able to change model matters to you — because a particular model suits your stack, or because you want to switch when a cheaper one is good enough — that is a real point for Copilot and it has nothing to do with either tool’s coding ability.

What neither of them did

Worth stating plainly, because it is the same gap and it is the most consequential thing this comparison does not contain.

Neither wrote a single test. Not one assertion between them.

Across the eight tools I have given this brief, exactly two wrote and ran real test suites: Claude Code with 28 assertions covering corrupt storage, non-array payloads and float precision, and Google Antigravity with 6. Both are agent-first developer tools. Every assistant-shaped product in the set — Copilot, Codex, Cursor, and all three hosted builders — wrote nothing that checked anything.

Tool	Own tests	Shape
Claude Code	28 assertions	Terminal agent
Antigravity	6 assertions	Agent manager
Copilot	None	IDE assistant
Codex	None	Terminal agent
Cursor	None	AI-native editor
Lovable, Bolt, Replit	None	Hosted builders

Codex gets partial credit here: a syntax check is not a test suite, but it is more than nothing, and volunteering what it had not verified is a behaviour I would rather have than confident silence.

If verification is what you are actually shopping for, this page does not contain your answer. Claude Code and Antigravity do.

Where these two sit among eight

Both have now taken the same brief as six other tools, which gives this comparison a scale a head-to-head cannot.

Tool	Built from one prompt	Time	Lines	Own tests	Cost
Cursor	Yes	under 1 min	581	No	$0 free tier
GitHub Copilot	Yes	~1 min	468	No	$0 free tier
Lovable	Yes	109 sec	Not counted	No	~$0.30
Antigravity	No, approval gate	~2.5 min	2,894	Yes, 6	Free
OpenAI Codex	Yes	2 min 44	585	No	$0
Bolt	Yes	2–3 min	Not counted	No	~$0.25
Replit	Yes	~4 min	Not counted	No	31% of free plan
Claude Code	No, interviewed first	~8.5 min	1,052	Yes, 28	About $2.56

Two things that table shows which a two-way comparison hides.

These two are the closest pair in the whole set. 468 lines against 585, about a minute against two and three-quarters, both unattended, both free, both testless. On a task like this they are near-interchangeable, and anyone telling you one is dramatically better at writing code is not describing something I could measure.

All eight passed. Six of six, every tool, first attempt, including both traps. The capability question that most comparisons are implicitly arguing about did not show up.

The full ranking is in best AI for coding.

What the credit model does to this choice

Copilot’s mid-2026 move to credit billing is the reason a lot of people are comparing these two right now, so it deserves more than a footnote.

Every Copilot paid tier lists more credit value than it costs — $10 buys $15, $39 buys $70, $100 buys $200 — which is a better-behaved structure than “they raised the price” implies. What it is not is legible. A credit costs what it costs depending on which model answered and how long the context was, and you learn the rate by exhausting it.

	Copilot	Codex
Metering unit	Credits	Within a ChatGPT plan
Published rate card	Credit totals per tier	Plan-level, not per action
What runs out	Credits	Plan limits
Predictable?	Only if you track it	Only if you track it

I have not exhausted either allowance, and I will not pretend to have. My tests ran on free tiers on both sides, so everything above is read off the plans pages rather than measured against a month of my own work.

What I can say is that this axis does not clearly separate them. Both meter. Neither publishes a per-action price you could forecast against before starting. If unpredictable spend is what is driving your search, the honest answer is that neither of these two solves it, and the tools that do are the ones with a flat subscription or a genuinely free tier — which on the wider set means a Claude plan or Google Antigravity.

Using both: what the workflow actually looks like

“Use both” is the most common recommendation for this pair and it is usually left as a slogan. Here is the concrete version.

Copilot handles the typing. Inline completion and next-edit suggestions while you write, inside the editor you already use. This is hundreds of small interactions a day that you barely notice, and it is the thing my one-shot build test does not measure at all.

Codex handles the errands. A task you can specify and walk away from — a rename across a codebase, a migration, a piece of scaffolding. You describe the outcome, it works, you review a diff.

The division is real because the two jobs have different latency requirements. Autocomplete has to be sub-second or it is worse than useless. A refactor across seven files can take three minutes and still be a bargain. No single tool is optimised for both ends of that range, which is why people who use both rarely go back to one.

The split in practice	Copilot	Codex
Interaction frequency	Hundreds a day	A few a day
Latency requirement	Sub-second or useless	Minutes are fine
You are	Typing	Reviewing a diff
Failure mode	A bad suggestion you ignore	A wrong task you have to unpick

Two practical notes if you run them together. Keep one source of project instructions rather than two, because the failure mode is not conflict — it is two sets of rules drifting apart until you cannot tell which produced what. And decide deliberately which one owns the terminal, because both will happily run commands and the overlap is where the confusion lives.

And check your bill before adding a second one. Copilot Pro at $10 already lists Codex access. If your combined workflow starts inside one subscription, that is a cheaper starting point than two.

If you are choosing for a team

The individual calculus and the team calculus diverge here more than usual.

Copilot is the easier organisational purchase, and not because it is better. Per-seat billing, centralised administration, policy controls and audit logs are what procurement asks for, and Copilot is sold as a developer platform seat with those attached. Codex arrives inside a consumer subscription, which is an awkward thing to buy fifty of.

Codex is the easier individual purchase, especially where people already pay for ChatGPT personally — which, across most engineering teams, a meaningful share already do.

Team factor	Which side
Per-seat billing and admin	Copilot
Policy, audit, compliance	Copilot
Already in people’s personal spend	Codex
Model choice across providers	Copilot
One bill that reaches both	Copilot Pro
Predictable annual cost	Neither, cleanly

The trap at team scale is the same one as everywhere else in this category. A modest per-seat price with a meter behind it looks cheap in a spreadsheet and is not forecastable in practice. If budget certainty matters more than peak capability, and at ten seats it usually does, that argues for whichever option you can cap, and for setting the cap before rollout rather than after the first surprising invoice.

What this test does not tell you

The limits, stated plainly, because a comparison that hides them is worth less than it looks.

It does not test Copilot where it lives. My brief was a one-shot app build. Copilot’s actual product is inline completion inside an editor, and nothing here measures that. The remarkable thing is that a tool built for autocomplete produced the leanest complete app of eight, not that it was fast.

It is one greenfield build per tool. Neither result says anything about a repository with ten years of history, which is where both products spend most of their working life. The Codex refactor is the closest thing I have to that, and it was one task on one codebase.

Neither paid tier was exhausted. Everything about credits and limits above is read from plans pages, not measured.

And Copilot has no rating here, because one controlled build is not a review. Codex carries 4.4 from a proper one. I would rather leave the asymmetry visible than invent a number to make the table look complete.

Which should you pick?

If this is you	Pick
Already paying for ChatGPT	Codex, it is in your plan already
Already paying GitHub	Copilot Pro, and Codex comes with it at $10
Paying for neither, want to evaluate	Either free tier, both completed the brief for nothing
Live in VS Code or JetBrains	Copilot, inline completion is the actual product
Work in the terminal, delegate tasks	Codex
Need model choice	Copilot, Codex is OpenAI only
Want files on disk, not a browser artifact	Codex
Want the tool to verify its work	Neither, look at Claude Code or Antigravity

The row people should read twice is the second. If GitHub is already in your budget, $10 reaches both of these, and the decision you thought you were making is mostly already made.

What “measured” means on this page

Half the value of a comparison is knowing how firm each number is, so here is the provenance.

Both build results are first-hand. I sent each tool the identical brief, took what it produced, served it, used it in a browser, entered real values, watched the total change, hard-reloaded, and read the stored data. Not a transcript, not a summary. That protocol matters more than it sounds: on the harder Codex task, its own diff badge reported six changed files where git showed seven, and only checking against disk caught it.

One number is deliberately soft. Copilot’s “about a minute” is not a stopwatch figure. Codex ran in a terminal where I could time it; Copilot ran in a browser chat that gives no completion signal I could poll. I have left it approximate rather than inventing precision, and it is the reason the speed row says Copilot wins rather than by how much.

One number was wrong and is now right. I first recorded Copilot’s output as 467 lines. The artifact download has no trailing newline, so wc -l — which counts newline characters — undercounted by one. The real figure is 468, matching what GitHub’s own panel displayed. Cursor and Claude Code were unaffected because their files terminate properly. The conclusion did not change; Copilot is still the leanest of the eight.

Claim on this page	How firm
6 of 6, both tools	First-hand, app served and used
Codex 2 min 44 sec	First-hand, terminal-timed
Copilot ~1 min	Approximate, no pollable signal
Copilot 468 lines	First-hand, corrected from 467
Codex 33 refs across 7 files	First-hand, verified against git
Copilot tier prices	Read live off the plans page
Credit drain at volume	Not measured, free tiers only

Pricing is read live, not recalled. Copilot’s tiers came off its plans page on 14 August 2026 rather than from an earlier note, which matters in a category where two products have restructured pricing this year.

And what is not measured is labelled. Copilot’s inline completion, either tool on a large existing codebase, and the behaviour of an exhausted paid allowance are all outside what I tested, and each is named where it would otherwise be assumed.

The one thing that would change this verdict

Worth naming what would move it, since a comparison that could never be wrong is not worth much.

If the third-party agent access turns out to be thin, the recommendation flips. The whole “buy Copilot Pro at $10 and reach Codex through it” argument rests on a line on GitHub’s plans page. What that line guarantees is access; what it does not state is how much Codex work $15 of monthly credits actually buys. If the honest answer turns out to be “an afternoon”, then anyone doing serious delegated work should buy a ChatGPT plan directly and the $10 route is a trial rather than a solution.

I cannot resolve that from a free-tier test, and I would rather say so than round it into a confident recommendation. If you run Codex through Copilot Pro at real volume, that is the number worth knowing, and it is the thing I would test next given a paid account.

If Copilot’s inline completion is what you are actually buying, nothing on this page measures it, and my build result, leanest of eight, says nothing about whether its suggestions are good while you type. That is the product’s core and my brief does not touch it.

And if either restructures pricing again, this comparison ages fast. Copilot moved to credits in mid-2026 and Codex’s tiers have shifted inside ChatGPT’s plan changes more than once. Every figure here carries a date for that reason.

The final word

These two get compared constantly and, on the evidence, they are much more similar than the framing suggests. Copilot was slightly faster and slightly leaner. Codex was slightly better behaved. Both passed the same brief, both did it free, and neither checked its own work.

Where they genuinely diverge is not capability but how you buy them. Neither is a developer seat: one is a GitHub subscription, the other is a ChatGPT subscription, and both throw in a coding tool. Once you see it that way, the honest recommendation follows from your existing bill rather than from any benchmark. Pay for ChatGPT already? You have Codex. Pay GitHub? Ten dollars gets you Copilot and Codex, which is the fact this comparison usually misses.

That is a genuinely unusual situation, and it is worth checking your own bill before you spend anything, because the cheaper of the two products is the one that contains the other. The one thing I would not do is buy both separately. A widely cited write-up prices the pair at around $30 a month combined, and GitHub’s own plans page contradicts it.

And, because it is now eight for eight: my brief asked for cancelled items to leave the total and stay visible. It said nothing about restoring them. Both tools added a Reactivate button anyway — as has every other tool I have ever given this to.