My Bot Said Ready. The Room Was Empty.

On Friday night I hired a butler for my Discord, and he spent his first twelve hours announcing himself to an empty room.

His name is Wadsworth, after the butler in Clue. His job is simple and genuinely useful: I forward anything worth keeping into a private channel, and he files it — scored, tagged, with a link back to where it came from. He took maybe twenty minutes to build. He connected on the first try. He authenticated with a valid key. He wrote the word ready into his log, and then he heard nothing. Not for an hour. For a day.

Because nobody had invited him in. A bot on Discord can log in without belonging to a single server — perfectly authenticated, perfectly deaf. The log said ready because logging in was all that ready had ever been defined to mean. He was standing in the hallway of an empty house, announcing dinner.

1,203 restarts under a green light

I fixed the invitation. Then the sequel: a copy of the same butler on another machine was still carrying placeholder text where its password goes — the setup file literally said paste_the_token, and it had been started anyway. I had written the bot to exit with an error on unfixable problems like that, which sounds responsible. Except the babysitter process that keeps him alive treats an error exit as "restart him." My own comment in the config claimed it did the opposite. So the deliberate, responsible error exit was the exact thing ordering the relaunch. Every thirty seconds. 1,203 times in twelve hours.

And the whole time, the monitor said: running. Last exit, clean. Green.

Here is the sentence this weekend beat into me: a green light that means nothing and a red light that can't be turned off are the same defect. One trains you to trust nothing has failed. The other trains you to ignore alarms. Either way, the system has lost the ability to tell you the truth.

The audit found a haunted house

So we audited everything. All of it — every machine, every scheduled job, every bot, every app. What came back read like a home inspection on a haunted house.

Twenty background services running on my production Mac that existed in no document anywhere — names like ledger, mailroom, registrar — installed by hand months ago and remembered by no one. Ten small web apps living on exactly one disk, in no backup at all. A Salesforce mirror that had quietly frozen in May and that my overnight auditor had been reading as fresh every morning for three months, correctly citing every stale number. And my production Mac itself, introducing itself to the network under the name of a Windows tablet — which is why a security pass flagged my own server as a possible intruder in my own house.

Nothing was exactly broken. Everything was lying about what it was.

A rule marked applied is not a rule

My favorite find was in my own handbook. Weeks earlier I had written a rule — address machines by name, never by network address, because addresses rotate and names follow the machine — and marked it applied. It was never checked. Half the fleet was still on raw addresses, and the night a power outage rotated one of them, my off-site backups silently stopped for a week while every dashboard stayed green.

The rule was fine. The documentation was fine. What was missing was anything that ever asked whether the rule was actually true. A standing rule with no enforcement is a wish.

The preflight: prove it, then run

The fix was not a better dashboard, and it was not more documentation, which I now regard as the ambient temperature of good intentions. The fix was preflights — short, deliberately dumb scripts that refuse to start anything until its claims are proven. Is the key a real key and not placeholder text? Is the butler actually inside a room? Is there a server on the other end to file into? Does every machine name resolve, and does the backup target answer when called? Each check is one line of output. If anything fails, nothing starts, and the script says exactly what is missing and how to fix it.

Twenty seconds of curl. Every one of those checks answers a question that had already cost me a real evening. The night watch I built in July tells me when something dies. The preflights do something better: they make it hard for a thing to start in a state where it was always going to die.

The overnight auditor got the same religion. The first line of every report now proves which machine it woke up on — because it turns out my laptop travels, the mount follows the laptop, and an auditor reading the wrong machine's files will write you a confident report about a system that isn't there. And it is no longer allowed to write "no record anywhere" unless it lists every place it looked. Searching one file and reporting absence is how an honest empty result becomes a confident lie.

Three days later, it caught me

Here is the payoff, and the reason I trust the whole contraption more this week than last. On Monday I logged a number that needed writing in two places, and I finished one of them. Tuesday at five in the morning, the auditor cross-checked the file against itself, noticed the two fields disagreed, and flagged the half-finished write — with the commit that caused it — hours before the one meeting on my calendar where that exact number was the agenda.

That is the whole game. Not smarter AI. AI that is required to show receipts, pointed at its own work as ruthlessly as at mine.

The butler said ready from an empty room. Now nothing in this house gets to say ready until it proves someone is listening.

MG