AI Can Now Execute the Wrong Idea for Much Longer

This month, Fable 5 and GPT-5.6 are at war. The press-release version is modern cyber warfare: frontier labs, compute arms races, capability curves. Squint, though, and it’s the oldest commercial contest on record: two stallholders in an ancient Greek agora, shouting over each other about whose wares are cheaper and better. Same shopfront rivalry, three thousand years on. The only novelty is that the wares now think.

So, in the spirit of a discerning agora customer, I gave one of them something simple to build: a file management page for remote storage. Drag files in, see them appear. That was the whole idea.

Twenty minutes later, it presented its work. Five separate components: an upload box accepting one file at a time, a submit button awaiting my confirmation, a status indicator, an upload history, a file listing, each with its own validation states and thoughtfully worded error messages. Everything functioned. The code was clean. The UX was what you’d get if a filing cabinet were designed by five departments who had never met.

None of it should have existed.

The agent had decided, somewhere in its first thirty seconds, that I wanted a structured uploading application. It then spent twenty minutes executing that decision with the diligence of a junior consultant who never once looks up from the brief. It is a peculiar kind of accomplishment, like a houseguest who, asked to fetch the milk, returns having reorganised your kitchen. One hesitates to complain; so much effort was clearly involved.

Here is what took me longer to notice: the older, weaker models would never have wasted my twenty minutes, and the reason is unflattering to everyone involved. They couldn’t run that long.

Progress moved into the time dimension

The shape of AI progress has changed. The recent leaps have come from models taking many more steps, and being trusted to take them unsupervised (more reasoning tokens; tools, terminals, browsers, memory; retries, self-verification, longer uninterrupted execution windows), rather than from each step getting much smarter. Research calls this test-time compute: scaling the thinking at inference rather than the intelligence at training.

METR, the group whose “time horizon” benchmark has become the industry’s favourite growth chart, measures the length of task an agent can complete, where length means how long a skilled human would need. ^[1] Since 2023 that horizon has been doubling roughly every four months. At the start of 2026 the frontier sat near a twelve-hour horizon (most of a working day, completed autonomously, with coin-flip reliability), and the best model measured since has pushed towards seventeen, which is the edge of what the task suite can reliably measure. ^[2] The benchmark is running out of ruler.

This is real capability. A mediocre worker who can run for ten hours, inspect their results and retry failed approaches will accomplish things a brilliant one who stops after thirty seconds cannot.

Notice what the axis measures, though: endurance. How long the agent can keep going. The direction of travel is taken on faith.

Misunderstanding now compounds

With earlier models, my file-storage request would have played out differently. The model would have produced a partial implementation (one upload box, half-styled) and stopped. I’d have looked at it, said “no, more like a file explorer”, and we’d have corrected course before anything expensive happened.

The old model’s weakness was accidentally a review checkpoint.

A long-running agent carries its first interpretation all the way through. The assumption shapes the page structure; the page structure shapes the components; the components shape the state model; the state model shapes the validation logic; the validation logic shapes the user journey the agent then dutifully tests and polishes. By the time a human sees the output, a misunderstanding has become architecture. The research on long-horizon agents finds the same mechanism from the inside: small per-step errors compound across a long run, and models condition on their own earlier mistakes, making the next error likelier than the first. ^[6] Meanwhile the returns on simply thinking longer flatten out surprisingly early, ^[7] and past a point more reasoning makes answers worse: models talk themselves out of positions that were correct. ^[8]

People mention hallucination less with every model generation. What actually happened is a migration. The classic hallucination fabricated a fact (a citation, a case, a number), and it sat in one sentence you could interrogate, though plenty survived scrutiny anyway. The new one fabricates intent: handed an ambiguous brief, the agent hallucinates the product you must have meant, then spends the day building it. The fabrication used to fit inside a checkable sentence; now it is smeared across an architecture, and it arrives with tests. Broken software at least announces itself: it crashes, it refuses to compile. A polished implementation of the wrong product looks finished. We have traded visible incompleteness for completed assumptions, and completed assumptions are far harder to reject.

“The danger of a more capable agent is that it can turn a small misunderstanding into a large amount of excellent work.”

We are measuring the wrong clock

Here is where the benchmarks quietly mislead us. Almost everything the industry publishes asks whether the agent eventually completed the task: pass rates, success against a defined target, maximum autonomous horizon.

Almost nothing measures the clock that matters to you. We are, in effect, rating taxi drivers by how far the meter ran, with no one checking whether the taxi arrived at the right address. The clock that matters runs from the moment you began expressing an objective to the moment you accepted the result. Call it intent-to-acceptance time.

It includes writing the brief, preparing the context, the agent’s run, your review, the corrections, the rework when the direction was wrong, and the quiet deletion of everything that should never have been built. An agent can improve on every published benchmark while making that number worse. Longer execution raises the ceiling of what AI can accomplish; with equal generosity, it raises the ceiling of what AI can waste.

Perception is unreliable here. In METR’s randomised trial, experienced open-source developers using early-2025 AI tools took 19 per cent longer on real tasks, while believing the AI had made them roughly 20 per cent faster. ^[3] METR now labels the result historical and expects today’s tools land on the right side of zero; its follow-up data leans that way, and by METR’s own account is too noisy to trust yet. ^[4] The durable finding is the perception gap. Visible output feels like productivity. Elapsed time is what your calendar records.

