Something strange is happening in AI budgets this year. The price of intelligence collapsed, per-token costs are down almost two orders of magnitude since early 2024, and yet the bills keep climbing. Companies are reportedly burning through annual AI budgets by summer. Part of the answer is that an agent isn't a chatbot: one task fans out into ten or twenty model calls. But a growing share of the spend is something quieter. It's the checking. Evaluating, monitoring, and verifying what the agents did is becoming its own budget line, and for some teams it costs more than running the agents themselves.
I told you in Issue 002 that the verification is the work now. This issue is about what that work costs, because cost is where verification actually dies. Nobody decides to stop checking. The checks just quietly don't happen, because each one is priced in the single currency that doesn't scale: human attention. A check that needs a person to look is a check that stops happening the week everyone gets busy, which is the week you needed it.
So the whole game of verification at scale is re-pricing. Take every check you wish were happening, and push it down to the cheapest mechanism that can still catch the failure. There's a ladder, and it's worth walking rung by rung.
The verification cost ladder
At the bottom, nearly free: property checks. You usually can't verify that an output is right, but you can always verify that it's well-formed, in bounds, in policy, in schema. That sounds trivial until you notice how many real failures are exactly that, and that these checks cost nothing and can run on every single output. Free coverage comes first.
Next: cross-checks against your own systems. When an AI output states a price, a date, a policy, a balance, something one of your systems already knows, the comparison is mechanical. A contradiction with your own record isn't a suspicion to investigate. It's a catch, automated, at query cost.
Then the rung people skip: canaries. Feed the system test cases with known right answers, on a schedule, and alarm when one sails through unflagged. This check isn't really about the output. It's about the watching. Monitoring decays silently, I wrote about that drift in Issue 009, and a canary is how you verify the verifier without paying a human to stare at dashboards.
Then machines checking machines. Here's the asymmetry that makes this rung work, and it's the load-bearing idea of the whole issue: checking is cheaper than producing. A model that can't reliably produce a correct answer can still reliably detect that an answer contradicts the document it came from. Classification is an easier job than generation. So a second, often smaller, model can screen the flood of outputs and flag the suspicious minority. Two honest cautions, because this rung gets oversold: a machine judge has its own biases and drifts with every model update, so it needs calibrating against human samples, and it's a screen, not a verdict. It decides where attention goes. It doesn't replace it.
And at the top, the expensive rung: human judgment. The best check you have, the only one that catches the technically-valid output that's still the wrong call, and the only one that cannot scale. Which is exactly why it must be spent, not sprayed: on irreversible actions, on what the lower rungs escalate, and on a small sampled slice whose only job is calibrating everything below it.
Put it together and the discipline is one sentence: for every check, ask whether a rung below could catch the failure, and push it down until the answer is no. What remains at the top is the short list of places a human genuinely belongs, and because the list is short, the human actually shows up for it. That's the difference between verification as intention and verification as something that happens. On the test bench in 2000, we didn't verify chips by heroic attention. We made the thirty runs cost forty-five seconds. The AI version of that move is this ladder.
A check you can afford is a check that happens. Everything else is a good intention with a budget problem.