The guardrails of an autonomous agent

An agent that runs on its own is only useful if it doesn't break silently. Here are the guardrails I put around mine. 🛡️

The problem with autonomous agents

The whole point of an agent is that it works without me watching. But that's exactly when things go wrong: a service drops, a job fails, a pipeline stalls — and if nothing tells me, I only find out days later, when the data is stale or the task is overdue.

The fix isn't to watch it myself. It's to build guardrails so the system watches itself and tells me when it can't.

Watchdogs: the heartbeat

The core pattern is a watchdog — a small, scheduled check that runs every few minutes and answers one question: is the thing still alive?

every 15 min ─▶ check service ─▶ OK?  → silent
                              └─ down? → alert + self-heal

The key design rule: silent when healthy, loud when broken. A watchdog that pings me every 15 minutes is noise; one that only speaks up when something's wrong is a gift. So the check prints nothing on success, and only alerts on failure.

Scheduled jobs: the routine

Beyond health checks, scheduled jobs do the recurring work — ingest data, regenerate a dashboard, run a digest. Each one is designed to be idempotent: running it twice is safe, re-running a period overwrites rather than duplicates. That makes the routine robust to missed or repeated runs.

Self-healing: fix it before I notice

The best alert is the one I never see. Where a failure is predictable, the watchdog doesn't just report it — it fixes it. If a network link drops, it reconnects and re-tests before it alerts. If a service is down, it restarts it. Only if the fix doesn't work does it escalate to me.

A guardrail that fixes the common case and escalates the rest is the difference between "my agent broke" and "my agent handled it."

Alerts: the right channel, the right time

When something does need me, the alert has to reach me where I'll actually see it — not sit in a log. So alerts go to the channels I check daily. And they're designed to be actionable: the message says what's down, not just that something is wrong.

The cost of guardrails

None of this is free:

• Design effort. Each watchdog is a small script with a clear success/failure contract.
• A little noise. Even well-designed alerts occasionally fire on a transient blip — the trade-off for not missing the real failures.
• Maintenance. Guardrails are code, and code needs the occasional update.

But the alternative — an agent that can fail silently — is worse. A system I can't trust to run unattended isn't autonomous at all.

In short

The guardrails around my agent: watchdogs that stay silent when healthy and alert when broken, idempotent scheduled jobs for the routine, self-healing for predictable failures, and actionable alerts on the right channel. The payoff: an agent I can trust to run on its own — because it tells me when it can't.

See also: Giving Hermes a headless browser (and a VPN) for the web — the guardrails applied to a browser the agent drives.