An agent quoted a customer last quarter’s pricing for six weeks before anyone noticed. The pricing sheet it was grounded in had been updated in the shared drive — a new version, correctly named, sitting one folder over. Nobody had told the agent’s knowledge source about it. The agent wasn’t wrong about what the document said. The document was wrong about what was true.
This is the failure mode that doesn’t show up in a demo. A demo runs on the document as it existed the day someone ingested it. Production runs for months, and the business underneath the document keeps changing.
The ingestion step isn’t the whole job
Most AI agent projects treat “grounding” as a one-time task: pull the pricing sheet, the approval matrix, the policy doc into a vector store or a retrieval index, test a few queries, ship it. The agent answers confidently because retrieval-augmented generation is designed to produce confident answers from whatever it’s given. It has no mechanism for knowing the source is six months old.
Nothing about the failure is loud. The agent doesn’t error out or hedge. It cites the document, which is exactly what it’s supposed to do — the document is just wrong now. A discount tier that got tightened in a Q2 finance review still gets offered in Q3. An approval matrix that moved a $50,000 threshold down to $10,000 after a budget review still lets the agent wave through requests at the old ceiling. The agent isn’t malfunctioning. It’s doing exactly what it was built to do, with an input nobody maintained.
The worse version of this is when the stale answer looks more authoritative than a human’s, because it comes with a citation. A rep who half-remembers the old pricing at least says “let me check.” An agent that quotes the wrong document says it with a straight face and a source link.
A knowledge source needs an owner, not just an ingestion date
The fix isn’t a smarter retrieval algorithm. It’s treating the knowledge layer as a maintained system with a named owner, not a folder you point an embedding job at once. This is the knowledge principle we build around: an agent should be grounded in the company’s actual documents, and “actual” has to mean current, not just authentic.
In practice that means three things a lot of pilots skip. First, every source document has an owner — a specific person responsible for the pricing sheet, the approval matrix, the policy doc — the same way a spreadsheet with real financial consequences already has one before an agent ever touches it. Second, there’s a refresh cadence tied to how often that document actually changes, not a generic “re-index monthly” default that’s either too slow for pricing or overkill for a policy that hasn’t moved in two years. Third, and most overlooked, the agent’s access to a source is tied to a version and a last-verified date, so a stale document can be flagged or pulled from the grounding set instead of sitting there indefinitely as an available answer.
None of that requires exotic tooling. It requires deciding, before deployment, who is on the hook when the source drifts from reality — the same question you’d ask about any system of record, applied to the one an agent is now quoting from directly. If the pricing sheet has an owner but nobody updated the agent’s copy of it, you haven’t solved the problem, you’ve just added a second copy to keep in sync.
This is also where audit earns its keep: if an agent acts on stale information, the record should show which version of which document it cited, so the question “why did it quote that number” has a one-step answer instead of a forensic search through a shared drive.
Where this still takes judgment
Not every document needs the same cadence, and treating them all identically wastes effort in one direction or leaves risk in the other. A refund policy that hasn’t changed in eighteen months doesn’t need weekly re-verification; a pricing sheet during a promotional quarter might need it daily. Getting this wrong in the cautious direction — re-checking everything constantly — creates its own cost: someone has to review those checks, and “verified, no change” notifications nobody reads are just noise with a timestamp.
There’s also a harder judgment call underneath the mechanical one: some documents don’t have a natural owner because the underlying process is genuinely ambiguous, or ownership is split across two teams who each assume the other is maintaining it. An agent can’t resolve that ambiguity. Building the refresh cadence sometimes forces a business to answer a question it had been avoiding — who actually owns this number — before the agent can be trusted with it.
The question to sit with
Pull up whatever document your most-used spreadsheet, pricing sheet, or approval matrix lives in right now, and check the last-modified date against the last time anyone told your AI tools about the change. If those two dates don’t line up, an agent somewhere is already answering questions with the old version — confidently, and without telling you. Book a diagnostic call if you want a straight answer on how exposed that gap actually leaves you.