Enterprises repeat the mistake at scale. The dashboards count licences deployed, messages sent, tokens consumed, hours employees claim they saved. Meanwhile PwC’s January 2026 survey of 4,454 chief executives found 56 per cent reporting neither increased revenue nor decreased cost from AI in the past year; 12 per cent could point to both. ^[9] Usage metrics are easy to collect and satisfying to report; they also answer a different question. It’s the clean demo running on a dirty organisation, summarised quarterly for the board.

Execution is becoming cheap. Definition is becoming expensive.

If execution is becoming abundant, the scarce input is correctly defining the objective. That inverts how most of us learned to work with these tools, and the inversion runs all the way up the org chart.

When execution was expensive, a weak requirement failed slowly. Meetings, design reviews and prototypes gave everyone time to notice the direction was wrong. When execution is nearly immediate, a weak requirement produces a fast, complete failure. What holds for a product spec holds for strategy: as building gets cheap, the premium shifts to choosing which problem to solve, deciding what should never be built, and running a culture that rewards clear definition and honest review over visible activity. The same economics, from your component diagram to your board papers.

The old workflow was conversational: ask loosely, inspect, correct, continue. With long-running agents, the safer workflow looks like commissioning: a tight brief up front, a checkpoint mid-run, review against the original need at the end.

There’s a telling detail in Anthropic’s data on how people use its coding agent. Experienced users auto-approve far more of the agent’s actions than novices (full auto-approval roughly doubles by 750 sessions, from about a fifth to over 40 per cent), and they interrupt it nearly twice as often. ^[5] That seeming contradiction is the skill. They’ve stopped supervising keystrokes and started guarding direction. Expertise with autonomous AI is knowing which moments of intervention carry all the leverage.

The agent that produced my five-component filing cabinet took the feedback graciously, and offered, with entirely fresh enthusiasm, to build the settings page.

Are you ready to retrain everyone quarterly?

Now the uncomfortable enterprise question. Every frontier release changes the optimal working pattern: how much detail a good brief requires, whether the model asks or assumes, how long it runs before returning, how much initiative it takes. The habits your teams built on the last model are silently invalidated by the next one, and this northern summer, the next one arrived roughly weekly.

That is a new workforce operating model arriving every few months, priced and deployed like a licence renewal: the corporate equivalent of replacing the office coffee machine and discovering it has quietly rewritten everyone’s job description. Most organisations hand out the licences, run one training session, and measure adoption. Then they wonder why the P&L can’t find the value, while their employees generate ever-larger volumes of beautifully executed misunderstandings.

Johnny’s verdict

The moment you hand work to an agent, you become a manager, and the constraint on your output stops being your hands. Andy Grove wrote the playbook for this forty years ago: a manager’s output is the output of the organisation under them, and the craft is spending yourself on the few activities with the highest leverage. ^[10] Your organisation now includes machines that execute for hours, so management capacity, once a concern reserved for people with headcount, just became personal. The disciplines that matter are the classic managerial ones: strategy, value, delegation, and John Doerr’s rule of measuring outcomes rather than activity. ^[11]

So stop asking how much your AI produced. Ask how much of it you accepted, and how long acceptance took:

• Set strategy before tasking. Which problem deserves solving, and what the result is worth. Deciding what should never be built used to be an annual planning call; with agents, it’s a daily one, and it happens in the brief.
• Write the fence before the brief. The job to be done, the simplest acceptable version, and the explicit exclusions. Every ambiguity you leave in will be executed: thoroughly, competently, and at length.
• Spend your interventions where the leverage is. Make the agent restate the job in its own words and show a minimal version before it builds the cathedral. Interrupting at that moment is the highest-leverage act available to you; the weak models used to perform it for free.
• Review against the need, not the diff. The question is rarely “does this work?” It’s “which assumptions appeared uninvited, and could half of this be deleted?”
• Measure what matters. Intent to acceptance, first-pass acceptance rate, percentage of generated work discarded. Outcomes, never activity. If you only count output, your dashboard will glow while your calendar bleeds.
• Re-learn on every release. The brief that worked last quarter over-constrains this quarter’s model, or under-constrains it. Treat each frontier release as a small retraining event, because it is one.

The defining failure of this era will be excellent work that should never have existed: professional output, passing tests, clear documentation, and someone still has to delete it. AI can now work for much longer; the scarce skill is deciding what it should work on.

The agent will no longer stop to ask. So you have to stop it to tell.

You are a commissioning editor for autonomous AI agents. Help me turn a task I'm about to delegate into a brief that cannot be executed wrongly for hours.

Ask me to paste the task exactly as I'd naturally type it. If you hold memory or past chats where my requests were over-built, audit those first; otherwise ask what the job to be done is, what the simplest acceptable version looks like, and what would make me delete the result.

Rewrite my request with:
1. The job to be done, in one sentence.
2. The simplest acceptable version, stated as the target.
3. Explicit exclusions: what must never be built.
4. A checkpoint order: restate your interpretation and show a minimal version before building on it.
5. My acceptance test, phrased against the need, never the code quality.

Deliver the rewritten brief as one copy-paste block, plus a one-line note naming the riskiest ambiguity you removed.

If you can browse the web, read the full essay first — it carries the complete argument and sources: https://thejop.com/essays/ai-can-now-execute-the-wrong-idea-for-much-longer/

Prompt from "AI Can Now Execute the Wrong Idea for Much Longer" — Johnny Opinion Press, thejop.com