Codex Now Generates 64% of Combined Codex and ChatGPT Output Tokens for Enterprise Customers

OpenAI finally published a number that makes the agent era feel real, and it is not a benchmark score. As of June, Codex generated 64 percent of the combined output tokens from Codex and ChatGPT among its enterprise customers. In plain English: the majority of what enterprises ask OpenAI to produce is no longer chat answers. It is work done by an agent, executed end to end.

That single line, buried in a report OpenAI calls 'From assistance to execution', is the clearest evidence yet that the centre of gravity in enterprise AI has shifted. We have spent two years arguing about whether agents were ready. The usage data says the argument is over, and the enterprises quietly moved on.

> TL;DR: Codex now produces 64% of combined Codex and ChatGPT output tokens among enterprise customers, a hard signal that enterprises are delegating work, not just asking questions. That shift is what is actually driving the governance market and the agent economics everyone keeps trying to price.

What does 64% of output tokens actually measure?

Output tokens are the text a model generates, the words and code it hands back. They are not a perfect proxy for work, but they are a better proxy than anything else OpenAI has shared, because they measure production, not prompts.

The distinction matters. A person who asks ChatGPT a question gets a short answer. A person who points Codex at a repo gets a stream of code, test runs, and tool calls that can run for thousands of tokens. When the agent's share of output crosses 50 percent, it means the enterprise is spending more of its AI effort on execution than on conversation. It crossed, and by a wide margin.

I would not over-read the exact number. It is self-reported, from the company that sells both products, and output tokens flatter Codex because agents churn tokens by nature. You can also legitimately argue that an agent emitting ten thousand tokens does not mean ten thousand tokens of useful work. Some of it is retries, dead ends, and scaffolding. But you do not get from a rounding error to 64 percent on marketing alone. That is a behaviour change showing up in the only place that cannot lie: the metering.

Why is this the real driver of governance urgency?

Yesterday I wrote about the $435 million flowing into agent security and governance. The Codex number is the demand side of that story. You cannot have 64 percent of your AI output being produced by agents and still govern AI the way you govern chat.

Chat is easy to govern because it is bounded: a human asks, a model answers, the human decides. An agent is harder because it does not stop at the answer. It reads files, calls APIs, mutates systems, and commits. The governance problem scales with output tokens, because every token an agent emits is a potential action you did not personally authorise.

This is why the security vendors are suddenly a category. The shift from asking to doing is not a vibe. It is a measurable change in what enterprises are buying, and it has a governance bill attached that most of them have not paid yet.

Then there is the money. When 64 percent of your output is agent-produced, your AI bill is dominated by execution, not chat, and execution is expensive because it is token-hungry. That changes the unit economics of delegation. A chat question costs pennies. An agent that refactors a module, runs the tests, and commits costs real money, and it costs more the more it retries. The teams getting value here are the ones that have already internalised that an agent is not a cheaper employee, it is a different cost curve entirely, and they budget for it like infrastructure rather than like a subscription.

What should non-technical teams actually delegate?

The useful question for the reader is not "will agents work" but "what do I let them do first." The data points to a clear answer, and it is the boring one.

Delegate the work that is already well defined and expensive to get wrong manually. Data reconciliation. Report generation. Ticket triage. Anything with a clear input, a clear output, and a way to check the answer. Do not delegate the work where the definition is the work, strategy, judgement calls, anything you could not hand to a new hire on their first day with a checklist.

In my experience, the teams that get this right pick one painful, repetitive task and hand it over with a human still in the loop. The teams that get it wrong try to replace an entire role in one afternoon and end up with an agent that confidently does the wrong thing faster. The enterprises in OpenAI's report are not replacing their judgement. They are replacing the grunt work between decisions. That is the honest reading of "assistance to execution": the agent executes the task, and the human executes the judgement.

Why is this not just a coding story?

Here is where I will plant a flag. Most coverage of this number treats it as a story about coding, because Codex is nominally a coding tool. That is a misread. The number matters because of what it says about delegation, not because of what it says about software engineering.

Codex is the leading edge of a broader pattern: give an agent a goal, let it work, and it produces far more output than a human ever would in the same conversation. The same shape is coming to sales, support, finance, and operations. The coding use case is just the first place the token count became impossible to ignore.

For a non-technical team, the signal is this: your budget for "AI that answers questions" is about to be dwarfed by your budget for "AI that does tasks." Plan the permissions, the handoffs, and the audit trail now, because the tools to do that safely are the same tools the venture market just decided to fund.

The takeaway

64 percent is a number with an opinion baked in, and the opinion is that enterprises have stopped asking and started doing. Treat it as a direction, not a measurement, and act accordingly.

If you lead an ops team, the concrete move is to pick one well-bounded, high-volume task and hand it to an agent this quarter, with a human checking the output. Not because agents are perfect. Because the enterprises already doing this are running the same experiment, and their output tokens are now the majority of what they buy. You are either learning to delegate to an agent now, or you are learning it later, on someone else's timetable.