AriadneMem: LLM Memory via Temporal Graphs

• AriadneMem is a structured memory system that builds directed temporal graphs to support multi-hop dialogue reasoning.
• It mitigates disconnected evidence by algorithmically discovering bridge nodes that link temporally distant dialogue segments.
• It handles state updates by distinguishing static fact duplication from evolving information, ensuring temporal consistency and reducing redundancy.

AriadneMem is a structured memory system for long-horizon LLM agents designed to remain accurate under fixed context budgets. It is introduced as a response to two persistent failure modes in long-term dialogue memory: disconnected evidence, in which multi-hop answers require linking facts distributed across time, and state updates, in which evolving information creates conflicts with older logs. Its core design is a decoupled two-phase pipeline: an asynchronous offline construction phase that builds a directed temporal graph, and a real-time online reasoning phase that reconstructs missing logical paths algorithmically before issuing a single topology-aware LLM call for answer synthesis (Zhu et al., 5 Feb 2026).

1. Problem formulation and target failure modes

AriadneMem is situated in the setting of long-horizon dialogue for LLM agents, where the agent must answer questions or act on information accumulated across many utterances while operating under a fixed context window. In this setting, the system is explicitly motivated by two intertwined error classes.

The first is disconnected evidence. Multi-hop questions may depend on facts that are temporally separated across hundreds of utterances. In the problem description, this is characterized as cases such as $A \rightarrow B \rightarrow C$, where standard flat top-$k$ retrieval returns isolated “atoms” without the connective structure needed to support composition. The consequence is that iterative LLM-based planning must infer or invent missing bridge facts during inference, which is both expensive and error-prone (Zhu et al., 5 Feb 2026).

The second is state updates. Information in long-running interactions may evolve, for example when a schedule changes from one time to another. Raw-log stores and atomic-list memory representations either preserve redundant duplicates or lose track of which record is current. AriadneMem addresses this by distinguishing static duplication from temporal transition, so that state change is represented as a directed update relation rather than collapsed into a single undifferentiated record (Zhu et al., 5 Feb 2026).

This framing places AriadneMem within a broader class of structured memory systems for LLM agents, but with a narrower emphasis on dialogue-centric lifelong memory under constrained token budgets. A plausible implication is that its design is less about generic storage and more about preserving inferential connectivity and temporal consistency during retrieval and synthesis.

2. Two-phase architecture and graph representation

AriadneMem decomposes memory into two asynchronous stages. The offline construction phase consists of entropy-aware gating, atomic extraction, and conflict-aware graph coarsening. The result is a directed, temporal “evolutionary” graph $G=(V,E)$ encoding both static facts and state-update edges. The online reasoning phase consists of fast-path shortcuts, hybrid retrieval to identify terminal nodes $V_{\mathrm{term}}$, algorithmic bridge discovery using an approximate Steiner-tree completion strategy, multi-hop path mining via bounded-depth DFS, and single-call topology-aware synthesis (Zhu et al., 5 Feb 2026).

The offline graph is built from a time-ordered dialogue stream $D=\{d_t\}_t$. Each atomic node $m \in V$ carries the tuple

$m = \langle v_m, K_m, Ent_m, t_m \rangle,$

where $v_m \in \mathbb{R}^d$ is a dense embedding, $K_m$ is a keyword set, $Ent_m$ is an extracted entity set, and $k$0 is an absolute timestamp (Zhu et al., 5 Feb 2026).

This representation is notable because it fuses three retrieval-relevant signals—dense semantics, lexical content, and timestamp—directly into the node state. The temporal component is not auxiliary metadata; it is structurally active in both coarsening and bridge discovery. This suggests that AriadneMem treats temporal ordering as a first-class constraint on memory reasoning rather than as a post hoc filter.

3. Offline construction: gating, extraction, and conflict-aware coarsening

The offline phase begins with entropy-aware gating, which filters low-information or redundant dialogue before LLM extraction. For a message $k$1, AriadneMem defines Shannon entropy over the normalized keyword frequency distribution: $k$2 It also computes redundancy against the nearest memory neighbor: $k$3 The gating rule is

$k$4

Here, $k$5 filters low-information chatter, while $k$6 and $k$7 block near-duplicate repetition; the summary gives example values $k$8 and $k$9 hr (Zhu et al., 5 Feb 2026).

Only dialogues with $G=(V,E)$0 proceed to extraction. The subsequent conflict-aware graph coarsening determines whether a newly extracted entry $G=(V,E)$1 should be merged, linked as a state update, or added as a new node. For a candidate match $G=(V,E)$2, AriadneMem computes

$G=(V,E)$3

Using thresholds $G=(V,E)$4 and $G=(V,E)$5, the action is defined as follows:

• If $G=(V,E)$6 and $G=(V,E)$7, the new entry is treated as a duplicate and merged; $G=(V,E)$8 is dropped and the representative timestamp is updated.
• If $G=(V,E)$9 and $V_{\mathrm{term}}$0, the entry is treated as a state update and a directed edge $V_{\mathrm{term}}$1 is added in timestamp order.
• Otherwise, $V_{\mathrm{term}}$2 is added as a new node (Zhu et al., 5 Feb 2026).

Formally, the coarsening operator $V_{\mathrm{term}}$3 produces $V_{\mathrm{term}}$4 unless the entry is merged, and $V_{\mathrm{term}}$5 in the link case. The key distinction is that duplicates are compressed, whereas updates are preserved as temporal transitions. This is the mechanism by which AriadneMem attempts to retain an evolving world state without accumulating unbounded redundancy.

4. Online reasoning: hybrid retrieval, bridge discovery, and single-call synthesis

