The reference file from a system that no longer existed
We build tools internally that use AI agents to do real work: research, drafting, small builds. One of those tools reads a reference file to learn what our own systems look like before it starts a task.
The file was accurate when it was written. Since then, we'd rebuilt the stack twice. The file still described the old one: a database we'd migrated off, a workflow tool we'd replaced, a command-line process nobody ran anymore.
Nothing crashed. The agent read the stale file, believed it, and quietly built on top of assumptions that hadn't been true for months.
A human skims past a stale doc. An agent doesn't.
If a person opens an outdated internal doc, they usually catch it fast. Something looks off, they ask around, they move on. Staleness gets caught because a human brings outside context to the reading.
An AI agent doesn't have that instinct. It reads the doc as ground truth, in confident present tense, and acts on it. It doesn't know the doc is three systems out of date, because nothing in the doc itself says so.
That's the actual risk. Not that the AI is wrong, but that it's confidently right about something that stopped being true a while ago, and there's no error message to catch it.
Three rebuilds, three generations of confident prose
Our own stack had gone through three real architecture changes in under a year. Each change left behind docs that were accurate for their era and never got touched again. Nobody deleted them because deleting a doc feels riskier than leaving a possibly-stale one sitting there.
That instinct is backwards for anything an AI system reads. A stale doc sitting untouched isn't neutral, it's live ammunition. The next task that happens to touch that file inherits every wrong assumption in it, and inherits it silently.
The fix wasn't just updating the content. It was checking every specific claim in the doc against what's actually running today, one by one, before rewriting a word.
Name what's dead, not just what's current
The part that made the difference wasn't the update itself, it was adding an explicit section naming what used to be true and no longer is. Not just the current state, but a direct "this is deprecated, don't reference it" list.
That's an unusual thing to put in a normal document written for people. People rarely need to be told twice that something is gone. AI agents do, because they might encounter the old name in some other file and need an authoritative signal that it's dead, not just its absence from the current version.
In practice: current state up top, a short deprecated list below it, and a habit of re-verifying the doc against the live system before trusting it for anything that matters.
What we run now, and what we'll set up for you
We fixed our own exposure with a standing rule: every doc an agent reads gets a current-state section and a named deprecated list, re-verified against the live system on a schedule, not left to go stale between rebuilds.
Any business running AI on top of its own documentation, its own process guides, its own knowledge base, has this exposure. A pricing sheet an AI reads to answer customer questions. A process doc an AI reads before touching a client account. If the source is stale, the AI won't hesitate the way a person would.
This is standard practice on every AI-driven system we build now. If your team is handing AI systems access to internal docs and nobody's checked those docs against reality recently, talk to BEIRUX and we'll audit it before the AI finds out the hard way.
Working on something like this? Tell us what you need or see the related service.
