An output you can't check is work you didn't save

In August, OpenAI shipped ChatGPT Work — a version of its Codex agent aimed past software engineers at everyone else: the accountants, analysts, marketers, and operators who live in email, Slack, Notion, and Figma. The pitch was an agent that doesn’t just answer but does: multi-step tasks, finished and handed back.

Here’s the detail worth sitting with. As TechCrunch reported, almost everyone inside OpenAI uses the agentic tool — but among the company’s own subscribers, adoption of the agent was strikingly thin: a minority of organizations and, by the reported figures, well under one in a hundred individual users. A tool that can, by any honest account, do a real slice of your job. And most people who could use it, don’t.

The easy explanation is that the output must be bad. But that’s not what the reporting describes, and it’s not what usually happens. The harder, more useful explanation is that capability was never the bottleneck. The bottleneck is a cost nobody puts on the roadmap: the cost of checking.

The brain charges you for evaluation

We tend to model delegation as pure upside — the agent does the work, you get the time back. But your brain runs a quieter ledger, and it counts something the pitch leaves out.

There’s a solid line of neuroscience showing that mental effort is treated by the brain as a genuine cost, weighed against reward the same way physical effort or delay is. The subjective value of cognitive effort shows up in the brain’s valuation machinery — the dorsal anterior cingulate and the same domain-general value network that prices other costs — and, given a free choice, people reliably pick the path that demands less thinking. Researchers have called it, only half-jokingly, a law of least mental effort. Alongside it sits an older finding: we’re averse not just to effort but to ambiguity — we discount options whose outcome we can’t pin down.

Put those together and you get the thing the demo hides. Delegating a task doesn’t just cost you the handoff. It costs you the verification — the mental work of deciding whether what came back is right. And that cost is paid in exactly the currency the brain is stingiest with: focused evaluation of an ambiguous result.

So the real equation a user runs, mostly below awareness, isn’t “can the agent do this?” It’s:

time to do it myself vs time to specify it + time to check it

You only come out ahead when checking is cheap. When verifying the output costs about as much as producing it would have, delegation nets to zero — and a rational brain, sensing that, quietly declines. Near-zero adoption isn’t a mystery. It’s the arithmetic working exactly as it should.

Why the coders adopted it first

This also explains the group that did take to agents: engineers. Not because developers are braver, and not only because the tool started there. Because code comes with a built-in verifier. It compiles or it doesn’t. The tests pass or they don’t. The check is close to free and close to objective — the machine grades it for you.

A slide deck, a go-to-market plan, a financial model, a positioning doc — none of these ship with a green checkmark. To know whether the agent’s version is good, you have to reconstruct the reasoning, which is most of the work you were trying to avoid. The output can be excellent and still not get used, because the user can’t cheaply confirm that it is. Capability arrived; a cheap way to trust it didn’t.

The build decision: engineer the check, not just the capability

If verification is the real tax, then the highest-leverage work in an agentic product isn’t making the model more capable. It’s making its output cheap to check. Three moves, from the same principle:

Show the work so the check is a skim, not a re-derivation. Don’t hand back only the answer; hand back the few load-bearing steps, the sources, the assumptions it made. You’re not decorating — you’re converting an expensive re-think into a fast scan.

Make the output land in a checkable shape. A diff beats a rewrite. A number with its inputs visible beats a number. A draft that highlights the three sentences it’s least sure about beats a confident wall of text. Every one of those turns a global “is this right?” into a few local, glanceable questions.

Pick first jobs where “right” is self-evident. The beachhead for any agent is the task with a built-in verifier — reconciles or doesn’t, matches the schema or doesn’t, the link works or it doesn’t. Win where checking is nearly free, earn the trust, then move outward.

The uncomfortable version of all this: a feature’s ceiling isn’t set by what it can do. It’s set by how cheaply a wary human can confirm it did it. Build the check, and the capability finally gets used. Skip the check, and you’ve built something genuinely powerful that quietly nets to zero.

The science, to look up: effort-based decision-making and the subjective value of cognitive effort in the dorsal anterior cingulate / domain-general valuation network; the “law of least mental effort” — Kool, McGuire, Rosen & Botvinick, Decision making and the avoidance of cognitive demand (2010); cognitive-effort discounting (Westbrook, Kool & Braver); ambiguity aversion — Ellsberg (1961). Mechanisms and effect sizes are still debated — treat the direction as robust, the magnitudes as approximate.

The news, to check: OpenAI’s launch of ChatGPT Work — TechCrunch, “OpenAI is building AI agents for everything. Will everyone use them?” (Aug 24 2026) and the follow-up interview with OpenAI’s head of product (Aug 25 2026); corroborated by CryptoBriefing and Outlook Business (Aug 2026). Adoption figures are as reported by TechCrunch.