Yesterday, our meeting summary enricher tried to refresh its Google auth token and hit a wall. Again. The AI that processes meeting notes is brilliant at extracting insights and action items, but it can’t negotiate with Google’s API when something goes sideways with OAuth.

This is the last mile of automation — the gap between “it works in the demo” and “it works when nobody’s watching.”

We talk a lot about autonomous business systems at Glassboks. The vision is compelling: continuous experimentation, fast feedback loops, systems that learn faster than humans can coordinate. No campaign cycles, no status meetings, just compounding learning. It’s not theoretical — we’re building it.

But here’s what the manifesto doesn’t mention: most of your time gets spent on the boring stuff. Auth token refresh logic. Rate limit handling. Graceful degradation when third-party APIs decide to take a nap. Error recovery that doesn’t spam your Slack channels.

The AI can write brilliant analysis of your sales pipeline, but it can’t debug why Linear’s webhook suddenly started returning 403s. It can generate insightful content about market positioning, but it needs you to manually re-authenticate with Google Drive when the token expires at 3 AM.

This isn’t a critique — it’s reality. Building reliable automation means building around unreliable dependencies. Every service you integrate is a potential failure point. Every API has its quirks. Every auth flow has edge cases that somebody forgot to document.

The irony is that the more autonomous your system becomes, the more important these mundane reliability patterns become. When a human is running the show, they can work around a broken integration. When an AI agent is handling it, that workaround needs to be encoded in advance.

I’ve been thinking about this as the “reliability tax” of automation. For every hour of brilliant AI reasoning, you need three hours of error handling, monitoring, and defensive programming. For every elegant autonomous workflow, you need a dozen unglamorous fallback mechanisms.

The payoff is real, though. When you get it right — when the error handling is solid and the monitoring catches issues before they cascade — the system really does run without you. Insights get generated, decisions get made, work gets done. You wake up to a day’s worth of intelligent action having happened while you slept.

But getting there requires embracing the paradox: building autonomous systems is deeply manual work. You’re not just programming the intelligence; you’re programming all the ways intelligence can fail, and what to do about each one.

Yesterday’s auth failure got fixed with a five-minute token refresh. But the real fix is the monitoring we’re building to catch these failures before they accumulate. Because true automation isn’t about removing humans from the loop — it’s about removing humans from the boring loops, so they can focus on the loops that actually matter.

The last mile of automation is paved with exception handlers. And that’s exactly as it should be.