Who Triggered This Memory? Hawkes Branching Edges for Multi-Hop Recall

Long-running assistants have to answer questions such as "what did she end up doing after the interview she was nervous about?" The answer draws on two remarks made weeks apart, and the two remarks share almost no words. Retrieving by text similarity finds the interview but not the outcome. Existing memory systems close this gap by linking memories that mention the same entity, or by linking successive versions of the same fact. Neither link covers the most common connection in human conversation: one event prompts a later one. We propose to recover these prompting links statistically. We fit a Hawkes process to the timestamped stream of extracted memory events. A Hawkes process is a model of event arrival times in which each event temporarily raises the rate of future related events. Under this model, every event has a computable probability of having been set off by each earlier event. Those probabilities become weighted edges in the memory graph, and the multi-hop search follows them.

The core claim is narrow and testable. On timestamped conversational memory, the "who triggered whom" structure that a self-exciting process infers is a better bridge for multi-hop questions than plain temporal proximity. The reason is that the Hawkes posterior explains away coincidences: dense same-day chatter is attributed to the background rate, while a sparse follow-up weeks later can still be credited to its trigger. If carefully tuned time-window edges do as well, the idea is wrong, and the experiments are built to show that quickly.

What exists and where this sits

Two groups of work motivate the gap. AriadneMem builds an evolving memory graph from conversation, with entity links plus directed temporal edges for state updates. At query time it finds bridges between disconnected evidence using a Steiner-tree approximation (the cheapest subgraph connecting the query's anchor nodes), and then makes a single LLM call. It reports a 15.2% relative gain in multi-hop F1 on the LoCoMo benchmark with GPT-4o, at about 497 context tokens. Its temporal edges are deterministic, though. They encode update order, not the probability that one event caused another. They also cannot connect two different facts that are related only by prompting. We reuse its extraction-and-bridge pipeline unchanged and add one edge type, so any gain is attributable to that edge type.

On the point-process side, Modelling Reciprocating Relationships with Hawkes Processes shows that mutually exciting processes capture reply bursts and turn-taking far better than independent-arrival models. It reports a log-likelihood of 436.66 against 133.29 for a Poisson model on an Enron thread. Learning with Temporal Knowledge Graphs and TREND use Hawkes intensities to forecast links in structured event graphs. These papers supply the method. They forecast future events. None of them uses the inferred triggering structure as a retrieval path for answering questions over unstructured text. APP-VAE constrains our design choice: deterministic sequence models tended to regress toward uninformative mean predictions of event timing. We therefore keep an explicit probabilistic intensity rather than a sequence network that scores next hops.

Text-corpus multi-hop methods are relevant but operate in a different setting. IRCoT interleaves reasoning sentences with retrieval. ChainRAG links sentences by entity co-occurrence, similarity and adjacency, and shows that second-hop recall can be up to 18% lower than first-hop recall. Q-RAG trains a small embedder with value-based reinforcement learning to take retrieval steps over long contexts. All of these treat the evidence as timeless. We also considered the more obvious intersection, a Hawkes intensity that decides when an LLM should retrieve (a Hawkes-style replacement for DRAGIN's uncertainty trigger), and rejected it. Over reasoning steps, an exponential kernel is roughly a moving average of recent retrievals, which a small classifier on DRAGIN-style features would learn directly. The intensity form adds nothing there that would survive that baseline. Over real clock time in memory, it does.

Method

The first stage is extraction. We run AriadneMem's offline stage to obtain atomic memory events, and attach to each one the session date and within-session turn order supplied by LoCoMo. Each event is then assigned to one of $K$ types by clustering its embedding.

The second stage fits a multivariate Hawkes process with conditional intensity

$$\lambda_c(t) = \mu_c + \sum_{j:\, t_j < t} A_{c, c_j} \sum_{m} w_m\, \beta_m e^{-\beta_m (t - t_j)},$$

where $\mu_c$ is the background rate of type $c$, $A_{c,c'}$ is how strongly a type-$c'$ event excites type $c$, and the kernel is a fixed mixture of exponentials. The decay rates $\beta_m$ span hours, days and weeks, and the mixture weights $w_m$ are learned. The mixture sidesteps the kernel-rigidity problem without a fully nonparametric kernel. A single conversation is too sparse to fit a $K \times K$ matrix, so $A$ is low-rank and shared across training conversations, while the background rates $\mu_c$ are fit per conversation. Fitting uses the standard expectation-maximization procedure that exploits the branching structure.

The third stage computes the edges. For each event $i$ and each earlier event $j$, the posterior probability that $j$ triggered $i$ is

$$p_{ij} = \frac{A_{c_i,c_j}\,\kappa(t_i - t_j)}{\lambda_{c_i}(t_i)},$$

where $\kappa$ is the kernel above. The denominator is what separates this from a recency score. A late event arriving in a quiet period gets a high $p_{ij}$. An event buried in a burst of unrelated chatter gets a low one. Pairs with $p_{ij}$ above a threshold become edges with cost $-\log p_{ij}$. These edges are added to AriadneMem's graph, and the unchanged Steiner-tree bridge search and single synthesis call follow.

Research Program

The work has three phases. First, we check that the point-process assumption holds on this data at all. On held-out conversations, the fitted Hawkes model must beat a homogeneous Poisson model and a per-type Poisson model in log-likelihood of event times. It should also show nonzero off-diagonal excitation, meaning that types trigger other types. If it does not, we stop. Second, we build the edge variants and the retrieval pipeline. Third, we measure where gains come from, stratifying questions by the time gap and the lexical overlap between their gold evidence items.

Baselines

The naive reference point is dense top-$k$ retrieval over the extracted memory events, with $k$ chosen so that the context length matches our system's. It shows how much of the multi-hop gap any graph method closes.

The strongest existing method is AriadneMem itself, run with the same GPT-4o synthesis model, the same extraction outputs and the same 3-hop cap. The only difference is that our variant has the extra edges. The file gives only the relative 15.2% multi-hop F1 gain on LoCoMo, and no reported result was found on Lacuna for AriadneMem's absolute LoCoMo multi-hop F1. We will therefore reproduce it and treat our reproduction as the reference number. Beating it means a multi-hop F1 improvement larger than the spread across three extraction seeds, with context tokens within 20% of AriadneMem's.

The iterative baseline is IRCoT adapted to memory retrieval. It shows whether a more expensive LLM loop achieves the same bridging. We report its F1 and wall-clock runtime.

Q-RAG, run from its public code (griver/Q-RAG) on LoCoMo conversations treated as long contexts, is the learned-retriever competitor. It is trained on the same training conversations we use to fit $A$.

Four ablations isolate the key ingredient, and they matter most. The first replaces triggering edges with time-window edges that link all pairs within $\Delta$. We tune $\Delta$ and the edge cost on the same development split with the same search budget as our threshold. The second keeps the kernel weighting but drops the $\lambda$ normalization, which gives recency without explaining-away. The third sets $A$ to the identity, allowing only same-type excitation. The fourth shuffles timestamps within each conversation before fitting.

Why not just…?

Why not just add temporal-proximity edges? This is the real threat, and the time-window ablation is built to settle it. Our prediction is specific. Window edges should match us on questions whose evidence falls in the same session. They should lose on questions whose evidence is separated by days to weeks, because any window wide enough to reach those links also floods the graph with unrelated same-day links and inflates Steiner costs. If a tuned window comes within one F1 point of our system on the long-gap stratum, we will conclude that the Hawkes machinery is unnecessary and say so.

Why not just iterate with the LLM, as IRCoT does? Iteration can in principle find the follow-up event by asking "what happened after the interview?" However, iterative loops pay a large latency cost. L-RAG reports about 2.8 s per query against more than 20 s for IterRetGen on 2WikiMultiHopQA. AriadneMem already beats iterative planning on LoCoMo while cutting runtime by 77.8%. The open question is whether iteration catches long-gap follow-ups that our edges miss. The per-stratum comparison answers it.

Why not just train a retriever end to end, as Q-RAG does? A learned retriever could absorb temporal cues, but LoCoMo-scale training data is small, and a retriever has no explicit way to discount bursts. We run Q-RAG under an equal training budget. If it wins, the result argues that learned navigation subsumes explicit triggering structure.

Why not a neural sequence model instead of a Hawkes process? APP-VAE found that deterministic LSTM baselines underperformed stochastic point-process models on event timing. Its reported Breakfast action accuracy was 62.20% against 53.64%. A neural model also does not directly give the per-pair attribution $p_{ij}$ that we need as an edge weight.

Decisive Checks

We evaluate on LoCoMo, reporting multi-hop F1, temporal F1, average F1, context tokens and runtime. We also report evidence recall where gold evidence annotations are available. According to Me serves as a second memory benchmark if its dialogues carry usable timestamps.

Three results decide the proposal. The first is the long-gap stratum comparison against tuned window edges. The second is the timestamp-shuffle ablation, which must erase most of the gain; if it does not, the gain comes from type clustering rather than dynamics. The third is a negative control on HotpotQA and MuSiQue, where there is no time information. There our edges reduce to background-only and should leave AriadneMem-style performance unchanged, which confirms that the method does no harm when its assumption is absent.