Modeling Temporal Facts in a Knowledge Graph

A knowledge graph without temporal structure will eventually hand an agent two contradictory versions of the same fact and let it guess. That guess is the single most common source of agent error in dynamic enterprise environments, and it starts with something simple: static graphs record facts as timeless triples, subject, predicate, object, with no record of when a relationship held or when it stopped holding.

Enterprise facts change constantly. A user upgrades a plan. A deal moves to a new pipeline stage. A policy gets revised. None of these changes register as contradictions in a static graph. The old fact just sits next to the new one, both marked true, forever.

An agent querying that graph has no principled way to pick between a fact that was true in January and one that became true in March. It resolves the conflict by pattern-matching on whatever looks most relevant to the prompt. Practitioners call the result hallucination, but the mechanism that produces it is a retrieval failure: the graph gave the agent two valid-looking answers and no way to tell them apart.

Regulated industries feel this most sharply. An underwriting agent that pulls a superseded loss-run figure and passes it to a human with a confident recommendation hasn't just produced a wrong answer. It has created a compliance exposure that may stay invisible until an audit finds it months later, by which point the decision has already been acted on.

What a temporal knowledge graph represents

A temporal knowledge graph answers the problem by extending the static triple into a quadruple: subject, predicate, object, and time. Every fact becomes a claim about a bounded period, not a claim about the world as it always is.

The time field can take different forms. It might be a discrete timestamp, a closed interval with a clear start and end, or an open-ended validity window still in effect. "Acme used Okta as its identity provider from January 2026 until March 2026" is a well-formed temporal fact under this model. "Acme uses Okta," on its own, is not, because it carries no information about when that statement stops being reliable.

Some systems push this further with hyper-relational or N-tuple structures, attaching extra qualifiers alongside the timestamp. That matters when a fact's meaning depends on context a simple four-part quadruple can't hold, like a contract term that only applies under a specific renewal condition.

A useful way to picture a TKG is as a sequence of snapshots, one for each moment something changed. But real reasoning over a TKG does more than read the latest snapshot. It tracks order across the whole sequence and weighs recency, so the system can tell not just what's true now but how the fact got there.

Two distinct tasks fall out of this model. Completion fills in missing quadruples within a period that's already known, an interpolation problem. Forecasting infers facts that haven't happened yet, based on historical patterns, an extrapolation problem. These require different architectures, and conflating them in a system design is where a lot of temporal graph projects go wrong before they even reach production.

The three structural choices that determine whether a TKG stays trustworthy

Three structural choices decide whether a temporal knowledge graph can be trusted over time: bi-temporal timestamps, valid-time intervals, and transaction provenance. They each answer a different question. Each answers a different question, and skipping any one of them leaves a gap that neither of the other two, nor the AI model sitting on top, can fill.

Valid time records when a fact was true in the world, the interval during which the relationship between two entities actually held. Without valid time, a graph can't answer "what was true on this date" without scanning every version of every fact it has ever stored, which undercuts the purpose of having a queryable structure.

Transaction time, also called ingestion time, records when the system learned the fact, the moment it was recorded in the database. Without transaction time, a graph can't distinguish a fact that was always known from one that got inserted or corrected after the fact. That distinction matters enormously when someone later asks what an agent actually saw at the moment it made a decision.

Combining both lets a graph reconstruct what it contained at any past moment, including what an agent saw when it acted, keeping real-world validity and system-of-record history separate. Those are two separate timelines, and keeping them separate is the whole point.

Provenance is the third leg. It records which source, which extraction run, or which human correction produced each fact. When two sources disagree about a validity window, provenance gives the graph evidence to adjudicate the disagreement instead of silently overwriting one version with another and losing the trail.

Graphiti, Zep's open-source temporal knowledge graph framework, shows what this looks like in practice. Each fact carries a validity window. New facts trigger invalidation of prior facts they contradict. Graphiti runs this bi-temporal tracking and contradiction handling at sub-second query latency, proof that temporal fidelity doesn't force a trade against speed.

