AGENTCL: Stress-Testing the "Brain" of Continuous Language Agents

TL;DR

Language agents are expensive to run but often "forget" everything once a task ends. AGENTCL is a new benchmark that proves our current memory methods are good at following "hints" (Plasticity) but terrible at staying smart over time in random environments (Stability). By forcing agents through Compositional Streams, the authors reveal that most SOTA memory methods actually degrade performance when faced with unrelated tasks.

The Problem: The "Incidental Success" Illusion

In current agent research, we often see models getting better over a sequence of tasks. But is the agent actually learning?

The authors argue that existing benchmarks are too "noisy." If an agent solves Task B better after seeing Task A, it might just be because they share the same Python library, not because the agent understood a reusable logic. This lack of Task Relationship Control means we are measuring luck as much as learning.

Methodology: Engineering the "Eureka!" Moment

To fix this, AGENTCL introduces a controlled environment where learning is mandatory for success.

1. Compositional vs. Naive Streams

• Naive Streams: Random tasks from the same domain (e.g., random coding problems).
• Compositional Streams: A "Teacher" (GPT-5.2) decomposes a complex task into subtasks. The agent must solve the subtasks first. If the memory works, it should "reuse" the sub-solution to solve the complex task.

2. The Two-Pass Evaluation

Standard accuracy hides the truth. AGENTCL uses two passes:

• Pass 1 (Read/Write): The agent learns as it goes.
• Pass 2 (Read-Only): The memory is frozen. This tests if the agent retained the knowledge or if it was just a "short-term" fluke.

3. MEMPROBE: A Triple-View Memory

The authors propose MEMPROBE to test their benchmark. It doesn't just store a "diary" (trajectories); it splits memory into:

• Interaction Memory: Raw logs.
• Insight Memory: "What did I learn from my mistakes?"
• Skill Memory: Reusable code snippets or logic blocks.

Figure 1: The AGENTCL protocol, showing how Plasticity, Stability, and Generalization Gains are decoupled.

Experiments: The Stability Bottleneck

The results are a wake-up call for the LLM community.

• Plasticity is High: On CodeEval-Pro, MEMPROBE showed a +21.9% gain in the first pass. The agents are definitely "reusing" code.
• Stability is the Weak Link: In many cases, the Stability Gain (SG) was negative. This means that as more tasks were added to the memory, the agent got more confused, retrieving irrelevant "ghosts" of past tasks that didn't apply to the current one.
• The "Naive" Compression: In naive streams, the difference between a "SOTA" memory method and a simple memoryless agent (ReAct) practically vanished.

Figure 2: Compositional streams (left) clearly separate good methods from bad ones, while naive streams (right) make them look identical.

Critical Insight: The "Passive Retrieval" Trap

The study highlights that most current agent memories are passive. They just store everything and hope the embedding-based retrieval finds the right "chunk."

AGENTCL proves that this leads to Cognitive Interference. Without a mechanism to "forget" or "refine," the agent's brain becomes cluttered with semi-relevant noise. For an agent to truly learn "continually," it needs a Consolidation Filter that acts like a human's sleep cycle—discarding the junk and hardening the useful skills.

Conclusion

AGENTCL shifts the focus of the field from "how much can we store?" to "how much should we ignore?" Future agents shouldn't just be bigger; they need to be more discerning. If we want agents that evolve during deployment, we must solve the Stability Gain crisis identified here.

Note: This blog post summarizes "AGENTCL: Toward Rigorous Evaluation of Continual Learning in Language Agents" (Shu et al., 2026).