Waking, asking, stopping
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.
The design
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.
- 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.
- Wake tools. Delete everything except the wake. A reminder is a schedule that signals the agent.
- Reminders move out. The agent's own reminders and watches became items in a separate planning service. The harness lost its watch tools.
- 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.