The Hidden Bug in Every AI Agent Memory System: Temporal Drift

Most AI agent memory systems have a silent bug. It doesn't show up in demos.
It only surfaces in production, after weeks of running.

The bug is called temporal drift — and it is the reason your agent confidently
tells a user something that stopped being true three weeks ago.

How it happens

You store a fact: "User prefers Python over TypeScript."

Three weeks later the user switches to a TypeScript-first team.
You store a new fact: "User is now working in a TypeScript monorepo."

Both facts live in your vector database. Both have similar embeddings to queries
about the user's tech preferences. Your similarity search retrieves both.

Now your agent has two contradictory beliefs — and no way to know which one is current.

Why vector similarity cannot fix this

Cosine similarity measures semantic closeness, not temporal validity.
A fact from two years ago and a fact from this morning score equally if they
are semantically related to the query. There is no "time" in the embedding space.

You can try to inject timestamps into your prompt and ask the LLM to reason about
which fact is newer. That works in demos. In production, it is slow, non-deterministic,
and fails the moment two facts have similar timestamps.

The structural fix: temporal assertions

Instead of storing facts as permanent records, treat each fact as a temporal interval:

• valid_from: when this fact became true
• valid_to: when this fact stopped being true (NULL = still active)

When a new fact supersedes an old one, you write a valid_to timestamp on the old record
and insert the new one. You never delete. You never update in place.

Active memory is then trivially:

SELECT * FROM memory_events
WHERE agent_id = $1
  AND subject = $2
  AND valid_to IS NULL;

Historical state at any past moment T is:

SELECT * FROM memory_events
WHERE agent_id = $1
  AND valid_from <= T
  AND (valid_to IS NULL OR valid_to > T);

No LLM calls. No reasoning under uncertainty. Pure index arithmetic.

This is what we built with Smriti

Smriti is an open-source bi-temporal memory engine
that does exactly this. It extracts Subject-Verb-Object facts from agent interactions,
assigns them validity windows, and handles supersession automatically.

The result: your agent's memory is always temporally coherent.
No stale facts. No conflicting beliefs. No hallucinations from outdated context.

If you are building an agent that runs for more than a single session,
this is the architectural layer you are probably missing.

---

Open source. MIT license. Built on PostgreSQL.