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.
Where this applies beyond internal tooling
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.
The habit that matters isn't more documentation, it's cheaper, more frequent verification of the documentation you already have, plus explicit "this is gone" markers instead of quiet omission.
If your team is handing AI systems access to internal docs and nobody's checked those docs against reality recently, that's worth doing before the AI is the one finding out the hard way.
Working on something like this? Tell us what you need or see the related service.
