RoMem: Rotational Temporal Memory Module

• RoMem is a rotational memory module that encodes time as continuous phase rotations, effectively resolving temporal conflicts in evolving datasets.
• It employs a Semantic Speed Gate, using pretrained text embeddings to infer relation-specific temporal volatility for zero-shot generalization.
• RoMem uses geometric shadowing to rank temporally aligned facts without deletion, leading to state-of-the-art performance in temporal KG completion and agentic memory.

Searching arXiv for RoMem and closely related temporal KG / agentic memory papers to ground the article. RoMem, short for “Rotational Memory,” is a drop-in temporal knowledge graph module for structured memory systems that replaces discrete timestamp metadata with a continuous geometric operator in embedding space. It is designed for temporal knowledge graphs and agentic memory, where facts may be persistent, evolving, or contradictory across time. Rather than overwriting prior facts or relying on recency sorting, RoMem stores facts in an append-only memory and internalizes time as a continuous phase rotation in complex vector space, so that temporally aligned facts rank above obsolete contradictions at query time (Li et al., 13 Apr 2026).

1. Conceptual basis and the static–dynamic dilemma

RoMem is motivated by a limitation of conventional temporal memory representations: time is often treated as an atomic label, typically a timestamp column attached to a fact. In traditional temporal knowledge graph or agentic memory systems, this induces three common workarounds when facts change: destructive overwriting, per-ingestion LLM arbitration, or simple recency sorting. The RoMem formulation identifies this as a static–dynamic dilemma: discrete metadata treats all relations identically and therefore cannot resolve temporal conflicts without sacrificing either historical information or static knowledge (Li et al., 13 Apr 2026).

The method addresses this by making time part of the scoring geometry rather than external bookkeeping. Each fact remains permanently in memory, and “obsolete” facts are rotated out of phase in complex vector space. This geometric shadowing mechanism means that temporally appropriate facts naturally outrank earlier contradictions at query time without requiring deletion. The paper presents this as a way to preserve static memory perfectly while supporting arbitrary query times, including historical and zero-shot dates (Li et al., 13 Apr 2026).

A common misunderstanding is to treat RoMem as a timestamp-aware reranker layered on top of ordinary retrieval. That characterization is incomplete. The central design choice is not merely to attach time-sensitive features to retrieved facts, but to encode temporal behavior directly into the embedding dynamics. This suggests that RoMem should be understood as a temporal reasoning module rather than only as a post hoc ranking heuristic.

2. Semantic Speed Gate

A defining component of RoMem is the Semantic Speed Gate, which assigns each relation a volatility score indicating how fast facts of that relation should rotate over time. The stated goal is to infer this volatility automatically from the relation’s text, allowing zero-shot generalization across surface variants and domains (Li et al., 13 Apr 2026).

Let $\phi(r) \in \mathbb{R}^m$ denote a pretrained text embedding of relation string $r$. The gate MLP $f_\theta$ maps $\phi(r)$ to a scalar in $(0,1)$:

$\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$

where $\sigma$ is the logistic sigmoid (Li et al., 13 Apr 2026).

The architecture described for this gate uses relation-text embeddings as input, one or two dense layers with ReLU, and a scalar output logit passed through $\sigma$. The training procedure is self-supervised. Transition pairs are mined from ICEWS05-15 by examining consecutive observations for each $(h,r)$ slot. For consecutive times $t_i, t_{i+1}$, a binary label $r$0 is set to $r$1 if the tail changed and $r$2 otherwise. The gate pretraining objective is

$r$3

$r$4

$r$5

with $r$6 and $r$7 a global scale. The reported procedure trains this module for 100 epochs with learning rate $r$8, after which $r$9 is frozen for the second phase (Li et al., 13 Apr 2026).

