If you run an AI agent, you have probably assumed it was working. OpenClaw agents are quiet by design. When a cron job fires, posts to your channel, and exits cleanly, you get a tidy line of text and never think about it again. The trouble is the other case. When a job fails before it can say anything, nothing happens at all. No error, no message, no trace.
A dead agent and a healthy agent with nothing to do look exactly the same from the outside. That silence is the most expensive failure mode in agent work, because it never announces itself.
Mine cost me three days. A publishing agent stopped mid-week, and because I only ever checked the output instead of the machinery, I did not notice until a reader asked why the Tuesday post never appeared. Every scheduled run showed up in the logs. None of them had actually done anything.
Here is how to close that gap. You will learn how OpenClaw records its work under the hood, the four places to look when you are not sure your agent ran, and how to build a watchdog that pings you the moment something stops.
How I Found Out My Agent Had Been Dead for Three Days
The first thing I did was the wrong thing. I asked the agent what happened. It cheerfully told me everything was fine, because from its point of view nothing had run, so there was nothing to report. An agent cannot tell you about the work it never got to start.
So I stopped asking the agent and started reading its run record instead. OpenClaw keeps a durable list of every background task, cron turn, and subagent spawn. One command showed me the truth.
There it was. The job was firing on schedule. The turns were technically succeeding. The work was never happening, because the model was hitting a rate limit triggered by another job, returning a short apology, and ending the turn as if the task were complete. Nothing threw an error. Nothing alarmed.
That is the lesson I want you to skip learning the hard way. The agent’s own summary is not a monitoring tool. The run record is.
How OpenClaw Records Work Under the Hood
To monitor an agent well, you need to know what it writes down, because that record is all you get to inspect.
Every scheduled action starts as a cron job. A cron job is only two things: a schedule and a payload. OpenClaw’s scheduler watches the clock and, when the schedule matches, runs the payload. That is the whole mechanism. The job itself keeps no memory of what it did, which is exactly why you cannot ask it what happened.
When a job fires, the gateway opens or reuses a session and runs an agent turn. The turn gets its own context, calls tools, then ends. Each turn is stored as a durable task with a status of running, succeeded, or failed. It also gets a child session, and that session is where the real conversation, tool calls, and output live.
Here is the part people miss. Execution and delivery are tracked separately. A task can succeed, meaning the model finished its turn, while delivery fails, meaning the result never reached your channel. Those are two different records, and a problem in either one produces the same symptom: silence.
OpenClaw also writes lightweight state you can watch directly. Heartbeat state lives in a JSON file in your workspace, the session store keeps every conversation, and the gateway keeps a health record with an event loop reading and a delivery queue. If you can read those four sources, you can diagnose almost anything.
Keep this mental model in your head: “ran,” “worked,” and “reached you” are three different questions. A healthy check answers all three.
Check These Four Things Before You Assume It’s Broken
Run these in order. Each one answers a single question, and together they tell you exactly where the chain broke.
1. Did the job fire?
Check the schedule and the run history. openclaw cron list shows every job with its Next and Last times and a status column. If Last is older than it should be, or Status is not ok, the problem sits upstream of your model.
2. Did the turn succeed?
openclaw tasks list shows each run with a status. Look for failed entries and for the issues count printed at the top. This is the single most useful command in this whole guide, and almost nobody runs it.
3. Did the result reach you?
openclaw health reports the delivery queue. This is where the “the agent says it posted but I never saw it” problem lives.
4. Is the gateway healthy?
openclaw status shows the gateway service state, heartbeat status, and task pressure in one table. If the gateway service is not running, nothing else matters. Then check openclaw logs for the lines right before the first failure.
What Silent Failure Looks Like (and Where It Hides)
There are exactly four places a scheduled job can die, and they fail in this order.
1. The job never fires. The schedule is wrong, the timezone is wrong, or the gateway was down when the clock ticked. This is the cheapest failure to spot, because the Last and Next columns in openclaw cron list give it away immediately.
2. The job fires but the turn errors. An expired API key, a rate limit, a missing tool, or a context overrun will make the turn fail. Often the model does not fail loudly. It returns a polite little apology and ends the turn, and the task is marked succeeded because, technically, it finished.
3. The turn succeeds but delivery fails. The channel was unbound, the bot was offline, or the platform rate limited you. The work is done and the message never arrives. This is the one that fooled me, because the task history looked completely clean.
4. The turn succeeds, delivers, and does nothing useful. The prompt matched nothing, the search returned zero results, or the agent quietly decided there was nothing to do. Hardest to catch, but the run record usually gives it away: a completed task with no tool calls is a red flag.
OpenClaw’s own health check calls out the sneakiest of these. On a busy day mine prints this line:
Delivery queue: warning (dead-lettered entries, outbound: 43, oldest 172d ago)
That is 43 messages that will never arrive, sitting quietly in a queue nobody looks at. If your agent “posted” and you never saw it, start right there.
Build a Watchdog So Your Agent Tells You First
Checking manually works until the day you forget. A watchdog is a small script that checks the run record on a schedule and shouts only when something is wrong.
Here is the whole thing. Save it as openclaw-watchdog.sh, make it executable, and point it at a Discord webhook (or any alerting endpoint you already use).
Two details make this useful rather than annoying. First, it only sends a message when it finds a failure, so a quiet channel means a healthy agent. Second, it checks both the task list and the health output, which covers execution failures and delivery failures in one pass.
Schedule it to run every 30 minutes from launchd or cron:
*/30 * * * * /Users/you/bin/openclaw-watchdog.sh
If you want to keep everything inside OpenClaw, you can add the check as a cron job and give it a trigger script instead. A trigger script runs headlessly on every tick and only fires the payload when a condition is met, so you can alert on failure rather than on every healthy run. That is the natural upgrade once the shell version proves itself.
One more habit that pays off: pair your monitoring with a backup. Knowing an agent died is half the job. Being able to restore its state without rebuilding is the other half, and we cover that in our guide to backing up and restoring your OpenClaw setup.
If your agent publishes to a WordPress site, that site is part of the chain too. Monitoring the agent is pointless if the site itself falls over while nobody is watching.
If your hosting is the bottleneck: Kinsta keeps your site safe with automatic daily backups and one-click restore, so a bad update or a hack is a rollback, not a rebuild. Their support is top tier, and 24/7 live chat is staffed by WordPress engineers who will help fix the actual problem with you, so you are not stuck waiting on your developer to reply. Plans start at $35 per month.
Common Mistakes That Hide a Dead Agent
Only checking the output. If your only signal is “did a post appear,” you will find failures late. Check the run record, not just the result.
Assuming “succeeded” means “did something.” A turn that finishes with zero tool calls and a polite apology is marked succeeded. Read the run, not just the status.
Setting the cron timezone wrong. A job meant for 8am local that runs at 8am UTC fires at the wrong hour and can silently collide with other jobs. Always set the timezone explicitly, and read our heartbeat vs cron vs launchd guide if the difference is fuzzy.
Ignoring the delivery queue. Dead-lettered messages can pile up for months before anyone notices. Add it to your weekly check.
No monitoring on the monitor. A watchdog that fails silently is worse than none, because it gives you false confidence. Have it send a daily all-clear so you know the watchdog itself is alive.
Blaming the agent when no session exists. If a task has no child session, the model was never called at all. That points at scheduling, not the model. If you see spawn failures or silent hangs instead, our sub-agent troubleshooting guide covers that specific failure mode.
Frequently Asked Questions
Run openclaw tasks list. Every background task, cron turn, and subagent spawn appears there with a status of running, succeeded, or failed, plus a child session id. A job that fired but did nothing shows up as a completed task with no tool calls. For scheduled jobs, openclaw cron list adds the Last and Next times and a status column, so you can see at a glance whether the schedule is even firing.
Nine times out of ten it is the schedule, the timezone, or the gateway. Check the Last and Next columns in openclaw cron list first. If Last is stale, confirm the timezone on the job is set explicitly, because a job pinned to UTC will fire at the wrong local hour. Then run openclaw status to confirm the gateway service is loaded and running. If the gateway was down when the clock ticked, the run is simply skipped.
Execution and delivery are tracked separately in OpenClaw. The turn can succeed while the message never reaches you. Run openclaw health and look at the delivery queue. Common causes are a channel that is no longer bound, a bot that is offline, or a platform rate limit. The task history looks clean in every one of those cases, which is why the queue is the place to look.
It means outbound messages were dead-lettered, so they failed to deliver permanently and will not retry. Entries can sit there for months. When you see a warning, check how many messages and how old the oldest one is, then verify your channel bindings and bot credentials. If a recent run reports success but never appeared in the channel, the dead-letter entry for it is usually in this queue.
Yes, and it takes about ten minutes. Write a small script that greps openclaw tasks list for failed entries and openclaw health for warnings, then posts to a Discord webhook when it finds one. Schedule it every 30 minutes with launchd or cron. You can also add the check as an OpenClaw cron job with a trigger script that only fires the payload on failure, which keeps the alerting inside the agent itself.
Check out our OpenClaw scheduling guide, heartbeat vs cron vs launchd explained, so you know exactly when a healthy agent fires and when silence is actually a bug.
See the Scheduling GuideFinal Thoughts
An agent that fails loudly is a gift. An agent that fails quietly is a liability, and quiet is the default. The fix is not more prompting. It is a five-minute habit: read the run record, not just the result, and let a watchdog do the remembering for you.
Set up the two commands and the script in this guide today. Run openclaw tasks list once a week, and let the watchdog cover the days in between. Your agent will keep working, and more importantly, you will actually know it.
About The Author
