🤖 machine learning

Is One Score Enough? Rethinking the Evaluation of Sequentially Evolving LLM Memory

This paper introduces SeqMem-Eval, a diagnostic framework that moves beyond aggregate accuracy metrics to provide a finer-grained evaluation of sequentially evolving LLM memory by measuring dynamic properties like forgetting, negative transfer, and the trade-offs between adaptability and stability.

Original authors: Songwei Dong, Zihan Chen, Chengshuai Shi, Peng Wang, Jundong Li, Cong Shen

Published 2026-05-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Songwei Dong, Zihan Chen, Chengshuai Shi, Peng Wang, Jundong Li, Cong Shen

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are hiring a new employee to solve a long list of problems, one after another. You want them to learn from their mistakes and get better over time. In the world of Artificial Intelligence, these "employees" are Large Language Models (LLMs), and the "learning" happens through a digital memory system.

For a long time, researchers have judged how well these AI employees are learning by looking at just one number: their final test score. If they get a high score at the very end, everyone assumes they are great.

This paper, titled "Is One Score Enough?", argues that looking at just the final score is like judging a marathon runner only by their finish time, ignoring whether they tripped, fell, got lost, or ran backwards halfway through. The authors say this single number hides a lot of dangerous secrets.

To fix this, they created a new way to evaluate AI memory called SEQMEM-EVAL. Think of it as a detailed "health checkup" for the AI's brain, rather than just a final grade.

Here is how they break down the AI's memory performance using simple analogies:

1. The Problem: The "Final Score" Trap

Imagine two students taking a 100-question test.

Student A gets questions 1–50 wrong, then studies hard, gets 51–100 right, and ends with a 50% score.
Student B gets questions 1–50 right, then gets distracted, forgets everything, gets 51–100 wrong, and also ends with a 50% score.

If you only look at the final score, they look identical. But their learning journeys were completely different. The paper argues that current AI evaluations make this exact mistake. They see the final score and assume the memory is good, even if the AI is constantly forgetting what it just learned or making things worse for future tasks.

2. The Solution: The "SEQMEM-EVAL" Health Check

The authors propose looking at five specific "vital signs" to see what the memory is actually doing:

Online Utility (The "Live Performance"):
Instead of just checking the final grade, this looks at the AI's performance while it is taking the test. Is it getting better steadily? Or does it have a great start, crash, and then recover? It's like watching a live sports game rather than just reading the final box score.
Hold-out Generalization (The "New Challenge"):
This tests if the AI can use what it learned to solve new problems it has never seen before. It's like teaching a chef to cook a specific pasta dish, then handing them a new, unfamiliar ingredient to see if they can apply the same cooking principles. The paper found that many AIs get good at the specific tasks they practiced but fail to apply that knowledge to new situations.
Backward Transfer (The "Retroactive Help"):
Does learning a new lesson help the AI remember old lessons? Imagine you learn a new math trick that helps you solve a problem you struggled with yesterday. The paper found that often, new updates don't help the past; sometimes, they actually confuse the old answers.
Forgetting (The "Memory Leak"):
This measures how much the AI loses as it learns new things. It's like filling a bucket with water (new knowledge) while there is a hole in the bottom (forgetting). The paper discovered that many AI methods are great at adding water but terrible at plugging the hole, causing them to lose valuable knowledge they had just acquired.
Efficiency (The "Cost"):
This checks how much "fuel" (computer time and data) the AI burns to learn. Some methods get slightly better scores but require 10 times more computing power. The paper asks: Is that tiny improvement worth the massive cost?

3. What They Found (The "Aha!" Moments)

When the authors tested many different AI memory systems using this new "health check," they found some surprising things:

High scores can be a lie: Many AI methods showed great final scores, but when you looked closer, they were actually forgetting huge amounts of information or getting worse at tasks they used to solve easily.
Different designs, different flaws: Some AIs were great at remembering recent things but terrible at long-term lessons. Others were stable but couldn't learn anything new. There is no "perfect" memory system yet; they all have trade-offs.
The "Overwriting" Problem: The paper showed that sometimes, when an AI learns a new topic, it accidentally deletes the rules for an old topic. It's like writing a new note on a sticky pad and accidentally covering up the important note underneath it.

The Bottom Line

The paper concludes that we need to stop treating AI memory like a simple "pass/fail" test. Instead, we need to look at the whole story: How does it learn? Does it forget? Does it help with new problems? And is it worth the cost?

By using SEQMEM-EVAL, researchers can finally see the "hidden failures" in AI memory and build systems that are not just smart at the end of the day, but actually reliable, stable, and efficient throughout the whole journey.

Technical Summary: Is One Score Enough? Rethinking the Evaluation of Sequentially Evolving LLM Memory

Problem Statement

Large Language Models (LLMs) are increasingly equipped with external memory to operate over sequential tasks, accumulating and reusing experience to adapt their behavior over time. While prior work has formalized this setting (e.g., Wei et al. [35]), the evaluation of sequentially evolving LLM memory remains incomplete. Current practices predominantly rely on aggregate metrics, such as final hold-out accuracy or cumulative online performance. The authors argue that these metrics are misleading because they collapse distinct memory behaviors into a single number, obscuring critical failure modes such as forgetting, negative transfer, and unstable learning dynamics. Consequently, methods with similar aggregate scores may exhibit fundamentally different internal dynamics—one steadily accumulating reusable knowledge, while another suffers from oscillatory behavior or transient improvements followed by degradation.