At inference time, AriadneMem does not rely on iterative LLM planning to reconstruct missing chains of evidence. Instead, it deterministically traverses the offline graph. The first step is hybrid retrieval: $V_{\mathrm{term}}$6 From these terminal nodes, it builds a base graph $V_{\mathrm{term}}$7, where $V_{\mathrm{term}}$8 if $V_{\mathrm{term}}$9 or $D=\{d_t\}_t$0 (Zhu et al., 5 Feb 2026).

The central mechanism is algorithmic bridge discovery. For each topologically disconnected pair $D=\{d_t\}_t$1, the system constructs a concatenated bridge-query embedding $D=\{d_t\}_t$2 from $D=\{d_t\}_t$3 and solves

$D=\{d_t\}_t$4

If the cosine score exceeds a threshold, the node $D=\{d_t\}_t$5 and edges $D=\{d_t\}_t$6 and $D=\{d_t\}_t$7 are added. The summary explicitly characterizes this as a greedy Steiner-tree approximation that recovers intermediate bridge nodes without additional LLM calls (Zhu et al., 5 Feb 2026).

After bridge completion, AriadneMem performs multi-hop path mining: $D=\{d_t\}_t$8 The implementation uses bounded-depth DFS with path length $D=\{d_t\}_t$9, followed by pruning to a node budget of 8–25 nodes by prioritizing shorter coherent paths. The resulting evidence subgraph is serialized into a compact context $m \in V$0 by listing each fact as $m \in V$1, each path as a sequence of fact identifiers, and explicit answer-format rules such as JSON output, temporal fidelity, aggregation logic, and length constraints. Final answer generation is then performed in one LLM call: $m \in V$2 This pipeline is described as single-call topology-aware synthesis (Zhu et al., 5 Feb 2026).

The architectural consequence is clear: connectivity recovery is shifted from the LLM’s latent reasoning process into an explicit graph-layer procedure. This suggests that AriadneMem is designed to trade repeated generative planning for deterministic graph operations, with the LLM reserved for final synthesis rather than for search.

5. Experimental configuration and reported performance

The reported evaluation uses the LoCoMo benchmark, specifically the MultiHop, Temporal, OpenDomain, and SingleHop subsets. The main backbone is GPT-4o, with ablations using GPT-4.1-mini and Qwen3-Plus. The reported context token budget is approximately 497 tokens on GPT-4o. Hyperparameters include $m \in V$3, $m \in V$4, $m \in V$5 hr, $m \in V$6 hrs, $m \in V$7, $m \in V$8, path length $m \in V$9, and node budget 8–25 (Zhu et al., 5 Feb 2026).

The baselines listed include SimpleMem, Mem0, A-Mem, LightMem, and MemGPT, among others. In the GPT-4o excerpt on LoCoMo, the summary reports the following values:

Method	MultiHop F1	Average F1	Token Cost
SimpleMem	35.89	39.06	550
AriadneMem	41.34	42.57	497

In the same excerpt, total time is 480.9 s for SimpleMem and 429.9 s for AriadneMem (Zhu et al., 5 Feb 2026).

The reported improvements are given in relative terms. AriadneMem improves Multi-Hop F1 by 15.2\% and Average F1 by 9.0\% over strong baselines. It also reduces total runtime by 77.8\% relative to iterative-planning baselines, with the example comparison Mem0’s 1934 s $m = \langle v_m, K_m, Ent_m, t_m \rangle,$0 AriadneMem’s 429.9 s, while maintaining context tokens below 500 (Zhu et al., 5 Feb 2026).

These results support the paper’s central claim that graph-layer reasoning can improve both accuracy and efficiency. More specifically, they indicate that the system’s gains are not obtained by expanding prompt length; the reported token cost is lower than that of the SimpleMem excerpt while the F1 metrics are higher.

6. Relation to graph-based agent memory and stated limitations

A related graph-based memory architecture appears in “AriGraph: Learning Knowledge Graph World Models with Episodic Memory for LLM Agents” (Anokhin et al., 2024). There, the world model is a directed attributed graph

$m = \langle v_m, K_m, Ent_m, t_m \rangle,$1

with semantic vertices and edges for subject–relation–object facts, plus episodic vertices corresponding to raw observations and episodic hyper-edges linking those observations to extracted semantic facts. Retrieval proceeds through semantic search over graph edges and episodic search scored by

$m = \langle v_m, K_m, Ent_m, t_m \rangle,$2

and the resulting subgraph is serialized into working memory for planning and ReAct-style action selection (Anokhin et al., 2024).

The 2026 AriadneMem system differs in emphasis and mechanics. Its graph is described as an “evolutionary” temporal graph over extracted memory atoms, and its online stage centers on bridge discovery, bounded-depth path mining, and single-call synthesis rather than a full planning-and-decision loop. A plausible implication is that both systems share a commitment to explicit structured memory, but they target different operational regimes: AriGraph emphasizes interactive environment control with semantic and episodic integration, whereas AriadneMem emphasizes lifelong dialogue memory under strict context constraints.

The limitations explicitly identified for AriadneMem are also structural. Coarsening thresholds and node budgets require careful tuning per domain; bridge discovery is greedy; and possible extensions include more global Steiner-tree approximations, learned policies, multimodal memories such as images and video, continuous sensor streams, and online adaptation of gating thresholds via reinforcement learning (Zhu et al., 5 Feb 2026). These points indicate that the system’s current performance depends in part on manually selected thresholds and bounded graph search, rather than on end-to-end learned memory optimization.

From a research perspective, AriadneMem occupies a specific position in LLM-agent memory design: it externalizes temporal consistency and inferential connectivity into graph construction and graph algorithms, then supplies the LLM with compact serialized evidence. Its contribution is therefore not merely storage compression, but a particular decomposition of memory into offline structuring and online topological completion intended to make long-horizon reasoning tractable within a small context budget (Zhu et al., 5 Feb 2026).