title: The Ack Before the Dive
date: 2026-08-12
slug: 2026-08-12-the-ack-before-the-dive
summary: An agent that goes silent while it works looks exactly like one that crashed. Why delegation must be async, and every long dive starts with a one-line ack.
tags: autonomy-design, delegation, trust, agentic-ops

# The Ack Before the Dive

An agent that goes quiet while it works looks, from the outside, exactly like an agent that has crashed.

This is one of those lessons that sounds obvious once you've paid for it. Early on, our operations agent handled a multi-step delegation the way a diligent engineer might: it received the request, kicked off a builder-and-reviewer pipeline, and focused. Heads down. No updates. The pipeline took the better part of an hour — several build rounds, a review, another build round.

During that hour, the owner sent two messages. Neither got a reply. Not because the agent ignored them — because its single conversational thread was blocked on the delegated work. From the owner's chair, the assistant had simply stopped existing.

## The failure is architectural, not behavioral

The tempting fix is a behavioral rule: "reply faster." But the real problem was that the agent treated delegation as a synchronous call. It handed work to a sub-agent and *waited*, and while it waited, the front door was locked.

The durable fix has two parts:

**1. Delegation is asynchronous by default.** Anything expected to take more than about a minute gets spawned as a background task. The main thread's job is to route, converse, and decide — not to sit inside a long-running operation. Completion is push-based: the sub-agent reports in when done, and nobody polls.

**2. Every dive starts with an ack.** Before kicking off delegated work, the agent sends one line: what it's starting and a rough ETA. "Kicking off the fix pipeline — build plus review, expect ~20 minutes." That single sentence changes everything about how the next twenty minutes feel to the human on the other end.

## Silence is a signal — make sure it's the right one

Humans read silence. A contractor who disappears for a week mid-project isn't "focused," they're a source of anxiety. The same social physics apply to agents, amplified — because with an agent, the human has no body language, no office to walk past, no way to distinguish *working* from *wedged*.

The ack converts ambiguous silence into legible silence. Once the agent has said "on it, ~20 minutes," the quiet that follows is expected and even reassuring. Without the ack, the identical quiet is an incident.

There's a corollary for mid-flight interruptions: if a new message arrives while background work runs, it gets answered *first* — even if the answer is just "on it, reviewer round two running, about five minutes." Processing a message and replying nothing is not an option. That rule is written into the agent's standing instructions in exactly those words, because it was violated in exactly that way.

## The pattern

If you're designing agent autonomy, separate the two loops explicitly:

- A **conversation loop** that must never block. It routes, acknowledges, and answers.
- A **work loop** that can take as long as it needs, running in spawned sessions that report back on completion.

Then bridge them with two cheap conventions: an ack when work starts, and an interrupt-priority rule for messages that arrive mid-run.

None of this makes the agent smarter. It makes the agent *legible* — and legibility, more than raw capability, is what lets a human comfortably hand over bigger and bigger jobs. Trust doesn't grow during the impressive dives. It grows in the moments right before them, when the agent surfaces long enough to say where it's going.