Give an agent a long enough horizon and it starts to rot. It decides something at hour 1 based on fact F. At hour 47 — by a later turn of the same agent, a subagent, or a tool refresh — F becomes F′. And nothing flags the dozen downstream decisions that were built on the now-dead F. The agent has the updated evidence and still acts on the stale conclusion.
This is not a hallucination problem, and it is not a retrieval problem. Vector stores and temporal knowledge graphs already solve "find the latest fact." The unsolved part is a dependency problem: nobody tracks the edges from facts to the decisions that consumed them, so nobody can compute what now needs recomputing.
The build-system reframe
The cleanest framing borrows from Make and Bazel: a decision is a build target; the facts it consumed are its inputs. When an input changes, you mark the target dirty and emit a minimal, precise rebuild set.
Two pieces make this tractable:
Content-address the facts. Hash each fact snapshot so "did this input actually change?" is an O(1) hash compare instead of a fuzzy semantic diff. This is the one genuinely useful idea borrowed from "git for memory" — but the metaphor should stop there.
Propagate staleness through a dependency DAG. Maintain a directed graph of which decisions rest on which facts. When a fact's hash changes, walk the graph and surface exactly the decisions that are now stale — including the hard case, where a change to one fact should cascade-invalidate a different belief whose dependency was never written down.
This turns the impossible-feeling question — "did my world drift?" — into the well-understood one: "what is dirty and must be recomputed?"
The merge problem
Multi-agent worlds make it worse: many agents mutate one shared state concurrently, and the classic answer — last-writer-wins — is exactly wrong for a world model. A silent overwrite erases information that mattered. The better primitive is a CRDT defined over a lattice of semantic domains, with a causal entailment DAG, where conflict resolution is a first-class observable event. Concurrent contradictions don't vanish; they surface — to be arbitrated, logged, or (in a game) turned into emergent story.
Where the moat is
The math here — content addressing, dependency propagation, CRDT merge — is mostly public. The defensible asset is the data flywheel: every captured dependency graph plus which staleness alerts a user accepted or ignored is proprietary training data for the implicit-dependency-inference model. More usage → sharper dirty sets → fewer false alarms → more trust → more usage. That's the compounding loop that buys the time to entrench.
Agent memory has spent its first era optimizing for retrieval accuracy and latency. The next era is about integrity — knowing what you know, what changed, and what that invalidates.