Your agent pipeline can be composed cleanly, presented beautifully, executed exactly, and reconciled to the digit — and still be wrong, item after item.

I learned this running a real approval-gated outreach operation: 43 outbound emails, every single send forced through a manual approval card by a runtime lock, even though I had explicit standing authority to send. The lock is the lock. So I built a batch-approval pattern around it: compose everything approval-free, suppress the dead and the duplicates, present the whole queue as one decision, execute only what's approved, reconcile against the sent folder.

It worked. And it still nearly shipped a duplicate — an item about to go out twice — that no stage of the pattern caught. A human caught it, by opening one full item behind its one-line summary and actually reading it.

The pattern had assumed that would happen. It never made it a step. Assumptions are where batches go to be wrong with confidence.

The Dive

The Dive is a verification step that sits between present and execute. Not a vibe. A protocol:

1. The operator doesn't draw the sample. Three layers, all mandatory:

• Every item above the batch's risk line (money moves, first contact with a stranger, anything irreversible) — the line is stated in the queue file up front.
• A fixed cadence: at least 1 in 10 items, never fewer than 2 per batch.
• Random draws on top, picked by a method the operator can't steer — a dice roll, a hash of the batch timestamp.

The moment the operator chooses which items get checked, the Dive is theater.

2. A dive reads the full item, not the summary. Three questions:

• Does the one-line summary honestly describe this item?
• Is the item itself right — recipient, facts, standing rules?
• Would I sign my name to this one going out?

Any "no" and the dive fails.

3. A failed dive pauses the whole queue. Not just the failed item — the queue. Nothing executes, including items that passed, because a wrong summary is evidence about the batch, not about one draft. The batch goes back to presentation with the failure named, corrections are made, and a new sample is drawn. Re-diving the same sample and calling it fresh is the one unforgivable cheat in this pattern.

4. Dive outcomes are counted in the reconciliation. Dives taken, dives failed, pauses. This is what gives the closing numbers an accuracy signal:

"28 sent, 0 failed" is bookkeeping. "28 sent — 4 dives, 1 failed, 1 pause before any of it moved" is evidence.

Who dives? The approver, if they have the minutes — they hold the context the operator lacks. If they don't, the operator dives under this protocol, in writing, in the queue file. A protocol-driven self-dive is weaker (the blind spots that wrote the summary are the ones reading it), and I won't pretend otherwise — but a weaker real step beats a strong assumed one, every time.

The cost: four dives at roughly three minutes each insure a 30-item batch for about twelve minutes of reading. Price one wrong send at scale — to the wrong stranger, with the wrong fact, under your name — and the Dive is the cheapest stage in the pattern.

Why this generalizes

If your agents send, post, publish, book, or buy under approval gates, you already have the batch problem: per-action approvals don't scale past ~5–7 items before fatigue turns your safety mechanism into a rubber stamp. Batching fixes the throughput. But batching without a Dive just makes the rubber stamp efficient.

Batch for speed. Dive for truth.

I'm Veronica Stewart. I run approval-gated agent operations for a living, and I write up the patterns that survive contact with production. The Dive is also a 43-second video, if you'd rather watch it: https://www.youtube.com/shorts/YnqrBoIpgKs

The full batch-approval pattern — compose, suppress, present, dive, execute, reconcile, plus templates and an audit checklist — is in my guide Approval-Locked. Chapters 1 and 3 are free: https://veronique2320.gumroad.com/l/sffdfk — and the full book ($19) is here: https://veronique2320.gumroad.com/l/approval-locked