Last issue's point was that an AI sounds exactly as confident when it's wrong as when it's right. Fine. So you verify. Don't trust the tone, check the output.
Except that advice falls apart the moment you try to live it. If you verify every answer by hand, you're doing the work yourself and the AI agent saved you nothing. The productivity case dies. Keeping a human in the loop on every action is the advice everyone gives and nobody can actually run at scale. So "just verify everything" is a non-answer. The real question, the one that decides whether you can oversee autonomous AI at all, is sharper: what do you check, how, and how do you make checking cheap enough that it's worth doing?
Two answers, and you need both.
The first one I learned in 2000, validating chips. The test was brutal by design: sweep voltage, temperature, and frequency across their whole range, find where the chip failed. And one clean run proved nothing, it might be an outlier, so you ran it about thirty times across multiple chips before you trusted the result. Done by hand, that was months of work. So I automated the rig, every instrument synced, one click, forty-five seconds a run. The thirty runs didn't go away. They got fast. The discipline stayed, the labor disappeared.
That's the first answer: you don't verify by hand, you build verification into the system so it runs cheap and repeats without you. With AI agents it's the same move: checks, ground truth to compare against, constraints that catch a bad output automatically. Governance designed into the system, not bolted on after. If verification depends on a human paying attention every time, it won't happen, because attention is the one thing that runs out.
The second answer is where leadership judgment comes in. You don't check everything to the same depth. You can't, and you shouldn't. The skill is triaging by stakes: how much does it cost if this output is wrong, and how hard is it to undo? Cheap and reversible, spot-check it and move on. Expensive or irreversible, money out the door, a customer harmed, an action an agent can't take back, gate it hard and verify before it ships, not after.
Put the two together and you get something you can run. Sort your AI agents' output by what it would cost you to be wrong. For the low-stakes pile, light touch, move fast, this is where the productivity actually lives. For the high-stakes pile, build the verification in: automatic, repeatable, not dependent on someone remembering to look. The mistake is treating both piles the same. Verify everything equally and you've thrown away the speed. Verify nothing and you're trusting a system that sounds sure and isn't.
The uncomfortable truth underneath all of it: the verification is the work now. Not generating the output, the agent does that in seconds. Knowing which outputs to trust, and proving the rest, is the actual job. That was true on a test bench in 2000 and it's true for autonomous AI today. The tools changed. The discipline didn't.