The Temporal GraphRAG system, known as TG-RAG, tackles keeping a graph current without rebuilding it from scratch. TG-RAG models an external corpus as a bi-level temporal graph, combining timestamped relations with a hierarchical time graph, and it supports incremental updates by extracting new temporal facts from incoming documents and merging them into the existing structure. A graph that can only stay accurate through full reprocessing will always lag the rate at which enterprise facts change. One that merges incrementally doesn't.

How modeling approaches handle temporal patterns differently

The data model is half the problem. How the system reasons over that model matters just as much, and three broad paradigms have emerged: embedding-based methods, graph neural networks, and reinforcement learning path-finding. Each trades off predictive power, explainability, and the ability to generalize to entities the graph has never seen.

Embedding-based methods, including TTransE, HyTE, ChronoR, TGeomE, and TNTComplEx, extend static completion architectures by building time directly into the representation. Some concatenate a time embedding onto the entity and relation vectors. Others define temporal rotations in complex or quaternion space. Others factorize the whole temporal graph as a four-way tensor. Recent work in this family uses multi-curvature geometry, mixing hyperspherical, hyperbolic, and Euclidean spaces, to handle substructures that don't all behave the same way.

Graph neural network approaches, including TARGCN, RE-NET, and EvoKG, sample temporal neighbors across the timeline and encode the time differences between them directly. These models interleave graph-aggregated entity states with recurrent updates, letting structure and time evolve together instead of treating time as an afterthought bolted onto a static graph encoder.

Reinforcement learning path-finding methods, including TimeTraveler (also called TITer), DREAM, and APPTeK, take a different approach. They frame reasoning as path-finding through a step-by-step decision process over historical facts, producing multi-hop evidentiary trails for each prediction. That trail is the advantage: in regulated settings where explainability is a requirement, a model that can show its path through prior facts is worth more than one that only shows a probability.

Inductive models like TiPNN solve a separate problem: generalizing to entities the graph has never encountered. TiPNN does this by extracting query-aware temporal paths instead of leaning on pre-trained entity embeddings, which matters in enterprise settings where new suppliers, products, or counterparties show up continuously and a model locked to known entities simply can't reason about them.

The field has recently converged on addressing temporal sensitivity of recurring facts. A historical event that repeats loses influence over time, and a model that weights every occurrence equally ends up over-weighting repetitions that are stale and no longer representative. The MIDFA model, published in Neurocomputing in June 2026, addresses this directly with a history query encoder that models the frequency of fact occurrences at different timestamps, paired with a multidimensional information encoder that captures entity type constraints, temporal patterns, and structural patterns together. That's a modeling problem, not a storage problem, and it won't be solved by better timestamps alone. It requires an architecture built to decay old repetition on purpose.

Keeping the graph current: from batch updates to continuous extraction

A temporal knowledge graph is only as current as the pipeline feeding it, and batch ingestion reintroduces the exact staleness problem the temporal model was built to eliminate, just on a longer cycle.

Batch extraction captures a snapshot of source systems at one point in time. Between runs, facts change, get corrected, or get superseded, and the graph has no record of any of it until the next batch runs. From the graph's perspective, an updated fact arriving in the next batch looks indistinguishable from a brand-new fact, not a correction to something it already believed. That ambiguity undermines the purpose of tracking validity windows.

The ATOM system for dynamic TKG construction works directly against unstructured text to close that gap. It decomposes documents into atomic facts, uses large language models to extract temporal quintuples from them, and merges the resulting atomic graphs in parallel. Its dual-time modeling distinguishes observation time, when data entered the system, from validity time, when the fact actually held in the world, the same bi-temporal distinction that matters at the storage layer, applied at the extraction layer instead.

Consider an underwriting workflow built on top of a graph like this. An agent reads an incoming submission, resolves the insured entity against the existing book of business, pulls the loss history, scores the submission against the carrier's appetite, then routes it to a human underwriter with a recommendation and the evidence behind it. Every one of those steps depends on facts that need to be current at the moment the agent executes, not current as of the last batch run three days earlier. A stale loss history at step three produces a wrong score at step four and a wrong recommendation at step five, and none of those downstream steps can tell that the input they received was already out of date.

