AI Agents Are Finally Doing Real Work. The Numbers Are Weird.

The Short Version

AI agents are not just a demo anymore.

A new OpenAI report, written with researchers from Columbia, Duke, and the University of Pennsylvania, looked at how people are using Codex. The headline is simple: people are starting to delegate real work to AI instead of just asking it questions.

Not "write me a paragraph." Not "explain this error."

More like: inspect my files, change the thing, run the command, create the report, fix the workflow, and come back when you are done.

That's the shift. Chatbots answer. Agents do.

What the report says

Codex started as a coding tool. That makes sense. Code is one of the easiest places for an agent to work because the output is testable. Either the app builds or it does not. Either the test passes or it fails.

But Codex is spreading beyond code.

OpenAI says Codex now has more than 5 million weekly active users, up more than 6x since the desktop app launched in February. Developers are still the biggest group, but knowledge workers now make up about 20% of users and are growing more than three times as fast.

Translation: the tool built for developers is being pulled into normal office work.

People are using it to make reports, spreadsheets, presentations, contracts, research summaries, lightweight tools, and all the other digital paperwork that eats the workday.

This is exactly the pattern I wrote about with Claude Code and vibe coding. First the tool looks like it is for engineers. Then everyone realizes the real skill is not "writing code." The real skill is describing work clearly enough that an AI can do it.

The weird part

The adoption numbers are messy in a very interesting way.

Inside OpenAI, Codex has basically taken over. The report says that, as of June 11, 2026, Codex accounted for 99.8% of output tokens generated across Codex and ChatGPT by OpenAI workers.

Among outside organizations, Codex accounted for 63.3% of output tokens.

Among individual users, it was only 16.5%.

And here is the part that matters: fewer than 1% of active individual users had used Codex in the last 28 days, according to the report. Almost everyone is still using chat.

So no, we are not living in a world where every person has five AI agents running their life.

Not yet.

But the people who do cross the line use it a lot. They stop treating AI like a search box and start treating it like a junior operator. A slightly chaotic one, sure. But still an operator.

Update: Linear shows the second weird number

Two months later, Linear has published a useful second data point.

Its AI usage report looks at aggregated product data from paid Linear workspaces: AI conversations, agent sessions, issue activity, comments, and pull requests. It is not a census of the whole market, and Linear is careful about that. It can see what happens inside Linear. It cannot see every AI workflow happening in a terminal, IDE, Slack thread, browser, or private repo.

Good.

That limitation is exactly why the report is interesting. It is not trying to turn token counts into a productivity religion. It is looking at the work surface where product teams actually coordinate.

The first signal: AI use is no longer just an engineering habit.

Between January and June 2026, Linear says the share of users active on its AI features more than doubled in every function it measured. Product users went from 12% to 34%. Engineering went from 12% to 30%. Even go-to-market went from 5% to 18%.

That matches the Codex story: agents start in code, then leak into normal organizational work.

The second signal is sharper.

Linear says teams with coding agents opened far more pull requests per workspace per week than teams without them. In June 2024, the coding-agent cohort averaged roughly 21 PRs per week. By June 2026, that number was about 65. Traditional teams moved from about 8 to about 10.

That is a huge difference.

It is also not the same as "AI made everyone 3x more productive."

Linear says the quiet part out loud: pull requests measure motion, not value. More PRs can mean more useful work. They can also mean more review burden, more coordination, more small changes, more bot-generated noise, more partially finished branches, and more things for humans to merge, reject, rewrite, or babysit.

Then comes the line that should make every AI productivity deck sweat a little:

Linear says the gains have not clearly shown up as time saved. Existing work held, AI appeared as an additional layer, and overall time spent on product development appears to be going up rather than down.

Very efficient. We automated the work and got more work.

This is not a dunk on agents. It is the realistic adoption curve.