The role of the gate is conceptually important. Relations such as “president of” are intended to rotate quickly, while relations such as “born in” should remain effectively fixed. Because the gate is derived from relation semantics, the paper argues that unseen financial relations can receive appropriate $f_\theta$0 values by semantic proximity in zero-shot settings (Li et al., 13 Apr 2026). A plausible implication is that RoMem separates relation-specific temporal volatility from fact-specific semantic content, which is why it can preserve static knowledge while still modeling evolving facts.

3. Continuous phase rotation and scoring

RoMem embeds entities and relations in $f_\theta$1 and interprets them as complex vectors in $f_\theta$2. If $f_\theta$3 are head and tail embeddings, and $f_\theta$4 are relation embeddings for forward and inverse semantics, then time acts through an element-wise phase operator (Li et al., 13 Apr 2026).

The functional rotation is defined as

$f_\theta$5

where $f_\theta$6 is the per-dimension rotation angle. RoMem sets

$f_\theta$7

where $f_\theta$8 is a learnable global timescale, initialized to $f_\theta$9 for seconds-to-days conversion, and $\phi(r)$0 is a learnable inverse-frequency vector with $\phi(r)$1 and $\phi(r)$2 (Li et al., 13 Apr 2026).

The scoring function builds on ChronoR through a multi-component bilinear form. For subspaces $\phi(r)$3,

$\phi(r)$4

$\phi(r)$5

The fact score at time $\phi(r)$6 is

$\phi(r)$7

A simplified DistMult variant sets $\phi(r)$8 and drops $\phi(r)$9, trained with self-adversarial negative sampling (Li et al., 13 Apr 2026).

At query time $(0,1)$0, a stored fact with happen-time $(0,1)$1 is evaluated through the relative phase shift induced by $(0,1)$2. Facts whose times are close to the query remain nearly in phase and therefore receive high score, whereas temporally mismatched facts acquire larger phase differences and lower scores. This is the mechanism termed geometric shadowing (Li et al., 13 Apr 2026).

An important misconception is that RoMem deletes or suppresses obsolete facts. It does neither. Contradictory facts coexist in memory, but the phase geometry ensures that only the temporally aligned ones dominate ranking. This is central to the method’s append-only design.

4. Retrieval interface and integration into agentic memory

RoMem is packaged as a self-contained temporal knowledge graph embedding module with a standard scoring interface, intended as a drop-in replacement for the temporal component of graph-based memory systems such as replacing ChronoR in HippoRAG (Li et al., 13 Apr 2026).

The ingestion pipeline remains append-only. LLMs extract tuples $(0,1)$3 via OpenIE, and facts are added to memory without UPDATE or DELETE calls. At query time, graph traversal and dense retrieval first produce candidate facts, and RoMem then reranks them for temporal correctness (Li et al., 13 Apr 2026).

The paper defines a dual-stream retrieval formulation. A semantic score $(0,1)$4, obtained from dense passage similarity and Personalized PageRank on the knowledge graph, is combined multiplicatively with the temporal score:

$(0,1)$5

where $(0,1)$6 controls temporal amplification only on semantically plausible facts (Li et al., 13 Apr 2026).

Three query modes are specified. In explicit time mode, $(0,1)$7 is given and exact timestamp alignment is enforced. In time-seeking mode, as in questions of the form “When did $(0,1)$8 happen?”, the comparison uses $(0,1)$9. In time-agnostic mode, the default is $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$0, so fresher facts shadow older ones (Li et al., 13 Apr 2026).

The implementation sketch is two-phase. First, entity embeddings and relation embeddings are precomputed, and the gate is pretrained from ICEWS05-15 transition pairs. Second, with the MLP frozen, the system optimizes $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$1 using

$\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$2

where $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$3 is 1-vs-all cross-entropy using the unrotation trick, $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$4 is a listwise time-contrastive loss with Gaussian kernel targets, and $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$5 is N3 on embeddings plus gate regularization (Li et al., 13 Apr 2026). The reported hyperparameters include embedding dimension $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$6 so that $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$7, $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$8, num_time_negatives=8, curriculum $\alpha_r = \sigma(f_\theta(\phi(r))) \in (0,1),$9, gate learning rate $\sigma$0 for 100 epochs, and TKGE learning rate $\sigma$1 for 200 epochs (Li et al., 13 Apr 2026).