Keeping extraction current keeps the graph accurate. It doesn't determine who is allowed to act on what the graph contains, or whether that action can be reviewed after the fact. That question is where the audit requirements of regulated industries come in.

Bi-Temporal Graphs: Audit and Time-Travel Queries in Regulated Environments

Reconstructing what a graph contained, and what an agent saw, at a specific past moment is an audit requirement in regulated industries. It isn't a research novelty or an optional feature layered on for compliance theater, and only a bi-temporal model can satisfy it without falling back on backup snapshots that may not align with the exact moment in question.

A time-travel query asks something precise: what did the graph assert about entity X at timestamp T? Answering that requires both temporal dimensions at once. The valid-time dimension answers whether the fact was true in the world at T. The transaction-time dimension answers whether the system had actually learned it by T. A graph missing either dimension can only give a partial answer, and a partial answer isn't useful to an auditor trying to reconstruct a decision.

Without both dimensions, a regulator or internal auditor reviewing a past AI recommendation can only see the graph's current state, which may have been corrected or updated since the decision was made. That leaves no way to confirm what information the agent actually had in front of it at the time it acted, which is usually the exact question the audit exists to answer.

Decision traces depend on this same structural anchor. A full trace connects the evidence an agent retrieved, the recommendation it produced, the human reasoning applied on review, the approval given, and the action ultimately taken. Each of those elements needs to be anchored to a specific transaction-time snapshot. A graph that silently overwrites old facts instead of versioning them destroys that chain, and once it's destroyed, no amount of logging elsewhere reconstructs it.

Collibra CEO Felix Van de Maele, speaking at GraphSummit 2026, described why this shift matters now: "The big difference today versus two or three years ago is that we used to have people in the middle, and we could count on the judgment of people. That has gone away, and so governance has moved from documentation, design time and policy setting to runtime." Runtime governance only works if the graph can be queried at the moment of action and reconstructed afterward, not just inspected in its current state.

That's also why high-impact actions, changing an identity or access policy, modifying payment information, deleting production data, sending regulated information, or making a binding customer decision, should pause for review by an authorized person before executing. That review only means something if the reviewer can see the same facts the agent saw, which depends entirely on transaction-time anchoring being in place before the action happened, not reconstructed loosely afterward.

Agent Governance Failures as Temporal Governance Failures

Agent sprawl and permission accumulation are temporal problems wearing a governance costume. Agents pick up access rights over time. Those rights rarely get revoked when the agent is repurposed or shut down. No static registry records what a given agent was authorized to do at a given moment, the same permissions gap that bi-temporality closes for facts.

Gartner predicts that by 2027, 40% of enterprises will demote or decommission autonomous AI agents due to governance failures. The most likely failure mode Gartner points to is organizations failing to distinguish between what an agent is able to do and what it's actually been granted the scope to do, a distinction that only holds up if someone is tracking it over time.

Permission accumulation and fact staleness break in the same way. Just as a graph without valid-time intervals can't tell whether a fact is still true, a registry without temporal permission records can't tell whether an agent's access was ever formally revoked or just informally forgotten about. Both failures look identical from the outside: an old, unreviewed state being treated as current simply because nobody tracked when it stopped being accurate.

Organizations that handle this well treat agent offboarding the same way they treat employee offboarding. Permissions get explicitly revoked. Credentials get destroyed. The registry gets updated to reflect it. That is temporal governance applied to the agent layer, and it needs the same bi-temporal record-keeping the fact layer needs: a record of what was true, and a separate record of when the system learned it.

Delegation records complete the picture. A sound record preserves the identity of the requesting user, the identity of every agent in the chain, the original task and its approved purpose, and the policy decision applied at each step along the way. That's a temporal chain of custody, and like the fact layer it mirrors, it has to be queryable at any past moment for an audit to mean anything.