The verification economy

This week I shipped a small app. One agent built it. Six other agents reviewed it, in three rounds, before any human read the code. They filed about fifty findings. Several were real bugs: a fetch that quietly lost data, a missing protection that let any website spend my API budget, an injection path I would not have caught myself. I fixed what they found and shipped.

Both sides of that exchange were mine. My agent produced the work, and my agents checked it. The next step is not hard to see. Soon the checking agent will belong to someone else. A client’s agent will accept or reject a contractor’s agent’s deliverable. That is the shape of work between companies, and it is worth thinking through now, while it is still forming.

The flood lands on the checking step

Start with the arithmetic. Agents make production cheap. I have argued what that does at a single desk: when answers are nearly free, your job becomes judging answers. But a person’s attention does not scale. A contractor’s agents can produce in an afternoon what your team can review in a week. The queue forms at the checking step, and it only grows. So the checking gets delegated too. Not because anyone loves the idea. Because there is no other place for the work to go.

Economists have a name for what checking costs: a transaction cost. Kenneth Arrow wrote that virtually every commercial transaction has within itself an element of trust. Trust is what lets you skip the checking. Where trust is thin, as it is between companies, we built checking institutions instead: audits, inspections, escrow, acceptance testing. All of them are priced for human-speed output. Agent-speed output breaks that pricing. The institutions will not disappear. They will get agents of their own.

The deliverable becomes a claim

The first visible change is the shape of the deliverable. Work stops being a thing you hand over and becomes a claim plus the evidence to survive checking. The acceptance test becomes the contract. If you want to know what agent-to-agent commerce will feel like, read an eval suite, not a demo.

Pieces of this already run at scale. Ad verification is an entire industry of machines auditing machines’ delivery claims; DoubleVerify alone processed over a trillion ad events in 2024. Code review bots already read contractor pull requests. Insurers run software that adjudicates claims that other software filed. And the plumbing for the general case is being laid right now: the A2A protocol standardizes how agents identify each other, and AP2 standardizes how they pay each other, with “non-repudiable proof of intent” as a design goal. Identity and payment are getting protocols. Acceptance of work is the layer still missing. It will look like evals.

I made a related argument about model fungibility: the eval suite is the asset that lets you swap models safely. This is the same asset one level up. Between firms, the eval suite is not just protection. It is the interface.

Who checks the checker

Delegating verification does not remove the trust problem. It moves it up a level. If your agent accepts my agent’s work, why do you trust your agent? Somewhere the recursion has to stop.

Commerce has solved this recursion before, slowly and expensively. Auditors, bonds, warranties, spot checks. Agent commerce will re-derive the same institutions at machine speed, in a stack, cheapest first:

1. Executable checks. Tests pass or fail. Numbers reconcile or they don’t. Cheap, honest, and narrow.
2. Adversarial agents. Your agent probes my agent’s work wherever the result can be checked. This is where most of the new capacity goes.
3. Sampled human audits. Experts read a random slice, the way tax authorities audit returns. Expensive, so it is spent on samples, not totals.
4. Liability. At the top, someone with a balance sheet stands behind the work. Warranty, insurance, a bond. Money is the verifier of last resort.

Each level costs more than the one below it and gets used less. And note what falling verification cost does to the boundary of the firm: checking is a transaction cost, and when a transaction cost falls, the make-or-buy line moves. Work that was kept in-house because outsiders were too expensive to check will cross company lines.

You stop doing the work. Then you stop checking it. What is left is standing behind it.

Two ways it fails

The first failure is correlation. A panel of checkers is only useful if they fail differently. One recent study put nine LLM judges on a panel and found the panel behaved like about 2.2 independent votes. The correlation was structural, not just a family effect. My own six reviewers were all the same model family, which means they shared blind spots I cannot see either. Auditor independence rules exist for exactly this reason. Agent verification will need its own version.

The second failure is Goodhart. I wrote about it in the training context: a verifier with a hole in it teaches the exploit. The same holds at the commercial interface. Once acceptance tests are the contract, deliverables get optimized to pass the tests rather than to be good. Verification that is cheap but correlated, or thorough but gameable, is theater. Keeping the checks honest is permanent work, not a setup step.

Standing behind the work

So the human role moves twice. Agents took the producing first. They are taking the checking now. What remains is the part that cannot be delegated, because it is not labor. It is commitment.

Someone writes the rubric that defines what good means. Someone audits the auditors on a sample. Someone owns the outcome when both layers miss, and can be sued, fired, or ruined for it. That was always the scarce part of professional work. The signature, not the typing. The agents are just making it the whole job.