When a tool makes work cheaper, teams often do more of it. They write more issues. Open more PRs. Explore more branches. Ask for more variants. Turn vague ideas into tickets earlier. Review more machine-generated diffs. Move faster in one part of the system and discover that another part is now the bottleneck.

The agent did not remove the team.

It moved the constraint.

The review layer is becoming the product

Linear's August 20 changelog makes the same point from the product side.

Linear Agent can now set up, run, and test code before returning work. It can adapt to codebase configuration, install dependencies, use pinned runtime versions and setup scripts, run the app, navigate through browser flows, verify the implementation, capture before-and-after screenshots, fix problems, rerun tests, and return the work with validation attached.

That sounds like a coding-agent feature.

It is also a review-system feature.

The important move is not only that the agent writes code. It is that the agent brings evidence back with the code: what environment it used, what it ran, what it saw in the browser, what changed, what failed, what it fixed, and what still needs a human decision.

This is where agent products are heading.

Not just "here is a patch."

"Here is a patch, the run history, the test evidence, the screenshots, the cost, and the remaining judgment call."

That is much closer to how teams will actually absorb agentic work.

The bottleneck becomes less typing code and more deciding whether the machine-produced work should enter the product.

What an agent actually changes

The simplest way to understand this:

A chatbot gives you instructions.

An agent follows instructions.

If you ask ChatGPT, "How do I analyze this spreadsheet?" it can explain the steps. If you ask an agent, it can open the spreadsheet, write the formula, make the chart, save the file, and tell you what changed.

That sounds small until you realize how much of modern work is basically that.

Find the thing. Move the thing. Rename the thing. Compare the thing. Turn this thing into another thing. Send the thing to the right person.

We pretend this is knowledge work. A lot of it is file babysitting.

Agents are good at file babysitting.

Why this matters if you do not code

The big mistake is thinking this is about programming.

Programming is just the first beachhead because developers are comfortable letting tools touch files, run commands, and break stuff in a controlled environment. Most people are not. If you are a marketer, lawyer, analyst, recruiter, or founder, giving an AI access to your files feels insane.

Honestly? Fair.

But that is also why this is important. The hard part is not only model intelligence. The hard part is trust, permissions, review, and workflow design.

OpenAI's own report says adoption depends on context: access to relevant files and systems, management expectations, worker skills, and review processes. In normal language: agents work best when the environment is built for them.

That is why OpenAI is such an extreme example. Employees there have training, internal culture, cheap access, and a reason to try the newest thing. Your dentist's office does not.

So the future will not arrive evenly. It never does.

First it shows up in AI labs and tiny startups. Then software teams. Then operations teams. Then one person in finance quietly automates half their recurring work and everyone asks why their reports are always early.

The catch

There are two big catches.

First, the numbers are not perfect. Some of the report's task-complexity estimates are model-estimated. That means an AI is estimating how long a human task would take. Useful, but not the same as a stopwatch.

Second, agents need supervision. This is the boring sentence that matters most.

An agent that can edit files can also edit the wrong files. An agent that can send emails can also send a weird email. An agent that can browse your docs can also misunderstand them.

This is why the future job is not "do nothing while AI works."

The future job is: explain the goal, give the right context, set boundaries, review the output, and catch the weird stuff before it becomes real.

Less typing. More directing.

What you should try

If you have never used an agent, do not start by giving it your whole life.

Start small.

Give it a folder with harmless files. Ask it to organize them. Ask it to summarize a few documents. Ask it to turn messy notes into a clean brief. Ask it to make a spreadsheet from a CSV. Watch what it does.

Then ask yourself the real question: did it save time, or did it just create a new thing to babysit?

Linear's data makes that question less rhetorical.

The best early answer might be:

It creates more finished-looking work, and then your process has to decide what deserves to survive.

That is the whole game right now.

Agents are finally good enough to do real work. They are not good enough to be ignored.

And that might be the most accurate picture of AI in 2026: not magic, not fake, but weirdly useful if you know how to manage it.