Time is Not a Label: Continuous Phase Rotation for Temporal Knowledge Graphs and Agentic Memory
| Authors | Weixian Waylon Li et al. |
| Year | 2026 |
| HF Upvotes | 3 |
| arXiv | 2604.11544 |
| Download | |
| HF Page | View on Hugging Face |
Abstract
Structured memory representations such as knowledge graphs are central to autonomous agents and other long-lived systems. However, most existing approaches model time as discrete metadata, either sorting by recency (burying old-yet-permanent knowledge), simply overwriting outdated facts, or requiring an expensive LLM call at every ingestion step, leaving them unable to distinguish persistent facts from evolving ones. To address this, we introduce RoMem, a drop-in temporal knowledge graph module for structured memory systems, applicable to agentic memory and beyond. A pretrained Semantic Speed Gate maps each relation's text embedding to a volatility score, learning from data that evolving relations (e.g., "president of") should rotate fast while persistent ones (e.g., "born in") should remain stable. Combined with continuous phase rotation, this enables geometric shadowing: obsolete facts are rotated out of phase in complex vector space, so temporally correct facts naturally outrank contradictions without deletion. On temporal knowledge graph completion, RoMem achieves state-of-the-art results on ICEWS05-15 (72.6 MRR). Applied to agentic memory, it delivers 2-3x MRR and answer accuracy on temporal reasoning (MultiTQ), dominates hybrid benchmark (LoCoMo), preserves static memory with zero degradation (DMR-MSC), and generalises zero-shot to unseen financial domains (FinTMMBench).
Engineering Breakdown
Plain English
RoMem addresses a critical problem in long-lived AI agents: how to maintain structured memory that distinguishes between facts that change over time (like "president of") and those that remain permanent (like "born in"). Most existing approaches treat all knowledge the same way, either burying old facts or expensively calling an LLM for every update. The authors introduce a pretrained module called Semantic Speed Gate that maps text embeddings of relations to volatility scores, automatically learning which relations should update frequently and which should be stable, acting as a drop-in temporal knowledge graph layer for agent memory systems.
Core Technical Contribution
The core novelty is the Semantic Speed Gate, a learned mechanism that assigns volatility scores to knowledge graph relations based on their semantic embeddings. Rather than treating temporal decay uniformly across all facts, this approach learns that certain relation types inherently evolve (like political positions) while others are immutable (like birthplace), without requiring expensive LLM calls at ingestion time. This is fundamentally different from prior work that either uses simple recency sorting, overwrites facts naively, or delegates every update decision to an LLM, making it both more semantically intelligent and computationally efficient. The key insight is that volatility is a learnable property of relation types, not individual facts.
How It Works
The system operates on knowledge graphs where each triple consists of entities and relations (e.g., subject-relation-object). When new information arrives about a relation, the Semantic Speed Gate first converts the relation text into an embedding using a pretrained model. This embedding is then fed through the learned gate function, which outputs a volatility score between 0 (persistent) and 1 (rapidly changing). Based on this score, the system determines update behavior: high-volatility relations get fast rotation policies (old values are deprioritized quickly), while low-volatility relations retain long memory horizons (old values stay prominent). The system was trained on data where relation types are labeled with their true update frequencies, allowing the gate to generalize this pattern to new relations at inference time without additional LLM computation.
Production Impact
For teams building autonomous agents or long-lived systems, RoMem eliminates the expensive choice between semantic correctness and computational cost. In production, this means agents can maintain richer, more accurate world models without calling an LLM for every single memory update—a significant latency and cost reduction for systems that ingest thousands of fact updates daily. The drop-in nature means you can add this module to existing knowledge graph backends (Neo4j, RDF stores) without major architecture changes. The trade-off is that the Semantic Speed Gate requires pretraining on representative relation data, and the quality of the volatility scores depends on how well the training distribution matches your deployment domains. For domain-specific applications (specialized enterprise knowledge, scientific databases), you may need to fine-tune the gate rather than relying on the base pretrained model.
Limitations and When Not to Use This
The approach assumes volatility is primarily a property of the relation type itself, which breaks down when the same relation has different update frequencies in different domains (e.g., "leader of" changes rapidly for countries but not for academic institutions). The paper's scope appears limited to the memory ingestion and ranking problem—it doesn't address other critical agent memory challenges like entity linking errors, contradiction detection, or uncertainty quantification when facts conflict. The method relies on quality text embeddings and pretrained gate weights, meaning it may underperform on low-resource languages or highly specialized technical domains where the pretraining data is sparse. Additionally, the paper doesn't discuss how to handle cascading updates where changing one fact should trigger updates to others, or how to maintain consistency when different agents have conflicting versions of the same relation.
Research Context
This work builds on the growing literature of structured memory for autonomous agents, which has emphasized the limitations of simple retrieval-augmented generation (RAG) and pure LLM context windows. It advances the temporal reasoning in knowledge graphs by moving beyond discrete versioning or timestamp metadata, similar to how recent work on continuous-time graph neural networks has improved temporal modeling. The contribution directly addresses pain points identified in papers on long-horizon agent planning and memory-augmented reasoning, where memory quality degrades as agents operate over weeks or months. This opens future directions in learned decay functions, causal temporal reasoning in graphs, and differentiable memory management policies that optimize for downstream task performance rather than just update frequency.
:::tip Subscribe Get weekly breakdowns of papers like this in AI Letters - the newsletter for engineers building production AI systems. :::