---
title: 'AriadneMem: LLM Memory via Temporal Graphs'
url: https://www.emergentmind.com/topics/ariadnemem
type: topic
---

# AriadneMem: LLM Memory via Temporal Graphs

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 [2603.03290].

## 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 [2603.03290].

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 [2603.03290].

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 [2603.03290].

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 \(t_m\) is an absolute timestamp [2603.03290].

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 \(x_t\), AriadneMem defines Shannon entropy over the normalized keyword frequency distribution:
\[
H(x_t) = - \sum_{w \in K_t} p(w)\log p(w),
\quad
p(w)=\frac{tf(w)}{\sum_u tf(u)}.
\]
It also computes redundancy against the nearest memory neighbor:
\[
m^* = \arg\max_{m\in V} \cos(E(x_t), v_m),
\qquad
r_t = \cos(E(x_t), v_{m^*}).
\]
The gating rule is
\[
\Phi_{\mathrm{gate}}(d_t)=
\begin{cases}
1 & \text{if } H(x_t)>\lambda_{\mathrm{ent}} \text{ AND } (r_t<\lambda_{\mathrm{red}} \text{ OR } \Delta t>\delta_{\mathrm{short}}) \\
0 & \text{otherwise.}
\end{cases}
\]
Here, \(\lambda_{\mathrm{ent}}\) filters low-information chatter, while \(\lambda_{\mathrm{red}}\) and \(\delta_{\mathrm{short}}\) block near-duplicate repetition; the summary gives example values \(\lambda_{\mathrm{red}}=0.6\) and \(\delta_{\mathrm{short}}=1\) hr [2603.03290].

Only dialogues with \(\Phi_{\mathrm{gate}}=1\) proceed to extraction. The subsequent **conflict-aware graph coarsening** determines whether a newly extracted entry \(m\) should be merged, linked as a state update, or added as a new node. For a candidate match \(\tilde m \in V\), AriadneMem computes
\[
\mathrm{sim}(m,\tilde m)=\cos(v_m,v_{\tilde m}),
\qquad
\mathrm{ovlp}(m,\tilde m)=\frac{|K_m \cap K_{\tilde m}|}{\max(1,|K_m|)}.
\]
Using thresholds \(\lambda_{\mathrm{coal}}\) and \(\lambda_{\mathrm{ovlp}}\), the action is defined as follows:

- If \(\mathrm{sim}>\lambda_{\mathrm{coal}}\) and \(\mathrm{ovlp}>\lambda_{\mathrm{ovlp}}\), the new entry is treated as a duplicate and merged; \(m\) is dropped and the representative timestamp is updated.
- If \(\mathrm{sim}>\lambda_{\mathrm{coal}}\) and \(\mathrm{ovlp}\le \lambda_{\mathrm{ovlp}}\), the entry is treated as a **state update** and a directed edge \(\tilde m \rightarrow m\) is added in timestamp order.
- Otherwise, \(m\) is added as a new node [2603.03290].

Formally, the coarsening operator \(\mathcal{C}: V \cup \{m\} \rightarrow V',E'\) produces \(V' = V \cup \{m\}\) unless the entry is merged, and \(E' = E \cup \{\tilde m \rightarrow m\}\) 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}} = \mathrm{Top}\text{-}k_{\mathrm{sem}}(E(q)) \cup \mathrm{Top}\text{-}k_{\mathrm{lex}}(q).
\]
From these terminal nodes, it builds a base graph \(G_0=(V_{\mathrm{term}},E_0)\), where \((u \rightarrow v) \in E_0\) if \(Ent_u \cap Ent_v \neq \varnothing\) or \(|t_u-t_v| < \delta_{\mathrm{time}}\) [2603.03290].

The central mechanism is **algorithmic bridge discovery**. For each topologically disconnected pair \((m_i,m_j)\in V_{\mathrm{term}}\), the system constructs a concatenated bridge-query embedding \(E(q_{ij})\) from \(Ent_i \cup Ent_j \cup K_i \cup K_j\) and solves
\[
b^* = \arg\max_{m \in V \setminus V_{\mathrm{term}}} \cos(E(q_{ij}),v_m)
\quad
\text{subject to } t_m \in [\min(t_i,t_j),\max(t_i,t_j)].
\]
If the cosine score exceeds a threshold, the node \(b^*\) and edges \(m_i \rightarrow b^*\) and \(b^* \rightarrow m_j\) are added. The summary explicitly characterizes this as a greedy Steiner-tree approximation that recovers intermediate bridge nodes without additional LLM calls [2603.03290].

After bridge completion, AriadneMem performs **multi-hop path mining**:
\[
P_q = \{\, p \mid p \text{ is a directed path in } G_q,\; 2 \le |p| \le L,\; \text{temporally consistent} \,\}.
\]
The implementation uses bounded-depth DFS with path length \(L=3\), 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 \(C_{\mathrm{graph}}\) by listing each fact as \([F_k]\; t_k:\; \text{restatement } S_k\), 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:
\[
a = \mathrm{LLM}(q \,\|\, C_{\mathrm{graph}}).
\]
This pipeline is described as **single-call topology-aware synthesis** [2603.03290].

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 \(\lambda_{\mathrm{red}}=0.6\), \(\lambda_{\mathrm{coal}}=0.7\), \(\delta_{\mathrm{short}}=1\) hr, \(\delta_{\mathrm{time}}=6\) hrs, \(k_{\mathrm{sem}}=20\), \(k_{\mathrm{lex}}=5\), path length \(L=3\), and node budget 8–25 [2603.03290].

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 [2603.03290].

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 \(\rightarrow\) AriadneMem’s 429.9 s**, while maintaining context tokens below 500 [2603.03290].

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”** [2407.04363]. There, the world model is a directed attributed graph
\[
G=(V_s,E_s,V_e,E_e),
\]
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
\[
\mathit{rel}(v^i_e)=\frac{n_i}{\max(N_i,1)}\ln(\max(N_i,1)),
\]
and the resulting subgraph is serialized into working memory for planning and ReAct-style action selection [2407.04363].

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 [2603.03290]. 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 [2603.03290].

Source: https://www.emergentmind.com/topics/ariadnemem