Paper: Evaluating Very Long-Term Conversational Memory of LLM Agents
Authors: Adyasha Maharana, Dong-Ho Lee, Sergey Tulyakov, Mohit Bansal, Francesco Barbieri, Yuwei Fang
Published: 2024
arXiv: 2402.17753
Long-term memory is not just an access problem. Even when the right information is somewhere in the context, the model can still fail to identify it, trust it, connect it to the right event, or ignore misleading information around it.
That is the idea I took from Evaluating Very Long-Term Conversational Memory of LLM Agents. The paper introduces LOCOMO, a benchmark for testing whether language models can maintain and use memory across long, multi-session conversations. What interested me was not only that models struggle with long conversations. It was that more context can help one kind of memory task while making another kind of failure worse.
For long-term agents, that points to a deeper problem: a memory state can become unreliable before the model even starts generating a response.
Why I Read This Paper
I am currently interested in reliability failures in LLM agents, especially when an agent has to rely on information accumulated across many interactions.
A common way to approach long-term memory is to give the model a larger context window or retrieve relevant past information with RAG. The assumption is simple: if the right information is available, the model should be able to use it.
This paper is useful because it shows why that assumption is incomplete.
More context can help, but it can also introduce more noise, more opportunities to confuse speakers, and more temporal relationships that the model has to resolve correctly. So the problem is not only whether the model has access to memory. It is whether the model can decide which memory matters, understand how older and newer information relate, and avoid being misled by context that should not affect the answer.
That is the main reason I found this paper relevant to my own work. It suggests that long-term memory can become a reliability problem before the model even begins generating a response.
The Problem
Most earlier long-term dialogue benchmarks were still relatively short. The paper notes that prior work often evaluated around five sessions and roughly 1K tokens, which is very different from an agent interacting with the same person across weeks or months.
The question this paper is really asking is:
Can an LLM still understand a conversation when important information is spread across a long history?
That requires more than remembering isolated facts.
A long-running agent may need to understand that a user changed jobs, moved to another city, recovered from an injury, or changed a preference. It has to know not only what happened, but also when it happened, who it happened to, and how it relates to later events.
Core Idea
The authors introduce LOCOMO, a benchmark for very long-term conversational memory.
LOCOMO contains 50 conversations, with roughly 300 turns and 9K tokens per conversation on average, spanning up to 35 sessions.
The conversations are generated between virtual agents that have personas, life events, and memory. The life events are organized in temporal event graphs so that later conversations can depend on earlier events. Human annotators then correct long-term inconsistencies and verify that the conversations remain grounded in those events.
The basic idea is:
Persona
↓
Life events over time
↓
Long multi-session conversation
↓
Memory and retrieval
↓
Human verification
What matters to me here is not the generation pipeline itself, but the fact that the benchmark creates situations where information has to remain consistent across a long period of time.
For example:
Nate gets a dog
↓
He talks about the dog later
↓
He arranges a playdate with a neighbor's dog
The model has to understand that these are not independent facts. They are part of one evolving history.
The memory problem is not simply:
Did the model remember that Nate has a dog?
It is closer to:
Did the model understand how an earlier event should affect a later conversation?
That distinction matters for long-term agents.
How They Tested It
The paper evaluates long-term memory through three tasks.
The first is question answering, where the model answers questions that may require information from one session, several sessions, temporal reasoning, outside knowledge, or resistance to adversarial questions.
The second is event summarization, which tests whether the model can reconstruct important events and their temporal or causal relationships across the conversation.
The third is dialogue generation, where the model has to produce responses that remain consistent with the speaker's persona and previous life events.
For the QA experiments, the authors compare regular short-context LLMs, a long-context GPT-3.5 model, and RAG. The RAG setup retrieves either raw dialogue, session summaries, or structured observations about the speakers.
What They Found
The first important result is that longer context helps, but not uniformly.
On the overall QA task, GPT-3.5-turbo-16K improved from an F1 score of 24.1 at 4K context to 37.8 at 16K context. But human performance was still far higher at 87.9.
The more interesting result is what happened with adversarial questions.
As context length increased, performance collapsed:
4K → 13.1
8K → 8.4
12K → 6.4
16K → 2.1
So the same additional context that helped on normal memory questions made the model much easier to mislead on adversarial ones.
The second result is that RAG performance depended heavily on how memory was represented.
Retrieving the top five structured observations produced an overall QA score of 41.4, compared with 31.7 when retrieving the top five raw dialogue segments. But retrieving more observations did not continue improving performance.
That suggests that retrieval is not simply about finding as much relevant information as possible. Too much retrieved context can introduce enough noise to hurt the model.
The third result is that a larger context window did not automatically improve long-range understanding.
In event summarization, GPT-3.5-turbo with a 4K context achieved a FactScore F1 of 45.9, while GPT-3.5-turbo-16K scored 39.9.
The authors also found recurring errors such as missing events, hallucinated details, incorrect speaker attribution, and failures to connect events across time.
One limitation is that LOCOMO is still a constructed benchmark. The conversations are generated between virtual agents and then corrected by annotators, so they are not the same as months of messy real user-agent interaction. But that is also what makes the benchmark useful: it gives the authors control over temporal events, causal relationships, and speaker-specific facts, which are difficult to evaluate cleanly in real conversations.
What I Found Interesting
What surprised me was not that LLMs struggle with very long conversations.
What interested me was that having more information available did not consistently reduce failure.
The results do not follow a simple pattern like:
More context
→ More information
→ Better answer
Instead, the model is dealing with something closer to:
More context
↓
More useful evidence
+
More irrelevant or misleading evidence
↓
The model has to decide what to use
That last step seems to be where many of the failures happen.
The adversarial results are especially interesting for this reason. The model may have the relevant history in context and still produce the wrong answer because it interprets that context incorrectly.
I also found the observation-based RAG result important. Transforming conversations into smaller assertions about a speaker's life worked better than retrieving raw dialogue in several settings. That suggests that memory representation matters, not just retrieval.
But even structured memory became less useful when too much of it was retrieved.
This makes me think of context not simply as information available to the model, but as a state that can itself become unreliable.
How This Connects to My Work
This paper mainly evaluates what happens after the model receives its conversational memory. It asks whether the model can answer correctly, summarize events correctly, or generate a consistent response.
But it raises another question that I am more interested in:
Can we tell that a memory state is risky before the model generates its response?
Suppose an agent has two memories:
Memory 1:
User lives in Chicago.
Memory 2:
User moved to Seattle.
Current query:
"Can you recommend a restaurant near me?"
A retrieval system might return both. At that point, the problem is no longer simply retrieval: the relevant evidence is already available. The question becomes whether the memory state itself contains signals that make failure more likely.
For example:
conflicting values
memory age
temporal gap
query relevance
Could these signals tell us:
Predicted failure risk = 0.78
before the target model answers?
LOCOMO shows that long-context failures exist and that they are particularly visible in temporal reasoning, speaker attribution, and noisy retrieval. The paper also shows that models struggle with long-term narratives and with drawing temporal and causal connections across conversations.
What it does not directly test is whether failure propensity varies systematically from case to case, or whether that risk can be estimated in advance.
That is the part I want to investigate further.
Questions I Still Have
Failure stability
- Are some memory states consistently more failure-prone than others across repeated generations?
- If the same case is run many times, does it have a stable failure probability?
Conflict and temporal structure
- What happens when old and new memories explicitly conflict?
- Does the position of the conflicting memory matter?
- How much does the time gap between two memories affect failure?
Pre-response prediction
- Can simple pre-response signals predict failure better than an external LLM judge?
- Does the same risk pattern hold across different target models?
Takeaway
If I had to keep one idea from this paper, it would be this:
Access to long context is not the same as understanding long-term memory.
A larger context window can expose a model to more useful history, but it can also create more opportunities for confusion. RAG can help, but retrieval can introduce its own noise, and even relevant information still has to be interpreted correctly.
For long-term agents, the next problem may not simply be how to store more memory or retrieve more memory.
It may be knowing when the current memory state is safe to trust.
Reference
Maharana, A., Lee, D.-H., Tulyakov, S., Bansal, M., Barbieri, F., & Fang, Y. (2024). Evaluating Very Long-Term Conversational Memory of LLM Agents. arXiv:2402.17753. https://arxiv.org/abs/2402.17753