Field notes · 2026-11-09 · RunVouch
Agents that check on agents: refusing to build on an unproven run (MCP)
How a morning agent verifies the nightly agent's run over MCP before it consumes the output, and refuses when the run is missing, failed or unproven.
For two years I ran a crypto trading bot and a handful of scheduled agents without anyone watching. The single worst class of bug was never one agent failing. It was the second agent happily building on what the first one did not do. The nightly job wrote nothing, or wrote half a file, and the morning job read whatever was there, drew conclusions, and sent them to me with full confidence.
RunVouch is a watchdog for unattended AI agents: a dead man's switch, a cost cap and an outcome check, with a status endpoint any agent can query before it trusts another agent's work. This article is about that last part, the agent-to-agent handshake over MCP.
Why multi-agent pipelines fail at the handoff, not in the model
The pattern I kept seeing has a name now. A Berkeley group analysed more than 1600 execution traces across seven multi-agent frameworks and sorted the failures into 14 modes in three categories. One of those three categories is task verification: agents that do not check whether the previous step actually produced what it was supposed to produce. The paper is Why Do Multi-Agent LLM Systems Fail? and it matches my logs better than I would like.
The failure is structural. A cron pipeline passes state through files, a database or a queue. The second agent sees a file and assumes a run. But a file proves only that something wrote to that path at some time. It does not say the run finished, that it finished without errors, that it cost what it normally costs, or that it ran tonight rather than three nights ago.
My concrete case: a nightly agent fetched market data, scored a list of pairs and wrote scores.json. A morning agent read that file and produced a trading plan. One night the fetch step hit a rate limit, the agent retried the same call until its budget ran out, and the process exited while the previous night's file was still on disk. The morning agent produced a careful plan from data that was 24 hours stale. Nothing in the pipeline could tell the difference between "ran" and "did not run".
How an agent can verify the previous run before consuming its output
The fix is a single question the consumer asks before it reads anything: did the producer finish a verified run since the last expected time, and is it in a healthy state? To make that answer available to an agent, RunVouch exposes a read-only MCP tool called runvouch_status. It returns, per watched agent, the state (ok, alert, failed, unproven, running, waiting), the time of the last run, the cost of the last 24 hours and any open alerts.
The server is listed in the official MCP registry as com.runvouch/runvouch, with the streamable HTTP endpoint at api.runvouch.com/mcp. The registry at modelcontextprotocol.io/registry holds only metadata, so you still authenticate against our endpoint with your own API key. In Claude Code, the MCP docs say that HTTP is the recommended transport for remote servers, and the form is one command:
claude mcp add --transport http runvouch https://api.runvouch.com/mcp \ --header "X-API-Key: rv_your_key"
Once the tool is visible, the morning agent's instructions become short and strict. This is the exact block I use in a Claude Code Routine:
Before reading scores.json, call runvouch_status. Find the agent named nightly-scorer. Proceed only if ALL of these hold: - state is "ok" - last_run is less than 10 hours old - open_alerts is empty Otherwise stop, write "BLOCKED: nightly-scorer not verified" with the reason, and do nothing else.
The nightly side needs to actually produce that status. It wraps its command with the client and names the file it must leave behind:
rv agent nightly-scorer --cadence 24h --cap-run-cost 2 --evidence rv run nightly-scorer --evidence-file scores.json -- python3 score.py
The client posts start and end, derives the evidence from the mtime and size of scores.json, and fails open: if RunVouch is unreachable, the scorer still runs. The states the morning agent sees come from the detectors. A missing run is MISSED. A non-zero exit is FAILED. An exit 0 with an untouched evidence file is NO_EVIDENCE, which is the exact case of my stale scores: the process said success, the file did not change. The same tool called with identical input eight or more times is RETRY_STORM, which would have caught the rate-limit loop long before the budget did.
If you do not want a client on the producer at all, each agent also gets a ping URL. The nightly job can call /ping/<token>/start at the top and /ping/<token> with its exit code at the end, from a shell script, an n8n HTTP node or a GitHub Actions step. The consumer still reads the result through MCP.
What refusing to build on an unproven run looks like in practice
The morning agent now has three outcomes instead of one. On a green night it reads the file and writes the plan. On a MISSED or FAILED night it writes a one-line blocked notice and exits. On an unproven night, where the scorer exited 0 but left no fresh evidence, it also blocks, because "unproven" is not "ok". In every blocked case I already have a Telegram alert from the nightly side, so the blocked notice is a confirmation, not the first signal.
Three things I learned running this for real.
- Make the consumer check the cost too. The status response carries the 24-hour cost. If the nightly agent spent four times its normal amount and still went green, I want the morning agent to say so rather than quietly consume output from a run that burned through retries. The cost cap handles the hard stop: a crossed cap pauses the agent and refuses the next
rv run. It never kills a process that is already running. - Check freshness, not just state. State "ok" plus a last run from two days ago means the scheduler itself is broken. The age check in the instructions above is not optional.
- Keep the refusal boring. The first version of my morning agent tried to repair the situation by re-running the scorer. That doubled the cost on bad nights and sometimes produced a plan from a half-finished rerun. A blocked notice and a stop is the right behaviour. Humans fix pipelines in the morning.
A nice side effect: the morning agent's own run is watched too. If it blocks, it still ends its run with status ok and the blocked notice as evidence, so I can see the difference between "the morning agent did not run" and "the morning agent correctly refused". Those are very different problems.
Writing the verify step into the agent's prompt is the smallest version of this. If you prefer code, the Python and Node clients expose the same status call, and the plugin for Claude Code reports tokens and cost from the transcript without any changes to the agent itself. Three agents are free, which covers a producer, a consumer and one spare. The server is MIT licensed if you want to self-host; the hosted version runs in the EU.
FAQ
Does the morning agent need its own RunVouch account or key? No. Both agents live under the same account. A read-only viewer key is enough for the consumer side, since it only calls runvouch_status, runvouch_alerts and runvouch_runs. Keep the key that can start and end runs on the producer.
What if RunVouch itself is down when the morning agent asks? The MCP call fails and the agent has no status. In my instructions that counts as not verified, so the agent blocks. You can choose the other default and proceed on a missing answer, but then you are back to trusting a file, and I would rather lose one morning plan than act on a stale one.
Can a non-LLM consumer do the same check? Yes. The status is plain JSON behind the same API key, so a shell script, a cron job or an n8n workflow can read it with one HTTP request and skip its work when the producer is not green. MCP is just the shape that lets an agent do it without custom code.
Related field notes
- My Claude Code cron ran up $1,800 in two nights. The watchdog that stops it at $2
- Claude Code Routine failed silently? How to know your scheduled agent actually ran
- The dead man's switch for AI agents (and why a ping isn't enough)
Try it: free for 3 agents · Docs: Claude Code · cron