On June 25, 2026, Drew Johnston, David Holtz, Alex Martin Richmond, Christopher Ong, Prasanna Tambe, and Aaron Chatterji posted a paper that finally gave the AI-agent conversation something better than vibes: usage data from OpenAI Codex.
The headline is not subtle. Active Codex users grew more than fivefold in the first half of 2026, and the growth was fastest outside the original developer-heavy audience. More than 10 percent of users managed three or more concurrent Codex agents at some point each week, and 26.6 percent used skills.
That is the interesting part to me. The story is not simply that models got better. It is that people are beginning to change the shape of their work around delegated software agents.
Here are seven myths I would retire after reading the data.
Myth 1: AI agents are just chatbots with extra buttons
Reality: agents are closer to background collaborators with their own work queue.
OpenAI's original Codex launch framed the product as a cloud-based software engineering agent that can work on many tasks in parallel. Each task runs in its own isolated environment, preloaded with the repository, with the ability to read files, edit code, run tests, and return evidence through terminal logs and test output.
That is a different work pattern from asking a chatbot for a function. The user is not only prompting for an answer. The user is delegating a task, leaving it to run, then reviewing an artifact.
The adoption data matters because it shows people using that pattern repeatedly enough to form habits. Concurrent agents are the signal. Once a user has three background tasks running, the tool is no longer a smarter autocomplete. It is a queue.
Myth 2: Only software engineers care
Reality: developers are early adopters, not the entire market.
The paper says usage grew fastest outside the initial software developer audience. That does not mean lawyers, operators, founders, analysts, and PMs are suddenly becoming senior engineers. It means software agents are being used for work adjacent to code: data cleanup, internal tooling, writing scripts, auditing documents, running repeatable checks, and turning vague operational friction into small tools.
This tracks with what I see in real teams. The bottleneck is often not raw implementation skill. It is turning a fuzzy request into a scoped, reviewable unit of work. Agents lower the activation cost for those annoying tasks that are too small for a ticket but too real to ignore.
Myth 3: The agent era starts when agents become fully autonomous
Reality: the useful version is supervised delegation.
Codex still returns work for review. The launch notes emphasize manual validation, terminal logs, test outputs, and the ability to request revisions. OpenAI's Help Center also makes clear that larger codebases and longer sessions consume more agentic usage, which is a polite way of saying that autonomy has a cost curve.
The practical workflow is not "go build my company while I sleep." It is closer to: take this narrow task, use this repo context, run these checks, show me what changed, and stop when evidence runs out.
That may sound less magical, but it is more useful. Software work has always been full of bounded delegation. Agents fit there before they fit anywhere else.
Myth 4: Prompting is the main skill
Reality: configuration is becoming the main skill.
One of the most useful details in the adoption paper is that 26.6 percent of users used skills. OpenAI's Codex docs also put real weight behind AGENTS.md, memories, sandboxing, workflows, subagents, permissions, and review surfaces.
That is the right direction. A good prompt helps once. A good project instruction helps every future run. A stable test command, a clear permission rule, and a documented release checklist are more valuable than another clever sentence in a chat box.
For my own work, the agent setup I care about has three layers:
- Repo instructions that explain the local architecture and commands.
- Task shape that defines what success and non-success look like.
- Verification rules that force the agent to prove what it did.
The teams that treat agent setup as engineering infrastructure will get more durable gains than teams that treat it as prompt theater.
Myth 5: More agents automatically means more output
Reality: parallelism moves the bottleneck to review.
The paper's most eye-catching behavior is users running multiple agents concurrently. That is powerful, but it also creates a new kind of queue. Someone still has to read diffs, check assumptions, merge work, reject weak patches, and decide what belongs in the product.
This is where I think many teams will overestimate the short-term upside. If three agents produce three plausible pull requests, you do not have three wins. You have three review obligations.
The better pattern is not maximum concurrency. It is intentional concurrency. Run agents in parallel when the tasks are isolated: tests for one package, documentation cleanup in another, a small bug reproduction elsewhere. Avoid parallel edits to the same shared file unless you enjoy reconciliation work.
Myth 6: Agents remove the need for senior judgment
Reality: they make senior judgment show up earlier.
The person delegating the task still has to know what not to ask for. They need to spot risky blast radius, hidden dependencies, flaky test signals, weak security assumptions, and attractive patches that solve the wrong problem.
Agents can create the illusion that execution is the scarce part. In many codebases, execution is not the scarce part. Taste, sequencing, and constraint management are.
A senior engineer using agents well will spend less time typing boilerplate and more time designing the path: which tasks are safe to split, which files are shared leverage points, which tests count as evidence, and when a change should be deleted instead of polished.
Myth 7: The adoption curve is already settled
Reality: we are still watching the workflow harden.
The paper says the share of individual Codex users submitting at least one request estimated to require more than eight hours of experienced-human work increased nearly tenfold since the start of 2026. That is a serious behavior shift, but it is not the same as saying every team has integrated agents cleanly.
The next phase is less about whether agents can produce code. They can. The harder question is whether teams can absorb agent output without creating review debt, security gaps, and tool sprawl.
My bet is that the winners will not be the loudest adopters. They will be the teams that turn agents into boring process: scoped tickets, checked environments, explicit permissions, reproducible commands, and short feedback loops.
The real AI-agent milestone is not autonomy. It is when delegation becomes mundane enough that teams budget for it, review it, and measure it like any other engineering system.
That is the part worth watching after the Codex data. Not the demo where an agent does one heroic task, but the team that quietly learns how to run ten small ones without losing control.