Eight Hours of Agent Work, Eight Minutes of Review

An operations director asked me this last month, halfway through an agent rollout: "If the agent does eight hours of work overnight, how am I supposed to check it in the eight minutes I actually have?" It is the best question I have heard all year, because it names the real constraint on agentic AI. The doing is no longer the bottleneck. The checking is.

Most companies discover this the hard way. They stand up an agent, it produces a mountain of output on day one, and a competent human spends day two reading all of it. Congratulations: you have reinvented the job you automated, except now it is proofreading.

The answer is not "trust the agent" and it is not "read everything". It is a system. You shape the work so it is checkable, you make the agent verify itself, you set a second agent against the first, you compress what the human sees, and you sample the rest. Here is how we build that with clients.

Why Is Review the Bottleneck Now?

Because agent output has scaled faster than human attention, and the vendors have already redesigned their products around that fact. When Anthropic rolled Claude Cowork out to web and mobile on 7 July, the pattern it enabled was explicit: kick off work from anywhere, monitor it, approve it. OpenAI shipped the same shape with Codex Remote, which lets you approve an agent's actions from your phone while it works on a machine somewhere else. The industry's default workflow is now supervised delegation, and the human's job in that workflow is judgement, not production.

The scale of the asymmetry is worth sitting with. Anthropic's enterprise proof point for Claude Fable 5 was Stripe migrating a 50-million-line codebase in one day, against an estimated two months by hand. Nobody reviews 50 million lines by reading them. Whatever Stripe's engineers did to gain confidence in that migration, it was not line-by-line inspection. That is the discipline the rest of us now need at smaller scale.

And this is not a software problem. Anthropic's own usage data across 1.2 million anonymised Cowork sessions shows business-process operations at 33.4 percent of usage (reporting, checklists, spreadsheet reconciliation) while software development sits at 8.7 percent. The people drowning in unreviewed agent output are operations managers and finance leads, and they do not have a code review culture to fall back on. They need one.

How Do You Make Agent Work Checkable Before It Starts?

You write the acceptance criteria before the agent does anything, the same way you would for a contractor you have never worked with. If you cannot state what "done and correct" looks like in advance, no review process will save you, because you will be deciding the standard while marking against it.

In practice this means two things.

First, define the pass conditions up front. For a reconciliation task: every transaction matched or listed as an exception, totals agree with the bank feed to the cent, no category invented that is not in the chart of accounts. For a proposal draft: pricing pulled from the current rate card, every claim traceable to a source document, mandatory sections present. Write these down. Give them to the agent as part of the brief, and keep them as your marking sheet.

Second, demand structured output. Free-form prose is the most expensive thing a human can review, because you have to read all of it to trust any of it. A table of exceptions, a checklist with pass or fail against each criterion, a summary with linked evidence: these can be checked in minutes because their shape does the organising for you. When we scope agent workflows for clients, the output format gets designed before the prompt does.

The uncomfortable corollary: if a task resists checkable criteria, it is probably not ready to delegate to an agent. That is useful information, not a failure.

Can an Agent Verify Its Own Work?

Yes, and it should, before a human ever sees the output. Self-verification will not catch everything, but it reliably catches the cheap, embarrassing errors that would otherwise burn your eight minutes on trivia.

The verification toolkit depends on the work:

• Tests. For anything code-shaped or rule-shaped, make the agent write and run tests, and include the results in the deliverable. A green test suite is compressed evidence.
• Checklists. Give the agent your acceptance criteria and require it to mark each one pass or fail, with a pointer to the evidence. An agent that must show its marking is harder pressed to hand-wave.
• Citations. Every factual claim in a report should carry a reference to its source: the document, the row, the transaction ID. Unsupported claims get flagged as unsupported, not silently included.
• A self-review pass. A separate pass, after the work is finished, with a different framing: "find the three most likely errors in this output". Asking a model to critique is a different task from asking it to produce, and it surfaces different problems.

None of this is exotic. It is the same discipline you would demand from a junior employee handing work upward, applied mechanically.

What Does an Adversarial Second Agent Add?

A second agent whose only job is to break the first one's work catches the failures that self-review misses, because it has no investment in the output being right. The producing agent, asked to check itself, tends to confirm. A fresh agent, prompted to refute, tends to attack.

