Introducing Temporal Reasoning in Suprflo

Most memory systems store facts as if they were permanent. "User prefers almond milk" goes in once and stays retrievable forever, ranked by how semantically similar it is to whatever the user asks next. That works right up until the fact changes.

The moment a user says "I switched to oat milk after an allergy," a timeless store has a problem. It now holds two facts - almond and oat - that are both plausible, both relevant, and directly contradictory. Pure semantic retrieval has no principled way to pick, so it surfaces whichever embedding happens to score higher. The agent recommends the thing the user is now allergic to, and the failure looks like carelessness rather than a missing model of time.

This is not an edge case. Jobs change, addresses change, medications change, project status changes, preferences change. Any agent meant to remember a person or a process across months will accumulate facts that were true once and are not true now. Without a notion of when each fact held, the system cannot tell a current belief from a historical one - and that is the single most common way long-term memory goes wrong.

Temporal reasoning gives every memory a place on a timeline instead of a single flat existence. A fact is no longer just "true" - it is true over an interval, with a beginning and, when reality moves on, an end.

Concretely, Suprflo attaches a validity window to each fact: a valid_from marking when it became true and a valid_to marking when it stopped. A current fact has an open valid_to. A superseded fact gets its valid_to closed at the moment the new fact begins. Nothing is destroyed - the old belief is retired, not erased - so the agent can answer "what is true now?" and "what did we believe in April?" from the same record.

• When a fact became true - the valid_from timestamp, drawn from the conversation rather than the write time.
• When a fact stopped being true - the valid_to, left open while the fact still holds and closed the instant it is superseded.
• Whether a fact is current or historical - derived directly from the window, so retrieval can prefer what holds now without discarding the past.
• How a fact evolved - the closed windows form an audit trail, letting the agent reconstruct the state of the world at any earlier point.

The distinction that makes this bi-temporal rather than merely timestamped is that Suprflo separates when something was true in the world from when Suprflo learned it. A user can mention in August that they changed jobs back in April - the fact is valid from April even though it was ingested in August. Keeping those two clocks apart is what lets the memory stay honest about history.

Suprflo processes every incoming turn through a deterministic pipeline rather than dumping raw text into a vector store. Temporal reasoning lives inside that pipeline, so time is handled at write time, when the system has the most context, instead of being guessed at read time.

1. Ingest - the raw turn is vaulted verbatim, so the original source is always recoverable no matter what is extracted from it.
2. Extract facts - the system pulls discrete, checkable facts out of the turn, each with the time information stated or implied in the conversation.
3. Entity linking - facts are attached to the entities they describe, so "her employer" and "the company she joined" resolve to the same thing.
4. Semantic deduplication - near-identical facts are collapsed so the store does not fill with restatements of the same thing.
5. Bi-temporal write - each fact is written with its validity window, and any prior fact it supersedes has its valid_to closed rather than being overwritten.
6. Reflection queue - higher-order consolidation runs asynchronously, keeping the write path fast while longer-running reasoning happens in the background.

The subtle step is the bi-temporal write. When a new fact arrives that conflicts with an existing one, Suprflo does not blindly replace it and does not blindly keep both. Near-duplicate or competing facts go through LLM adjudication, which decides whether the new fact is an update to the old one - in which case the old window is closed and the new one opened - or genuinely independent information that should coexist. That judgment is the difference between a memory that evolves cleanly and one that either loses history or contradicts itself.

Take the milk example end to end. In February the user says they prefer almond milk. Suprflo writes a fact with valid_from set to February and valid_to left open - it is currently true.

In April the user mentions an allergy and a switch to oat milk. The new fact conflicts with the old one, so adjudication recognizes it as an update rather than a separate preference. Suprflo opens a new fact - oat milk, valid_from April - and closes the almond fact by setting its valid_to to April. The almond preference is not deleted, it is marked as having ended.

Now the queries resolve the way a person would expect. "What milk does the user prefer?" returns oat, because that is the fact whose window is still open. "Has the user ever preferred almond milk?" returns yes, correctly dated to February through April, because the closed window is still there to read. One store answers both the present-tense and the historical question without contradiction - which a flat, timeless store simply cannot do.

Temporal reasoning is not a cosmetic feature - it is the mechanism behind the memory behaviors that hard benchmarks actually test. Update consistency, temporal recall, and event ordering all reduce to the same question: does the system know when each fact was true? A memory that models validity windows can answer those, and one that stores flat facts cannot.

That is why we treat time as a first-class part of the architecture rather than a post-hoc filter. Suprflo currently scores 75.8% on BEAM 100K - the deliberately unsaturated benchmark whose hardest categories are temporal reasoning and event ordering - alongside 92.1% on LoCoMo and 93.1% on LongMemEval. BEAM stays the sternest test precisely because it stresses the time dimension the most, which is exactly where a bi-temporal model earns its keep.

In production the payoff is simpler to state. An agent backed by temporal memory stops recommending the thing a user dropped, stops citing a role they left, and stops treating a planned trip as one already taken. It can also explain itself - because the history is intact, you can ask not just what the agent believes but when it started believing it, which matters enormously for debugging and trust.

Modeling time helps enormously, but it is not magic, and it is worth being honest about the edges:

• Ambiguous dates - when a user says "a while ago" or "last summer," the valid_from is only as precise as the language allows, so some windows are approximate rather than exact.
• Adjudication is a judgment call - deciding whether a new fact updates an old one or stands alongside it is inherently a reasoning task, and hard cases can be gotten wrong in either direction.
• Implicit endings - facts often stop being true without anyone announcing it, so a window may stay open longer than reality warrants until something newer supersedes it.
• Cost and latency - maintaining windows, running adjudication, and keeping history all add work, so temporal reasoning is a trade you make deliberately for correctness, not a free upgrade.

None of these undo the value - an approximate window that knows a fact ended still beats a flat store that thinks it is permanently current. But they are the reasons temporal memory is a system to tune against real traces, not a switch you flip once and forget.