5. Empirical performance

The reported evaluation spans temporal knowledge graph completion, temporal question answering, hybrid conversational QA, static dialog memory, and zero-shot financial memory. The datasets are ICEWS05-15, MultiTQ, LoCoMo, DMR-MSC, and FinTMMBench (Li et al., 13 Apr 2026).

Benchmark	Setting	Reported result
ICEWS05-15	TKG completion	RoMem-ChronoR: 72.6 MRR / 66.8 Hit@1 / 83.7 Hit@10
MultiTQ	Temporal KGQA over ICEWS	HippoRAG MRR 0.203 → RoMem 0.337; Acc@5 0.112 → 0.366
LoCoMo	Hybrid conversational QA	average Recall@10 0.770 → 0.857
DMR-MSC	Static dialog memory QA	MRR 0.848 → 0.856
FinTMMBench	Zero-shot financial QA	MRR 0.690 → 0.728; Acc@5 0.550 → 0.580

For temporal knowledge graph completion, the paper reports state-of-the-art performance on ICEWS05-15 with 72.6 MRR. In the same table, ChronoR is reported at 68.4 MRR / 61.1 Hit@1 / 82.1 Hit@10, while RoMem-ChronoR reaches 72.6 MRR / 66.8 Hit@1 / 83.7 Hit@10. A DistMult baseline rises from 45.6 MRR to 62.1 MRR when adapted into RoMem-DistMult (Li et al., 13 Apr 2026).

For agentic memory, MultiTQ is described as temporally heavy, and the method improves HippoRAG from 0.203 to 0.337 MRR and from 0.112 to 0.366 on Acc@5. On LoCoMo, the average Recall@10 increases from 0.770 to 0.857. On DMR-MSC, performance moves from MRR 0.848 to 0.856, which the paper interprets as zero degradation on static memory. On FinTMMBench, zero-shot performance improves from MRR 0.690 to 0.728 and from Acc@5 0.550 to 0.580 (Li et al., 13 Apr 2026).

The ablation results identify two essential components: the functional rotation $\sigma$2 and the pretrained gate $\sigma$3. The paper further reports that adding the time-contrastive loss improves temporal discrimination without harming static accuracy (Li et al., 13 Apr 2026). This suggests that RoMem’s gains are not attributable solely to better retrieval or larger embedding capacity; they depend specifically on the interaction between continuous rotation and semantically inferred volatility.

6. Interpretation, scope, and limitations

RoMem’s principal claim is that temporal conflict resolution can be handled geometrically rather than through deletion, overwriting, or timestamp heuristics. The paper presents this as a mechanism for resolving temporal contradictions while preserving static memory exactly, with zero degradation confirmed on DMR-MSC through the limiting behavior $\sigma$4 for static relations (Li et al., 13 Apr 2026).

The method also claims zero-shot generalization to unseen financial domains on FinTMMBench, with the explanation that unseen relations receive appropriate $\sigma$5 values by semantic proximity. This should not be read as a universal guarantee of domain transfer. More narrowly, the reported result shows that the semantic gate can generalize across at least one unseen financial benchmark under the stated protocol (Li et al., 13 Apr 2026).

Another possible misconception is that RoMem is only applicable when timestamps are explicitly known at ingestion. The design described in the paper assumes extraction of $\sigma$6 via OpenIE and supports explicit-time, time-seeking, and time-agnostic querying. A plausible implication is that the quality of temporal extraction remains an operational dependency, even though the memory module itself avoids update and delete operations.

RoMem is presented as a structured-memory component rather than a general-purpose episodic memory mechanism for all LLM settings. Its strongest fit is graph-based memory with relation semantics and temporal conflict structure. Within that scope, the method’s significance lies in reframing time from a discrete label into a continuous operator that modulates fact ranking in embedding space (Li et al., 13 Apr 2026).