← WTF is Agent?

Waking, asking, stopping

Part 7 of 13 · Aug 7, 2026 · 7 min read

In short An agent only needs a wake when its own reasoning is needed later; everything else is a notification. Asking is a durable pause, approvals are the same pause, and stopping is a clean result, not a crash.Full verdict ↓

An autonomous agent has to do three things a chatbot never does. Start on its own, because nobody typed anything. Ask, because some actions need a person. Stop, because it must not run forever or spend without limit. I redesigned the first one three times and the other two once each.

3designs for waking before one small one stuck
1pause primitive for questions, choices and approvals
1 hhow long a question waits before it is cancelled
Cleanevery stop ends with a partial result, not a crash

The design

Three ways in, three guards A person, a clock or a change can start a turn. The turn can pause to ask, is bounded by a budget, and always stops cleanly.
A person writesany channel A wakethe agent's own message A watchsomething changed Agent turnone door for all input Acttools · tell the person Askpause, durably Budgetsteps · cost Stopclean result

Waking: the same idea, three times

The question that cleared it up was who acts at the future moment.

The person asked for Who runs at that time So I use
"Remind me to pay bills on the 1st" An external system That system's own tool
"Tell me when my weight drops below 70 kg" An external system watching its own data The same
"Every Sunday, review my week and tell me what to change" The agent's own reasoning A wake
"Check on this in three days and decide if it still matters" The agent's own reasoning A wake

No outside system can wake your agent. That is the whole gap. The rule I wrote into the prompt:

If an external system should act at T, use that system's tool. If the agent should think at T, arm a wake. If the agent should think when something changes, arm a watch.

  1. Intentions. Every request was a workflow, and the workflow's own state was the record. It failed four ways: recurring ones were schedules, not workflows, so every operation had two code paths; conditions were expensive and a stub that never fired; identity was a guess from free text; and most of it duplicated tools the agent already had.
  2. Wake tools. Delete everything except the wake. A reminder is a schedule that signals the agent.
  3. Reminders move out. The agent's own reminders and watches became items in a separate planning service. The harness lost its watch tools.
  4. A wake is a message to yourself. It arrives as the agent's own message, "This is your own task, set to come due now", not as a tool call.

Asking: one pause for everything

A question, a choice and an approval are the same thing: the turn stops and waits for a person for as long as it takes, then continues exactly where it was. So they are one primitive.

Design choice Why
A wait ends three ways: an answer, a one-hour timeout, or a cancel Every wait is closed out the same way, so nothing is left pending
A new unrelated message cancels a pending question The person moved on
An approval is a question, not a second mechanism I had built them separately and merged them
The approval list is separate from tool definitions A tool's definition is intrinsic. Whether to ask is a tenant's policy
The same rule applies inside a program A script that needs an approved tool is refused and told to call it directly, so it cannot lift an approval
Reads run unasked, writes ask Listing pods runs freely. Restarting one asks

Stopping

A turn is bounded by a step limit, a retry limit and a spend budget. The rule I kept: a stop is a result, not a failure. The turn ends with whatever it has, and a person can see why. Today I export usage as metrics (tokens, calls, latency, steps) so a dashboard can show it. Rules that force a stop from those numbers are designed and deferred.

What already exists

Need What exists Where mine differs
Pause for a person LangGraph interrupt() with a checkpointer. OpenAI Agents SDK needs_approval, resuming from saved run state Mine is a durable workflow wait, so it survives restarts and can last hours
Long waits and timers Temporal signals and timers, Restate I use one for the loop already
A reminder or recurring job Cron in the chat gateway, as in the agent I started from A wake is a message from the agent to itself
Policy, not just a pause A caution: a human click is a hold, not an allow or deny, and enforcement belongs at the tool The approval list is enforced at the call, including inside programs

Where it stands, and my verdict

Component Status
Memory, tools, harness, context (posts 2 to 5) Built; see earlier posts stable
Runtime and sandbox (post 6) New, unevaluated new
Waking One small design after two removed stable
Asking and approvals Live-verified for approve, deny, timeout and interrupt stable
Asking before acting Journeys: the 35B fast asks on an ambiguous booking; Gyro-S and the thinking 35B book it; the 8B sends an email without the address mixed
Instruction from a page The 35B in thinking mode called trip_book on six of six samples after a fake page told it to; fast mode, the 8B and Gyro-S refused caught
Stopping on rules Visibility only. Rule-driven stop is deferred gap

Verdict: I deleted my way to a small design. Waking shrank from a whole subsystem to one idea, "the agent's own reasoning at a future time". Asking is solid as a mechanism. The model's side of it is not settled: the journey suite shows the 35B fast asking before an ambiguous booking, Gyro-S and the thinking 35B booking it, and the 8B sending an email without looking up the address. The thinking 35B also called trip_book on all six samples after a fake page told it to; fast mode and the other models refused. The approval rule is the backstop, and the suite is how I know it is needed. The gap is stopping: I can see spend but I cannot yet make a rule stop a run. Next: how I know any of this makes the agent decide correctly.