You’ve used an AI assistant. You type, it answers, you type again. It’s a conversation, and like every conversation, it only exists while you’re in it. Look away, close the tab, go to lunch — and it stops mid-sentence, waiting for you to come back. It can’t do anything while you’re gone. It can only wait.
Now picture the opposite. You hand a task to something, and it goes off and works on it — for ten minutes, for an hour, every fifteen minutes around the clock — whether or not you’re watching. It takes shifts. It rests when there’s nothing to do. And when it hits a decision it shouldn’t make alone, it stops and asks you, then waits patiently until you answer. That’s not a chatbot anymore. That’s a worker.
This lesson is about the gap between those two things, and how an agent crosses it.
the moment the conversation has to outlive you
Here’s where the friendly chat model falls apart. You ask for something real — audit this whole project, rewrite a folder, work through a long plan — and it takes ten minutes. But a conversation is built to answer in seconds. Hold a connection open for ten straight minutes and something will give: a timeout, a dropped signal, a laptop lid closing. The work that takes real time has nowhere to live inside a back-and-forth.
The trick that makes an agent persistent is almost embarrassingly simple to describe: the request and the work are split apart. When you start a run, you get an answer back immediately — not the result, just a receipt. A little ticket that says “accepted, working on it,” along with a name for the run. That receipt comes back in milliseconds, before the agent has done a single thing. You’re free to walk away the instant you have it.
The work, meanwhile, goes on living somewhere else entirely — in its own little process, watched over by a supervisor, grinding through the task for as long as it takes. You hung up. It didn’t.
This is the difference between standing over someone until they finish answering, and leaving them a note with your number on it. The note frees you both. They work; you go do something else; you check back when it suits you.
the receptionist and the worker
So who, exactly, is keeping the work alive after you’ve gone? This is the cleverest part, and it’s worth slowing down for.
A persistent run is really two things, not one. There’s a receptionist and there’s a worker, and they have completely different jobs.
The worker does the slow, heavy labor — calling the model, running tools, thinking, writing. It might be ten seconds deep into something when you check in. The receptionist does none of that. Its entire job is to stay reachable. It remembers the run’s name, keeps a running list of everything the worker has done so far, and answers the door instantly when anyone knocks: What’s the status? Are you done? Show me what’s happened.
Because those two roles are separate, you never have to wait on the slow part to find out how things are going. You knock, the receptionist answers — immediately, every time — even while the worker is buried in the hardest step of the job. The thing you can talk to is never the thing that’s busy.
And every run has a name. When you started it, you got that name back on the receipt. Hand that name to anyone, from anywhere, and they can ask after the run and get an honest answer. The work became addressable — it stopped being a fleeting conversation and became a thing in the world with a name you can point at.
standing watch, and taking shifts
Everything so far describes a run you start — you ask, it works, it finishes. But the deeper kind of persistence is the agent that nobody has to start at all. It’s already there, standing watch.
These are standing agents, and they’re born not from a request but from a quiet declaration: a small file that says here are my workers, and here’s how often each one should wake up. One agent ticks every ten minutes. Another, every hour. They come to life when the system boots and they keep their own time forever after.
The beautiful part is what’s inside them: exactly the same engine as the run you started by hand. There aren’t two kinds of agent, a fancy one and a plain one. There’s one engine, and two front doors into it — one for “do this thing now,” one for “do your thing on a schedule.” The agent that wakes up every fifteen minutes is doing the very same work, the very same way, as the one you poked manually. A run that’s correct once is correct every time, because it’s always the same run.
And when several of these stand watch together — a researcher, a writer, an editor, each on its own beat — they don’t trample each other. A gentle limit keeps them from all reaching for the model in the same instant, the way a kitchen with two stoves can only cook two dishes at once no matter how many cooks show up. When one finishes, the next in line gets the burner. Nobody starves; nobody piles on.
resting when there’s nothing to do
A worker that never rests is a worker that costs a fortune. If a standing agent woke up every fifteen minutes, called the model, discovered there was nothing to do, and went back to sleep — forever — you’d be paying, over and over, just to be told nothing.
So persistent agents learn to rest. The rule is blunt and honest: when an agent wakes, looks around, and genuinely has no work, it says so out loud — it ends its run by plainly admitting no work. And the system listens. After an idle wake-up, it waits a little longer before the next one. Idle again? Longer still. The gaps stretch — a minute, two, four, eight — until a busy agent that was checking eighty times an hour quiets itself down to checking twice.
Then the moment there’s real work again, it snaps awake. One good run wipes the slumber away and puts the agent right back on its quick, attentive rhythm. It sleeps deeper the longer the world is quiet, and wakes fully the instant the world needs it. Doing nothing, it turns out, is the one thing it learns to do cheaply.
There’s a second kind of rest, too — a deliberate quiet beat built into the agent’s day, a pause for consolidating rather than charging ahead. A good day for an agent isn’t all motion. It has a shape: stretches of adding work, a beat to review it, and a quiet space in between.
the run that knows when to ask
The last piece is the most important, and it’s where persistence stays honest. An agent that works on its own is not an agent that decides everything on its own.
Because a run knows its own name, it can do something quietly profound: it can stop in the middle of its work and open a door back to itself — a place where a human can drop a decision. Then it simply waits. It doesn’t guess; it doesn’t barrel ahead on something it shouldn’t choose alone. It pauses, hands you the question, and holds its place until your answer arrives. When you decide, the decision travels back into the run by its name, and the work picks up exactly where it left off.
This is the line that keeps the whole idea trustworthy. A persistent agent isn’t a thing that runs away from you. It’s a worker that takes the long shifts you can’t sit through, rests when the work runs dry, keeps a name you can always call, and knows the difference between the calls it can make and the ones that are yours. The judgment never leaves the room. It just learns to wait for you — patiently, by name — instead of needing you in the chair the whole time.