We set these up as genuine adversaries: "Here is a reconciliation and the criteria it claims to meet. Find every place it fails. Assume it is wrong somewhere." The critic does not need to be your most expensive model; refutation is often cheaper than production, and a mid-tier model with a hostile brief is a surprisingly effective auditor.

What the critic produces matters as much as what it finds. The useful output is a short, prioritised list of disputes: claim, objection, evidence. Human review then becomes adjudication. You are not reading the work; you are ruling on a handful of specific disagreements between two systems that have already done the reading. That is a job a competent operator can do in minutes, and it is a much better use of their judgement than proofreading.

This adversarial pattern is also the backbone of proper agent evaluation before you ever deploy, which I have written up separately in how to evaluate AI agents. The same muscles apply: evaluation is pre-deployment review, review is continuous evaluation.

What Should the Human Actually Look At in Eight Minutes?

The human should see judgement calls, exceptions and uncertainty, never raw output. The review surface is a design problem, and most teams have not designed one, which is why their reviews take hours.

Three surfaces do most of the compressing:

1. 1Diffs, not documents. If the agent updated the pricing model, show what changed against the last approved version. Humans are excellent at judging deltas and terrible at re-reading whole artefacts for the fourth time.
2. 2Exception reports, not full listings. For 400 reconciled transactions, the review surface is the 12 the agent could not match, each with its best guess and the evidence either way. The 388 clean matches appear as a count, not as pages.
3. 3Confidence flags. Require the agent to mark each output item as confident or uncertain, with a reason. Then review the 5 percent it is unsure about and sample the rest. Calibration will not be perfect, but even rough self-flagging concentrates human attention where it earns the most.

The eight minutes, spent well, look like this: two minutes on the checklist and critic's disputes, four minutes on flagged exceptions, two minutes spot-checking random items from the confident pile. Judgement applied at the points of maximum doubt, everywhere else covered by structure.

Do You Really Have to Inspect Everything?

No, and pretending you will is how review processes quietly die. A process that demands 100 percent inspection gets skipped the first busy week, and then you have zero percent inspection with a policy that says otherwise. Manufacturing solved this decades ago: sample, measure the defect rate, and manage to an error budget.

Set the budget explicitly per workflow. For internal draft reports, a 2 percent error rate found in sampling might be acceptable, because errors are cheap and caught downstream. For customer-facing pricing, the budget might be zero, which tells you that workflow needs a harder gate than sampling. The point is that the number is chosen, written down and reviewed, not implied by whoever was tired that day.

Then audit on a cadence. Pull a random 10 percent of last week's agent outputs and mark them properly against the acceptance criteria. If the sampled error rate sits inside the budget, the system is working and the eight-minute reviews stand. If it drifts above, you tighten: more self-verification, a stronger critic, a bigger sample, or the task comes back under closer supervision until the rate recovers. Error rates trending in the right direction are also your evidence for expanding agent autonomy, which beats gut feel every time.

When Is Eight Minutes Not Enough?

Whenever the action is irreversible, external or regulated, the compressed review does not apply and the work gets full human attention before anything leaves the building. No sampling regime makes it acceptable to discover a bad outbound email after it sent, a payment after it cleared, or a compliance filing after it lodged.

Our rule with clients is to tier by blast radius:

• Reversible and internal (draft reports, reconciliation suggestions, research summaries): eight-minute review, sampling audits, generous error budget.
• Reversible but external-ish (CRM updates, internal system changes): eight-minute review plus a hard gate on anything the agent flags, tighter budget.
• Irreversible, external or regulated (payments, contracts, customer communications at scale, anything a regulator reads): full review, named approver, no exceptions, however confident the agent claims to be.

The approval affordances the vendors shipped this year, from phone approvals to per-action gates, make the tiering easy to implement and easy to ignore. Deciding which actions sit in which tier is a governance call, not a tooling one, and it belongs in the same conversation as permissions and guardrails. I have laid out how we structure that in AI governance as freedom inside guardrails.

Where to Start This Week

Pick one agent workflow you already run and retrofit the framework: written acceptance criteria, structured output, a self-review pass, and an exception-first review surface. Time your next review. Most teams get from hours to minutes inside a fortnight, and the audit trail they gain is worth more than the time.

If you would rather not work it out alone, this is the exact problem our AI consulting engagements are built around: designing the delegation, verification and review loop so your team supervises agents instead of proofreading them. Bring us the workflow that is eating your afternoons and we will help you get it to eight minutes.