OpenAI published usage data from inside its own walls. Its 99th-percentile employees now run more than 60 hours of agent work every single day. Sixty hours inside a 24-hour day is not overtime. It is a different unit of work.

You cannot fit 60 human hours into one person's day. You can run 60 agent-hours because several jobs execute at once while the employee specifies, checks and accepts the work. The number describes concurrency, not a longer workday.

The rest of OpenAI's report fills in the shape. The average employee now produces 85% of their output through Codex, not typed, delegated. Across the company, agents already account for 99.8% of weekly output tokens. The humans are still deciding what gets built and whether it is right. They have almost entirely stopped being the ones who produce it.

The work did not get faster. It went parallel.

"Faster" describes the same sequential process compressed in time. Parallel work changes the process: several jobs run while one person moves between specification, review and acceptance.

Parallel is a different regime entirely. The human stops executing tasks one after another and starts dispatching many at once, each running independently while attention moves elsewhere. The constraint is no longer how fast you work. It is how many streams of work you can start, supervise, and accept. The growth-team data makes the pattern concrete: research teams show 56 times more agent use than seven months ago, customer support 32 times, engineering 27 times, even legal 13 times. Those are not efficiency gains. Those are step changes in how many things happen at once.

The human stops doing the work and starts approving it. That is not a productivity upgrade. It is a change in what a person is for.

Old company, new company

The old company had a simple production function: headcount times hours. Output was labor, and labor was people multiplied by the time each one worked. It scaled linearly and it scaled by hiring. If you wanted more output, you added heads, onboarded them, managed them, and absorbed the coordination cost of every new person. The ceiling was real, and everyone knew where it was.

With agents, output depends on how many jobs can run at once and how many results the organization can verify. The constraint moves from typing and execution toward specification, review capacity and accountability. More agents do not remove the ceiling; they move it.

We have seen this abstraction before

The move is not unprecedented; it is the same move computing has made twice already. Compilers did it to assembly. Programmers stopped hand-writing the instructions the machine executes and started writing intent, letting the compiler generate the instructions. The programmer's job moved up a level, from producing machine code to specifying behavior and checking the result. Nobody mourns hand-written assembly.

The cloud did it to servers. Operations teams stopped racking physical machines and started declaring the infrastructure they wanted, letting the provider produce it. The unit of work stopped being the server you touched and became the capacity you specified. In both cases the human did not become less important. The human moved to a higher level of abstraction and became responsible for more, because each unit of their attention now commanded far more underlying work. Agents are the third instance of the same pattern, applied to knowledge work itself.

What the agent-hour measures, and what breaks

When the unit of work is the agent-hour, the metrics that ran the old company stop describing the new one. Headcount measured the old company because headcount was the input that produced output. Throughput measures this one, because output is now decoupled from the number of people. A ten-person team running thousands of agent-hours a day is not a ten-person team in any meaningful sense. It is a throughput engine with ten people steering it. Counting the people tells you almost nothing about what it produces.

Two things break as this lands, and both are worth naming before they surprise you:

  • Verification becomes the bottleneck. When agents produce 99.8% of output, the scarce human resource is the judgment that accepts or rejects it. I have argued this at length in verification cost is the new bottleneck: the constraint moves from producing work to confirming it is correct, and that cost does not fall as fast as generation cost.
  • Org charts stop mapping to output. If throughput is agents times parallelism, then seniority, span of control, and headcount budgets are measuring the wrong thing. The high-leverage person is the one who specifies and verifies the most agent-hours, not the one who manages the most people.

The delegation itself compounds. Every agent-hour is inference, and inference at this volume is a cost curve, not a fixed line. That is why the biggest operators are moving to own the silicon underneath it, a shift I traced in the biggest customer becomes the competitor. The agent-hour is both the new unit of work and the new unit of spend, and the two are the same number read from opposite ends.

How to operate when the unit changes

If the unit of work is the agent-hour, the skills that matter shift accordingly. The premium moves to specification, decomposition, and verification, the three things a human still does that an agent cannot yet do for itself. Writing a clear enough instruction that an agent produces the right thing is a skill. Breaking a large goal into parallelizable pieces is a skill. Judging correctness at the rate agents generate output is the scarcest skill of all, and the one most organizations have not started training.

The forward-looking version is uncomfortable and worth sitting with. If output is agents times parallelism, then the competitive gap between two companies is no longer a hiring gap. It is a gap in how well each one specifies and verifies work at scale. That gap is invisible on an org chart and enormous in throughput. The company that learns to run agent-hours well will out-produce the company that keeps counting heads, and the head-counting company will not understand why until it is far behind.

An agent-hour is useful only if the organization can accept its output without doing the job again. I would track it beside review minutes, accepted tasks and escaped defects. Proof-Adjusted Autonomy supplies the acceptance side of that measurement; raw runtime alone does not.