EvoArena Deep Dive: When Environments Keep Changing, Is Your Agent's Memory Still Overwriting Itself?

EvoArena Deep Dive: When Environments Keep Changing, Is Your Agent's Memory Still Overwriting Itself?

> Paper: EvoArena: Tracking Memory Evolution for Robust LLM Agents in Dynamic Environments > arXiv:2606.13681 | Code: https://github.com/Aiden0526/EvoArena > Institutions: NUS, SMU, University of Washington, UCL, UPenn, NTU, Recursive, MIT

TL;DR

EvoArena exposes a fatal blind spot in current agents: environments change, but agent memory only stores the latest state. The paper builds three dynamic evolution benchmarks (terminal workflows, code repositories, user preferences) and proposes EvoMem—a Git-style patch history of memory evolution instead of overwrite-on-update. Experiments show an average 3.7% chain-level accuracy improvement, especially significant under continuous environment change.

The Core Problem: Why Do Agents "Forget" Once Deployed?

Existing LLM agent evaluation assumes a static environment. The real world is not static:

• APIs your scripts depend on change interfaces
• Codebases get new versions, features, and bugs
• User preferences drift over time

Agents must answer: What changed? What is still valid? How to act under the current version?

But existing agents merge all memory into a single latest state, causing "State Collapse"—still-valid old rules get overwritten, and everything fails when environments roll back or multiple versions coexist.

Three Evolving Benchmarks

1. Terminal-Bench-Evo — Evolving terminal dependencies, interfaces, paths, validation rules. 89 initial tasks → 352 evolved versions, 441 instances total. 2. SWE-Chain-Evo — Evolving repositories (milestones, features, bug fixes). 50 chains, 493 chain-step instances, 145 unique milestones. Crucially, updates between steps apply *reference milestone updates* rather than agent patches, isolating adaptation from early-error accumulation. 3. PersonaMem-Evo — 10 personas, 505 questions, 313 preference chains. Four question types: single-pattern transfer, multi-pattern synthesis, conflict resolution, temporal trajectory extrapolation.

EvoMem: Git-Style Patch Memory

• Append-only, never overwrite — like Git commit history
• Each patch records 6 elements: timestamp, pre-update content, post-update content, update rationale, semantic summary, supporting evidence
• Uses latest memory by default at inference; retrieves patches to restore still-valid states when needed
• Patches are only created for non-additive updates (modifications, overwrites, reinterpretations)—pure new observations don't trigger patches
• Instantiated across agent types: Terminus2, OpenHands, A-Mem, Memento-S

Results: How Fragile Are Agents in Dynamic Environments?

Baseline chain-level accuracy (getting entire chains right end-to-end):

| Benchmark | Step-level | Chain-level | |---|---|---| | Terminal-Bench-Evo | 43.6% | 21.5% | | SWE-Chain-Evo | 27.9% | 10.0% | | PersonaMem-Evo | 47.3% | 40.0% |

EvoMem improvements:

| Benchmark | Step-level | Chain-level | |---|---|---| | Terminal-Bench-Evo | +2.4% | +6.1% | | SWE-Chain-Evo | +0.4% | +2.1% | | PersonaMem-Evo | +1.7% | +3.2% | | Average | +1.5% | +3.7% |

Best case: Terminal-Bench-Evo + GPT-5.5 jumps from 31.8% to 45.5% chain-level (+13.7 points). On standard benchmarks, EvoMem also gains +6.5% on GAIA (Memento-S) and +3.3% on LoCoMo (A-Mem).

Key insight: EvoMem improves sustained reliability far more than single-step correctness—exactly what dynamic environments demand.

Ablation Highlights

• Patches must be operationalized: when agents retrieve *and adopt* patches, accuracy is 88.9% (+8.3%) vs only +2.6% when patches are retrieved but not adopted.
• Lower regression rates on SWE chains: Pass-to-Pass failure drops (e.g., Kimi-K2.6: 7.14% → 3.33%), meaning agents break less historical behavior while adding new features.
• PersonaMem breakdown: biggest gains on multi-pattern synthesis (+5.2%) and temporal trajectory (+5.2%)—precisely where state collapse is worst.

Token–Accuracy Trade-off

Bigger token budgets ≠ better performance. On Terminal-Bench-Evo, GPT-5.5 reaches 62.8% accuracy but burns 505.0M tokens, while Gemini-3.1 Pro and GLM-5.1 achieve 53.8%/51.8% using only ~79-80M tokens. On PersonaMem-Evo, Gemma-4-31B leads at 52.6% with below-average consumption. EvoMem lets mid-sized models leverage memory history efficiently.

Why This Matters

1. State collapse is an implicit bug: mainstream memory systems (Mem0, A-Mem, LangGraph) default to "latest = best," losing all context of what was and why it changed. 2. Chain-level accuracy is the real standard: deployment cares about sustained reliability, not single steps. Baseline chain accuracy of 10%-40% reveals true fragility. 3. Lightweight, plug-and-play: EvoMem adds a patch layer on top of existing memory systems—no model changes, no fine-tuning. 4. Cross-domain validation: terminal, code, and preference evolution all benefit, suggesting state collapse is a general problem with a general fix.

Limitations

• Evolution scope limited (no multimodal or physical environment changes)
• Patch creation overhead may bottleneck in high-frequency scenarios
• Retrieval errors can inject noise
• Long-running agents may need compression/archiving for patch history
• RAG/vector-DB integration untested

> "Memory is not a snapshot—it is an evolution history."

Reference: Jundong Xu et al. "EvoArena: Tracking Memory Evolution for Robust LLM Agents in Dynamic Environments." arXiv:2606.13681, 2026.