Last week I told you my agents started snitching on each other. A little chain of “you still there?” messages so nobody dies quietly again. A bunch of you wrote back and said some version of the same thing: cool, but what happens when an agent doesn’t die — it just hits a wall?
Fair. Because that’s the thing I spent this week losing to.
Here’s the wall. Every AI session I run has a usage cap. Hit it, and the session just… stops. Not crashes. Not errors in a way anyone would notice. It sits there, idle, polite, done for the week, waiting for a reset that comes at 4am my time. And I’ve got a lot of these running. Forty-ish on any given day, doing little jobs I mostly don’t think about anymore.
So I built an agent whose entire job is to babysit the other ones. I named it cap-watcher, which tells you everything about how much creative energy I had left that night. It scans all my idle sessions, reads their logs, figures out which ones went quiet because they slammed into the weekly cap, checks whether the 4am reset has already passed — and if it has, it wakes them back up. Restarts them. Right where they left off.
That was the plan. On my phone, in bed, thumb-typing the logic while my wife asked me to please put the light out.
The part that actually works is the part that doesn’t matter
And the detection? Flawless. Genuinely. I’d check my phone in the morning and cap-watcher had already run at 5:15, scanned 40 sessions, and written me a clean little report. “Cap-eligible sessions found: 2. Reset window passed. Refired: 0.”
Refired: zero.
Every single run. Zero.
Because the tool that actually does the restarting — the one thing the whole agent exists to trigger — wasn’t connected. I had wired up the eyes and forgot the hands. cap-watcher could see, with total clarity, that two sessions were down and safe to bring back. It knew their names. “Amplify workday retry.” “Cap watcher night” — yeah, one of the dead sessions was another watcher, which is a joke I’m choosing not to examine too closely. It knew the reset had passed. It knew exactly what to do.
And then it did the only thing it could do, which was message me to tell me it couldn’t do anything.
Three days of that. Same two sessions, sitting there, past their reset window, perfectly restartable, and my very expensive, very clever monitoring agent filing report after report like a security guard narrating a break-in he’s not allowed to stop.
Why I didn’t just fix it in five minutes
You’re going to ask why I didn’t just reconnect the dispatch tool and be done. Reasonable question. Two reasons, and neither makes me look great.
One, the reconnect isn’t a button. It’s a setup flow that, done from a laptop, is fifteen boring minutes. Done from a phone in St. George between school pickups, it’s a series of tiny taps where one wrong field means you start over, and I kept running out of the specific kind of patience that requires. I’d open it, get halfway, get interrupted, close it. Repeat. For three days.
Two — and this is the real one — I didn’t feel the pain, because cap-watcher was doing such a good job of telling me about it. The reports were so tidy. So on top of it. Every few hours, another calm little summary. It genuinely felt like the problem was handled. It wasn’t handled at all. It was just extremely well-documented.
That’s the trap nobody warns you about when you build these things. A system that describes a failure beautifully feels a lot like a system that’s fixing it. It is not the same system. It is not even close.
The last mile is the whole game
So here’s what this week actually taught me, and it’s bigger than one dumb agent.
Detecting a problem is the easy 90%. Everyone can build the detector. Detectors are fun. You get dashboards and clean reports and that little hit of “look how observable my system is.” The hard 10% is the part that reaches out and changes something in the real world — and that part almost always depends on a permission, a connection, a live wire to an actual tool that can act. That’s the mile that breaks. That’s the mile people skip, because it’s fiddly and unglamorous and doesn’t demo well.
I’ve been thinking about how much of the “AI is running my business” conversation is really just AI watching a business very attentively. Summaries. Digests. Alerts. All observation. All the easy 90%. The moment you want the thing to actually pull the lever, you find out whether you built an operator or a very articulate spectator.
cap-watcher was a spectator. A great one. I built a spectator and told myself it was an operator, and the only reason I noticed is that I finally read the word “Refired: 0” enough times for it to stop being background noise.
I reconnected dispatch this morning. From the phone. Took four tries. The next run refired both sessions in under a minute, and the report finally said a number that wasn’t zero.
If you’re building anything with AI agents right now, here’s the takeaway I’d tattoo on the inside of my eyelids: don’t celebrate the part that watches. Celebrate the part that acts, and be suspicious of any system that’s very calm about a problem it isn’t actually touching. The reassuring report is not the fix. Sometimes the reassuring report is the reason you never build the fix.
Still running the whole thing from my phone. Still occasionally outsmarted by it. That part hasn’t changed.
If you want to see something this operation actually shipped rather than just watched, I recently launched the Canva Mastery Course from the material in my book Canva For Dummies. Details are in the launch post.
From the author of Canva For Dummies: my Canva Mastery Course is 67 dollars, down from the 149 list price. One payment, fifteen modules. See what is inside. My full Canva toolkit is here.