Methodology: SEQMEM-EVAL

To address these limitations, the paper introduces SEQMEM-EVAL, a diagnostic evaluation framework inspired by continual learning but adapted for the specific constraints of test-time LLM memory. Unlike continual learning where model parameters are updated, SEQMEM-EVAL targets a setting where the LLM remains fixed, and adaptation occurs solely through updates to an external, prompt-mediated memory state.

The framework decomposes memory quality into five complementary dimensions, moving beyond a single endpoint score:

Online Utility: Measures performance as the model progressively updates memory during the task stream. Instead of a single scalar, it analyzes the trajectory of cumulative accuracy using:
- OnlineAcc: Final cumulative accuracy.
- Peak-to-End Drop (PED): The degradation from the best intermediate performance to the final state.
- Minimum-to-End Recovery (MER): The recovery from the worst intermediate performance.
- Extremum Timing ( $r_{min}$ ): The relative timing of the lowest performance point.
Hold-out Generalization: Evaluates whether the evolving memory learns reusable knowledge applicable to unseen tasks.
- HoldOutAcc: Final accuracy on a fixed set of unseen examples.
- TrendHO: The slope of the hold-out performance trajectory over time, indicating whether generalization improves, stagnates, or degrades as memory evolves.
Backward Transfer: Assesses whether later memory updates improve performance on previously encountered tasks.
- BWT(t): The effect of memory updates after $t$ steps on earlier tasks.
- Immediate Validity (IV): The one-step backward transfer ( $t=1$ ), measuring if a new update immediately makes the current experience reusable.
Forgetting: Quantifies the loss of previously acquired capabilities.
- F(t): The difference between the best performance achieved on a past task within a horizon $t$ and its performance after $t$ additional updates.
Efficiency: Measures computational costs alongside performance.
- Token Consumption: Total tokens used (prompts, retrieved memory, answers, updates).
- Runtime: End-to-end wall-clock time.

Experimental Setup

The authors conducted a systematic empirical study across diverse benchmarks (HumanEval, MATH500, APIBench, MMLU-Pro, ALFWorld) and two LLM backbones (Qwen3-8B, MiniMax-M2.7). They evaluated a representative set of memory methods, including:

Instance-level retrieval: ExpRecent, ExpRAG.
Structured memory: Dynamic Cheatsheet (DC-RS), Agent Workflow Memory (AWM), G-Memory.
Experiential reflection: ExpeL (Single-Try and Multi-Try variants).

Key Findings

The study reveals that aggregate metrics often mask significant failure modes and trade-offs:

Aggregate Accuracy is Misleading: Methods with strong final or cumulative online accuracy often exhibit substantial forgetting or negative backward transfer. High final scores do not necessarily imply better memory quality or stable accumulation.
Unstable Trajectories: Many methods show non-monotonic improvement. Some achieve high intermediate performance but degrade significantly by the end (high PED), while others show delayed recovery.
Weak Generalization: Online gains do not reliably translate to hold-out generalization. Many methods fail to improve performance on unseen tasks, and in some cases (e.g., APIBench), they underperform the memory-free baseline on hold-out sets despite online gains.
Limited Backward Transfer: While recent updates often provide short-term benefits, they do not reliably consolidate into transferable knowledge for earlier tasks over longer horizons. Immediate validity (IV) is often weak, suggesting updates are shallow (e.g., simple appending) rather than extracting reusable insights.
Significant Forgetting: Sequential updates frequently interfere with previously acquired utility. As new experiences are incorporated, useful information is often overwritten or diluted, leading to the loss of capabilities achieved earlier in the sequence.
Efficiency Trade-offs: Stronger performance often comes with substantial token and runtime overhead. For instance, ExpeL-MT achieves high accuracy but at a 7.4x token cost, while DC-RS incurs a 36x token cost with marginal gains over cheaper methods.

Significance and Contributions

The paper makes three primary contributions:

Diagnostic Evaluation Framework: It introduces SEQMEM-EVAL, a framework that shifts the evaluation paradigm from a single aggregate score to a multi-dimensional analysis of memory dynamics (utility, generalization, transfer, forgetting, and efficiency).
Comprehensive Empirical Study: It provides a systematic comparison of representative memory methods under a unified sequential protocol, revealing that standard metrics systematically miss recurring failure modes.
Actionable Design Insights: The findings highlight that current memory designs exhibit distinct trade-offs between adaptability and stability. The authors argue that future memory mechanisms must move beyond raw instance storage toward abstraction that is paired with validation and cost control. They emphasize that stronger online performance often reflects increased inference budgets rather than more reliable memory evolution.

The authors conclude that a multi-dimensional perspective is essential for understanding LLM memory. By reframing evaluation as the analysis of an evolving process rather than a final endpoint, SEQMEM-EVAL aims to guide the development of more reliable, generalizable, and efficient memory-augmented LLM agents.