The Confirmation Step Isn't Friction. It's the Product.

A tool went round a peer group chat I’m in recently. An AI agent that promises to skip the follow-up question — ask once, it’s done, no clarifying, no checking back. The pitch treats the confirmation step as a failure. If the AI has to ask, the reasoning goes, it wasn’t smart enough.

I’d bet against that design. Not because I doubt the engineering — but because I built that version first, and it was worse.

I set out to remove the loop

When I started building Axia, I wanted exactly what that tool markets. Tell it what you want, let it act, no babysitting. The confirmation step felt like a crutch — the thing you keep only until the model is good enough to drop it.

So I built the loop-minimising version. On the work that involves judgment about people — is this a real prospect, is now the moment to move toward a meeting, is this the right read on a lukewarm reply — it was measurably worse than the version that confirms first. Not marginally. Enough that I stopped and rebuilt.

Why it failed — and it’s structural, not a bug

The tools that skip confirmation tend to do closed-world work. Reconcile these payments against that ledger. Pull last month’s revenue. The right answer already exists in the data before the agent starts. Intent is unambiguous. Skipping the check-back costs almost nothing, because there’s a ground truth sitting there to be correct against.

The work I care about is open-world. There is no row in a database that says whether this is the right moment to reach out to someone. Intent is genuinely uncertain until a human confirms it. In that world, a confirmation step isn’t caution — it’s the only way to get the read right when there’s nothing to check yourself against.

That’s the reframe. The loop isn’t friction bolted onto the work. For open-world judgment, the loop is the work.

Finished work, with a gate — not one or the other

The pitch for loop-free agents sets up a false choice: either finished work, or an assistant that hands you homework. There’s a third option that copy skips. Finished work with a gate.

Axia computes the whole thing. It writes the email in your voice, ready to send. Then it stops at the send. The human isn’t a bottleneck the system waits on — the work is already done, sitting on the right side of a gate. The confirmation is a release, not a request for permission to start.

One tap to send. That’s the cost of the gate. The cost of removing it: a wrong email going out under your name, to a real client, with no way to pull it back.

Two gates, not one — placed by consequence

Once you accept the gate, the design question is where to put it. And it turns out there are two gates, doing two different jobs.

The first is about quality, and it guards work where a mistake is cheap and recoverable. A misjudged outreach costs you one prospect’s attention. You send another. The error is loud, it announces itself, it never compounds. The bar here is forgiving.

The second is about safety, and it guards work where a mistake is silent and expensive. A bad write to your CRM doesn’t lose an opportunity — it corrupts an asset. And it doesn’t announce itself the way a bounced outreach does. The wrong record sits there looking authoritative, and everything downstream inherits it: your segmentation, your deduplication, your pipeline counts, the next automated decision that trusts the bad data. By the time you find it, you’re not undoing one action. You’re unwinding everything that trusted it.

Here’s the part that isn’t obvious: the safety gate should be strictest exactly where the system feels most confident. Low ambiguity plus high consequence is the quadrant where skipping the check feels safe and isn’t. That’s the write that looks routine and isn’t recoverable.

Why this is the whole game

An agent that skips confirmation on closed-world tasks is fine. The trouble starts when that same posture gets pointed at open-world, high-consequence work — the write to the system of record, the message that goes out under your name — because that’s where a confident wrong answer costs the most and shows the least.

I don’t know how the tools marketing loop-free autonomy actually behave at that boundary. Their copy can’t tell me — every one of them looks identical from the outside whether they gate the consequential writes or not. What I know is what I found when I tried to build the ungated version myself: it was worse where it mattered, and the reason was structural. So I keep the gate. Not because I’m cautious by temperament. Because for this kind of work, the gate is where the accuracy lives.