Awesome-AI-Memory

【English | 中文】

👋 Introduction

Large Language Models (LLMs) have rapidly evolved into powerful general-purpose reasoning and generation engines. Nevertheless, despite their continuously advancing capabilities, LLMs remain fundamentally constrained by a critical limitation: the finite length of their context window. This constraint defines the scope of information directly accessible during a single inference process, endowing models with only short-term memory capabilities. Consequently, they struggle to support extended conversations, personalized interactions, continuous learning, and complex multi-stage tasks.

To transcend the inherent limitations of context windows, AI memory and memory systems for LLMs have emerged as a vital and active research and engineering frontier. By introducing external, persistent, and controllable memory structures beyond model parameters, these systems enable large models to store, retrieve, compress, and manage historical information during generation processes. This capability allows models to continuously leverage long-term experiences within limited context windows, achieving cross-session consistency and continuous reasoning abilities.

Awesome-AI-Memory is a comprehensive repository dedicated to AI memory and memory systems for large language models, systematically curating relevant research papers, framework tools, and practical implementations. This repository endeavors to map the rapidly evolving research landscape in LLM memory systems, bridging multiple disciplines including natural language processing, information retrieval, intelligent agent systems, and cognitive science.

---

🎯 Goal of Repository

Our mission is to establish a centralized, continuously evolving knowledge base that serves as a valuable reference for researchers and practitioners, ultimately accelerating the development of intelligent systems capable of long-term memory retention, sustained reasoning, and adaptive evolution over time.

---

📏 Project Scope

This repository focuses on memory mechanisms and system designs that extend or augment the context window capabilities of large language models, rather than merely addressing model pre-training or general knowledge learning. The content encompasses both theoretical research and engineering practices.

🌀 Included Content (In Scope)

• Memory and memory system designs for large language models
• External explicit memory beyond model parameters
• Short-term memory, long-term memory, episodic memory, and semantic memory
• Retrieval-Augmented Generation (RAG) as a memory access mechanism
• Memory management strategies (writing, updating, forgetting, compression)
• Memory systems in intelligent agents (Agents)
• Shared and collaborative memory in multi-agent systems
• Memory models inspired by cognitive science and biological memory
• Evaluation methods, benchmarks, and datasets related to LLM memory
• Open-source frameworks and tools for memory-enhanced LLMs

🌀 Excluded Content (Out of Scope)

• General model pre-training or scaling research without direct memory relevance
• Purely parameterized knowledge learning without memory interaction
• Traditional databases or information retrieval systems unrelated to LLMs
• Generic memory systems outside the LLM context (unless demonstrating direct transfer value)

---

🔔 Recent hot research and news

• 2026-07-06 - 🎉 Updated 25 papers, including 4 on Datasets & Benchmark, and 23 on Framework & Methods
• 2026-06-14 - 🎉 Updated 24 papers, including 2 on Survey, 4 on Systems & Models, 2 on Datasets & Benchmark, and 16 on Framework & Methods
• 2026-06-06 - 🎉 Updated 45 papers, including 1 on Survey, 6 on Systems & Models, 12 on Datasets & Benchmark, and 26 on Framework & Methods
• 2026-05-10 - 🎉 Updated 16 papers, including 3 on systems and models, 1 on benchmarks, and 12 on methods; also added 1 new project under systems and open sources
• 2026-05-06 - 🎉 Updated 16 papers, including 2 on systems and models, 2 on benchmarks, and 12 on methods
• 2026-04-27 - 🎉 Updated 15 papers, including 2 on survey, 3 on systems and models, and 10 on methods
• 2026-04-17 - 🎉 Updated 46 papers, including 1 on survey, 5 on systems and models, 3 on benchmarks, and 37 on methods
• 2026-04-07 - 🎉 Updated 16 papers, including 15 on methods, and 1 on benchmarks
• 2026-03-15 - 🎉 Updated 14 papers, including 14 on methods
• 2026-03-08 - 🎉 Updated 15 papers, including 3 on survey, 2 on systems and models, 5 on benchmarks, and 5 on methods
• 2026-03-02 - 🎉 Add a new code agent to this repo
• 2026-02-27 - 🎉 Updated 20 papers, including 1 on survey, 2 on systems and models, 2 on benchmarks, and 15 on methods
• 2026-02-26 - 🎉 Updated 14 papers, including 14 on methods
• 2026-02-14 - 🎉 Updated 15 papers, including 1 on survey, 12 on methods, 1 on benchmarks, and 1 on systems and models
• 2026-02-09 - 🎉 Updated 15 papers
• 2026-02-01 - 🎉 Updated 16 papers, including 9 on methods, 4 on benchmarks, and 3 on systems and models
• 2025-12-24 – 🎉 Release Repository V(1.0)
• 2025-12-10 – 🎉 Initial Repo

---

🗺️ Table of Contents

• Awesome-AI-Memory
  • 👋 Introduction
  • 🎯 Goal of Repository
  • 📏 Project Scope
  • 🔔 Recent hot research and news
  • 🧠 Core Concepts
  • 📚 Paper List
  • 🧰 Resources
    • 📊 Benchmarks and Tasks
    • 💻 Systems and Open Sources
    • 🎥 Multi-media resource
    • 🧠 Adam Framework
  • 🤝 Make a Contribution
  • 💬 Community & Support
  • 🌟 Star Trends

---

🧠 Core Concepts

• LLM Memory: A fusion of implicit knowledge encoded within parameters (acquired during training) and explicit storage outside parameters (retrieved at runtime), enabling models to transcend token limitations and possess human-like abilities to “remember the past, understand the present, and predict the future.”

• Memory System: The complete technical stack implementing memory functionality for large language models, comprising four core components:

  • Memory Storage Layer: Vector databases (e.g., Chroma, Weaviate), graph databases, or hybrid storage solutions
  • Memory Processing Layer: Embedding models, summarization generators, and memory segmenters
  • Memory Retrieval Layer: Multi-stage retrievers, reranking modules, and context injectors
  • Memory Control Layer: Memory prioritization managers, forgetting controllers, and consistency coordinators

• Memory Operations: Atomic memory operations executed through tool calling in memory systems:

  • Writing: Converting dialogue content into vectors for storage, often combined with summarization to reduce noise
  • Retrieval: Generating queries based on current context to obtain Top-K relevant memories
  • Updating: Finding relevant memories via vector similarity and replacing or enhancing them
  • Deletion: Removing specific memories based on user instructions or automatic policies (e.g., privacy expiration)
  • Compression: Merging multiple related memories into summaries to free storage space

• Memory Management: The methodology for managing memories within memory systems, including:

  • Memory Lifecycle: End-to-end management from creation, active usage, infrequent access, to archiving/deletion
  • Conflict Resolution: Arbitration mechanisms for contradictory information (e.g., timestamp priority, source credibility weighting)
  • Resource Budgeting: Allocating memory quotas to different users/tasks to prevent resource abuse
  • Security Governance: Automatic detection and de-identification of PII (Personally Identifiable Information)

• Memory Classification: A multi-dimensional classification system unique to memory systems:

  • By Access Frequency: Working memory (current tasks), frequent memory (personal preferences), archived memory (historical records)
  • By Structured Degree: Structured memory (database records), semi-structured memory (dialogue summaries), unstructured memory (raw conversations)
  • By Sharing Scope: Personal memory (single user), team memory (collaborative spaces), public memory (shared knowledge bases)
  • By Temporal Validity: Permanent memory (core facts), temporary memory (conversation context), time-sensitive memory (e.g., “user is in a bad mood today”)

• Memory Mechanisms: Core technical components enabling memory system functionality:

  • Retrieval-Augmented Generation (RAG): Enhancing generation by retrieving relevant information from knowledge bases
  • Memory Reflection Loop: Models periodically “review” conversation history to generate high-level summaries
  • Memory Routing: Automatically selecting retrieval sources based on query type (personal memory/public knowledge base)

• Explicit Memory: Memory stored as raw text outside the model, implemented through vector databases with hybrid indexing strategies:

  • Dense Vector Indexing: Handling semantic similarity queries
  • Sparse Keyword Indexing: Processing exact match queries
  • Multi-vector Indexing: Segmenting long documents into multiple parts, each independently indexed

• Parametric Memory: Knowledge and capabilities stored within the fixed weights of a language model’s architecture, characterized by:

  • Serving as the model’s core long-term semantic memory carrier
  • Being activatable without external retrieval or explicit contextual support
  • Providing the foundational capability for zero-shot reasoning, general responses, and language generation

• Long-Term Memory: Key information designed for persistent storage, typically implemented as external knowledge bases with capabilities including:

  • Automatic Summarization: Distilling multi-turn dialogues into structured memory
  • Context Binding: Recording memory context to prevent erroneous generalization
  • Multimodal Storage: Simultaneously preserving text, images, audio, and other multimodal memories

• Short-Term Memory: Active information within the LLM’s context window, constrained by attention mechanisms. Key techniques include:

  • KV Cache Management: Reusing key-value caches to reduce redundant computation
  • Context Compression: Using summaries instead of detailed history (e.g., “the previous 5 dialogue rounds discussed project budget”)
  • Sliding Window Attention: Focusing only on the most recent N tokens while preserving special markers
  • Memory Summary Injection: Dynamically inserting summaries of long-term memory into short-term context

• Episodic Memory: Memory type recording specific user interaction history, fundamental to personalized AI:

  • User Identity Recognition: Identifying the same user across sessions
  • Interaction Trajectory Recording: Preserving user decision paths and feedback
  • Emotional State Tracking: Recording patterns of user mood changes
  • Preference Evolution Modeling: Capturing long-term changes in user interests

• Memory Forgetting: Deliberately designed forgetting mechanisms in large models, including:

  • Selective Forgetting (Machine Unlearning): Removing the influence of specific information from training data, such as covering specific knowledge with forgetting layers
  • Privacy-Driven Forgetting: Automatically identifying and deleting PII information, or setting automatic expiration
  • Memory Decay: Automatically lowering the priority of infrequently accessed memories based on usage frequency
  • Conflict-Driven Forgetting: Strategically updating or discarding old memories when new evidence conflicts with them

• Memory Retrieval: The complex process of precisely locating relevant information from massive memory repositories:

  • Semantic Pre-filtering: Vector similarity matching to obtain Top-100 candidates
  • Contextual Reranking: Reordering results based on current query context
  • Temporal Filtering: Prioritizing the most recent relevant information

• Memory Compression: A collection of techniques maximizing memory utility under limited resources:

  • Content-level Compression: Extracting core information while discarding redundant details
  • Representation-level Compression: Vector quantization (e.g., PQ coding), dimensionality reduction
  • Organization-level Compression: Clustering similar memories, building hierarchical memory structures
  • Knowledge Distillation: Transferring key patterns from external memory into parametric memory

---

📚 Paper List

Papers below are ordered by publication date:

  Date
  Paper & Summary
  Tags
  Links


2026-07-02
DRIFTLENS: Measuring Memory-Induced Reasoning Drift in Personalized Language Models

    
    


    



  
      • DRIFTLENS is a ground-truth-free framework that maps each expressed reasoning step to a value-ontology symbol and measures divergence between a question's no-memory trajectory and its trajectory under injected user-attribute memory, revealing that personalization memory silently reshapes how a model reasons ("symbolic drift"), not just its answer.
      • Measures per-instance reasoning stability of personalized LLMs under memory perturbations using a value ontology and two drift metrics (DTW and SRI) on a benchmark of unverifiable, persona-indifferent questions, and evaluates GRPO- and DPO-based post-training as mitigation.
      • Across four LLMs and 10 user-attribute categories, irrelevant persona memory induces medium-to-large reasoning drift (Cohen's d ≈ 0.35–0.98); GRPO and DPO both reduce drift but neither dominates (e.g., GRPO lowers DTW to 0.186 vs. 0.309 on Gemma2-2B; DPO reaches 0.204 on Qwen3-4B).
  


  2026-07-02
  InduceKV: Fixed-Footprint Continual Adaptation of Multimodal LLMs via Inducing KV Memories
  
      
      
  
  
      
  


  
      • Reframes continual multimodal-LLM adaptation as budgeted online inducing-set selection: task increments are stored as attention-compatible external KV memories (a frozen retrieval key plus compact layerwise KV payloads) injected into self-attention, keeping the backbone frozen under a strict fixed memory budget.
      • Fixed-footprint continual adaptation of MLLMs (task-incremental tuning, continual VQA, domain-incremental, lifelong tuning); extracts attention-ready memory entries and builds a compact inducing set via bilevel optimization (inner retrieval calibration; outer weight selection).
      • Consistently beats PEFT, MoE, replay, and prompt-retrieval baselines under matched budgets; improves over HiDe-LLaVA by 0.88 Avg/1.12 Last on UCIT and 1.35/1.43 on COIN, and raises continual-VQA AP 51.34→52.64 over CL-MoE while outperforming QUAD on VQACL.
  


  2026-07-02
  A-TMA: Decoupling State-Aware Memory Failures in Long-Term Agent Memory
  
      
      
  
  
      
  


  
      • Identifies "ghost memory" — a state-coordination failure where old, current, and transition facts coexist and mislead answers — and proposes A-TMA (Adaptive Truth Maintenance Auditing), a state-aware overlay that decouples memory into three diagnosable levels (bank maintenance, retrieval, answer-time resolution).
      • Long-term agent memory under changing user facts; A-TMA keeps superseded/transition records with typed links (a lightweight Sentry gate plus a Qwen2.5-3B Judge), builds state-aligned evidence packets, and conditions QA on explicit labels, alongside a new conflict-heavy benchmark LTP (LoCoMo Temporal Plus).
      • On LTP, Graphiti/Zep +A-TMA improves conflict accuracy by 0.240 absolute (0.480→0.720) and InsideOut+A-TMA lifts Acc from 0.117 to 0.662; on LoCoMo, Graphiti/Zep +A-TMA raises temporal F1 from 0.0295 to 0.1705.
  


  2026-07-02
  Learning User-Aware Recall: Personalized Retrieval in Long-Term Conversational Memory
  
      
      
  
  
      
  


  
      • Profile-guided Personalized Retrieval Optimization (PPRO) makes long-term conversational memory retrieval both user-aware and optimizable by injecting a derived user-profile embedding as an explicit personalized prior into the retrieval ranking score.
      • Personalized long-term conversational QA; PPRO builds episodic and semantic memory banks plus a user profile offline, performs profile-guided dual-path retrieval, and trains a query rewriter with GRPO using evidence-retrieval and answer quality as rewards while keeping memory banks and answer model frozen.
      • On LoCoMo, PPRO gives the best overall F1 across three backbones, beating prior-best SimpleMem by 7–19 points (e.g., GPT-4o overall F1 48.16 vs. 40.87); on LongMemEval-S it reaches 81.5 overall accuracy vs. 75.9 for the best baseline.
  


  2026-07-02
  ISM: Self-Improving Strategy Memory for Continual Mathematical Reasoning
  
      
      
  
  
      
  


  
      • Intelligent Schema Memory (ISM) is a self-evolving external memory that lets a frozen LLM improve at math reasoning under hard episodic resets by maintaining a compact, bounded bank of strategy schemas with dual representation (stable content + online-adapting feature hook), where every update is gated by symbolic verification.
      • Continual mathematical reasoning under a streaming episode protocol with frozen parameters; ISM uses two-stage retrieval (operator filter + soft scoring), symmetric success/failure learning, and seven self-improvement mechanisms plus conditional schema synthesis.
      • 80.67% on MATH-Hard and 61.67% on OlympiadBench over a 300-episode stream, beating the strongest baseline by +2.00 points on each while storing 64% and 86% fewer schemas (up to 23× fewer entries), with positive backward transfer (+0.03) on OlympiadBench.
  


  2026-07-01
  Multi-Head Recurrent Memory Agents
  
      
      
  
  
      
  


  
      • Decomposes recurrent-memory performance into capture vs. retention, diagnoses retention as the dominant bottleneck (caused by monolithic memory blocks), and proposes Multi-Head Recurrent Memory (MHM) — a training-free framework partitioning memory into independent heads with a stage-wise select-then-update strategy that structurally shields unselected heads from overwriting.
      • Reliable long-context reasoning over 100K–1M tokens; MHM-LRU is a lightweight instantiation that selects the least-recently-updated head each step, guaranteeing uniform head utilization with zero extra token overhead and no retraining.
      • On RULER-HQA at 896K tokens, MHM-LRU lifts retention from less than 30% to 73.96% and accuracy to 49.74% (vs. 21.62% MemAgent, 0.00% native LLM); on BABILong at 1M tokens it reaches 41.41% vs. 25.26% for MemAgent, staying stable where baselines collapse.
  


  2026-07-01
  AUTOMEM: Automated Learning of Memory as a Cognitive Skill
  
      
      
  
  
      
  


  
      • Reframes memory management as an independently trainable "metamemory" skill by promoting file-system operations (read/write/search/append/create) to first-class memory actions alongside task actions, then automates its improvement along scaffold structure and model proficiency via meta-LLM-driven outer loops.
      • Long-horizon procedurally generated games (Crafter, MiniHack, NetHack); Loop 1 (a meta-LLM revises the agent scaffold/file schema) and Loop 2 (a meta-LLM curates good memory decisions to LoRA-finetune a dedicated "memory specialist" while the gameplay model stays frozen).
      • Optimizing memory alone yields ~2×–4× gains on a Qwen2.5-32B base — Crafter 25.0→51.36%, MiniHack 7.5→30.0%, NetHack 0.42→1.85% — bringing the 32B model to the level of frontier systems like Claude Opus 4.5 and Gemini 3.1 Pro Thinking.
  


  2026-07-01
  Imprint: Online Memory Compression for Long-Horizon Egocentric QA
  
      
      
  
  
      
  


  
      • Imprint reframes long-horizon egocentric memory as an online memory compression problem (rather than hierarchical text summarization), representing observations as structured Interaction Records and consolidating them using cognitively-inspired signals of recurrence, recency, and distinctiveness.
      • Long-horizon egocentric QA; parses captions into (person, action, object, timestamps) records via Qwen2.5-7B-Instruct, groups them into event prototypes, scores importance, and consolidates online into a compact retrieval-oriented memory.
      • On the EgoLifeQA 7-day benchmark, improves QA accuracy 31.0%→35.8% and grounded accuracy 10.8%→64.8% (6× more evidence-grounded answers than EgoRAG), while reducing memory footprint 2.3× (109 MB vs. 254 MB) and retrieval latency 11.8× (1.7s vs. 20.1s/query).
  


  2026-06-30
  From Signals to Structure: How Memory Architecture Drives Language Emergence in LLM Agents
  
      
      
  
  
      
  


  
      • Demonstrates that in Lewis signaling games with frozen LLM agents, memory architecture matters more than channel capacity for language emergence — a persistent private notebook lets agents externalize learned conventions and avoid the high-capacity collapse seen in stateless agents.
      • A two-agent referential signaling game (sender/receiver coordinating a code from scratch) run with gpt-5.4-mini; compares five memory architectures (memory only, env board, scratchpad, codebook, codebook meta) across channel capacities from 4 to 125.
      • The scratchpad notebook achieves the most reliable coordination (0.867 ± 0.023 at capacity=25) while stateless "memory only" peaks at cap=25 then collapses (collision 1.0 at cap=64); the information-bottleneck point (cap=8) is a bimodal fragility point, not a compositional optimum.
  


  2026-06-30
  The Past Is Prologue: A Plug-in Controller for Selective Updates in Sequentially Evolving LLM Memory
  
      
      
  
  
      
  


  
      • Janus is a method-agnostic plug-in memory controller that treats each candidate memory update as an accept/reject deployment decision, combining a Memory Momentum Trigger (when to compare old vs. new memory) with a compact hybrid evaluation set of coverage, boundary, and fresh tasks (what to compare on).
      • Sequentially evolving LLM memory for task-solving agents; Janus wraps existing memory updaters (e.g., DC-RS, ExpeL) without changing their update rules, using directional deviation of the memory-update trajectory to trigger bounded-cost old-vs-new validation.
      • Across six datasets, two LLMs (Qwen3-8B, DeepSeek-V4-Flash), and two updaters, Janus improves average accuracy by +2.7 to +4.6 points (e.g., DC-RS 79.5→83.2 and ExpeL 78.3→81.5 on Qwen3-8B).
  


  2026-06-29
  Forensic Trajectory Signatures for Agent Memory Poisoning Detection
  
      
      
  
  
      
  


  
      • Discovers a mechanistically-forced behavioral invariant ("recall fact before send email") that persistent memory-poisoning attacks imprint on an LLM agent's tool-call trajectory, enabling detection from operation-only tool logs without access to memory contents, model weights, or activations.
      • Detects memory-channel (delayed-trigger) poisoning by extracting 19 trajectory features from trigger-session tool logs and training LR/RF/GBM classifiers, evaluated via 5-fold CV, BCa bootstrap, and leave-one-model-out hold-out on 2,520 runs across 9 models (7B–120B).
      • The single invariant rule alone reaches AUC=0.9563; the full Random Forest reaches AUC=0.9904 (Recall 0.984), with AUC=1.000 on 6/9 cross-model hold-outs and zero-retraining transfer to GPT-4.1/GPT-4o; a prefix-only variant hits AUC=0.934 for inline blocking.
  


  2026-06-29
  Neural Procedural Memory: Empowering LLM Agents with Implicit Activation Steering
  
      
      
  
  
      
  


  
      • NPM is a training-free framework that represents agent procedural memory as implicit activation-steering vectors in the residual stream rather than explicit textual instructions, distilled from dual-granularity contrastive experiences to overcome the text-action disconnect of RAG-injected guidelines.
      • Procedural memory for LLM agents; pre-computes steering vectors from contrastive success/failure trajectories, then retrieves and dynamically synthesizes a task-specific vector injected at inference time to modulate reasoning and action selection without parameter updates or context expansion.
      • On four benchmarks (ALFWorld, WebShop, ScienceWorld, BabyAI), NPM matches/exceeds explicit textual baselines (e.g., MiniCPM3-4B avg 22.60→28.87; Qwen3-8B 30.63→36.32) and the hybrid NPM+Workflows setting is best overall (Qwen3-8B avg 41.89, ALFWorld 66.42%).
  


  2026-06-29
  Mandol: An Agglomerative Agent Memory System for Long-Term Conversations
  
      
      
  
  
      
  


  
      • Mandol consolidates fragmented vector/graph memory into a unified memory-native architecture combining a hierarchical memory model, an agglomerative SemanticMap/SemanticGraph structure that natively fuses key-value/vector/graph storage, and a quantitative retrieval mechanism that runs without invoking LLMs.
      • Long-term cross-session conversational memory; replaces RAG-style recall-then-rank with query-adaptive routing, MAD-based denoising/conflict resolution, and MMR token-constrained context generation over an in-memory unified store (with DuckDB persistence).
      • Best overall accuracy on LoCoMo (92.21%) and LongMemEval (88.40%), with ~5.4× mean retrieval and ~4.8× mean insertion speedup under 10 QPS load, cutting tokens 17.4–20.0% vs. EverMemOS.
  


  2026-06-28
  Manufactured Confidence: How Memory Consolidation Turns Hearsay into Confident Facts
  
      
      
  
  
      
  


  
      • Diagnoses "manufactured confidence" — memory-consolidation products (mem0, LangMem) rewrite hedged, casual remarks into confident, dated standalone "facts" that agents then obey, showing agents key on the confidence of phrasing rather than the source, needing no attacker.
      • Uses judge-free access-control and budget-approval agents across five models/four providers to isolate the failure, running the same poisoning protocol against mem0, LangMem, and a verbatim-storage control, and testing framings, source attribution, uncertainty tags, and a hedge-preserving extraction prompt.
      • mem0 and LangMem launder hedged injections into confident facts at 100% (verbatim control 0%); confident framings grant unauthorized access ~0.81 while hedges collapse to ~0.00; a redundant directory restores 0.00 wrong-grant, and hedge-preserving extraction cuts wrong-grant from 0.45 to 0.10.
  


  2026-06-28
  Selective Memory Retention for Long-Horizon LLM Agents
  
      
      
  
  
      
  


  
      • TraceRetain is a lightweight capacity-bounded memory-retention framework for frozen LLM agents that scores memory entries by interpretable features (success, age, access frequency, redundancy, specificity, similarity, downstream utility) and evicts the lowest-scoring ones.
      • Formulates external-memory management as a capacity-constrained retention problem on ALFWorld (gpt-5-mini, ReAct-style), comparing TraceRetain-Linear/CEM against cache heuristics (FIFO/LRU/LFU/Random/Ebbinghaus) and unbounded memory under a 75%-distractor noisy-write stress.
      • Methods saturate on clean ALFWorld (47–49/50 vs. 39/50 no-memory); under noisy writes, unbounded and FIFO Precision@5 collapse while TraceRetain-CEM stays stable (16.9%→16.6%) and preserves 97/100 task success, with bounded K=50 matching unbounded K=100.
  


  2026-06-27
  Memory as an Attack Surface in LLM Agents: A Study on Multiple-Choice Question Answering
  
      
      
  
  
      
  


  
      • Frames the external memory of LLM agents as an attack surface, showing that misleading or corrupted memories inserted through ordinary natural-language interactions can silently flip an agent's answer even when the current query is clean.
      • Builds a planner-guided LLM QA agent with external memory for four-option MCQ, then applies two attacks — false-information memory injection and interaction-based answer-choice steering — across ML, cybersecurity, and networking on GPT-5.4/GPT-4o mini, Gemma2-9B, and Phi3-14B.
      • Clean baselines average 91.85% (closed) vs. 77.10% (open); false-memory injection causes 82/1064 answer changes (7.80% ASR) with Phi3-14B most vulnerable (34.48% shift in cybersecurity); feedback reinforcement biases answers more than example exposure.
  


  2026-06-25
  Supersede: Diagnosing and Training the Memory-Update Gap in LLM Agents
  
      
      
  
  
      
  


  
      • Introduces "supersession" (keeping the current value of a changed fact) as a distinct, trainable failure mode, and releases Supersede — the first RL environment whose reward directly targets temporal fact-currency rather than a proxy, reframing the FAMA metric as a dense training signal.
      • Handling superseded facts in long multi-session dialogue under a bounded, self-maintained memory; diagnoses the gap on the LongMemEval knowledge-update subset and trains it down via GRPO fine-tuning of Qwen2.5-3B with a programmatic supersession-aware reward.
      • Bounded memory drops knowledge-update accuracy 92%→77% on frontier gpt-5.4 (p=0.0033); accuracy falls further as conversations grow 24× (68%→28%); GRPO training nearly doubles held-out supersession accuracy on real unseen conversations (9.0%→16.7%).
  


  2026-06-25
  Temporal Validity in Retrieval Memory: Eliminating Stale-Fact Errors for AI Agents over Evolving Knowledge
  
      
      
  
  
      
  


  
      • MemStrata maintains temporal validity via a deterministic (subject, relation, object) supersession rule in a bi-temporal ledger — retiring stale facts with no similarity threshold and no LLM call on the read path — backed by a proof that cosine similarity cannot separate contradictions from duplicates (AUROC 0.59).
      • Keeps agent memory current under evolving knowledge (code renames, config/dependency/API changes); stores facts like RAG for full static recall but supersedes contradicted values, evaluated fully deterministically on a local 7B model across 6 benchmarks.
      • Ties RAG on static knowledge yet reaches 0.95–1.00 accuracy on evolving knowledge vs. RAG's 0.20–0.47 (2–5× gain), drives stale-fact-error rate from 15–40% to ~0%, and runs ~8× faster than LLM-reranking baselines (~2.1s vs. ~16–18s).
  


  2026-06-24
  Memory Makes the Difference: Evaluating How Different Memory Roles Shape Conversational Agents
  
      
      
  
  
      
  


  
      • Introduces the first fine-grained taxonomy of conversational memory by functional role (answer, clarifying, enriching, distracting, irrelevant) plus a user-centric, context-aware LLM-as-judge evaluation framework covering accuracy, relevance, and informativeness.
      • Controlled comparative experiments on conversational RAG over two long-term multi-session datasets (LongMemEval-m, Long-MT-Bench+) with three frontier LLMs and three retrievers, varying context size and memory-type composition.
      • Clarifying memory reliably improves factual accuracy; distracting memory substantially harms accuracy/relevance; irrelevant memory reduces topic relevance; performance rises then declines as context grows (information overload), and answer memory remains essential.
  


  2026-06-23
  Reasoning as Attractor Dynamics: Latent Memory Retrieval via Gibbs-Weighted Energy Minimization
  
      
      
  
  
      
  


  
      • Reframes LLM reasoning as retrieval from a Dense Associative Memory — correct chains as flat-minima attractor basins, hallucinations as sharp minima — and introduces a Gibbs-Weighted Basin Selection operator that reweights sampled paths by inverse-square spectral entropy (W ∝ E⁻²).
      • Math reasoning (GSM8K); sample K high-temperature trajectories, compute each path's trajectory energy as length-normalized NLL, then reweight via a post-hoc Gibbs measure to relax into the dominant attractor basin.
      • On GSM8K with Phi-3.5-mini (3.8B), Gibbs-Weighted Retrieval (K=12) reaches 90.07% vs. Standard Sampling/majority-vote 84.69% and Greedy Decoding 78.4% — a +5.38% gain over self-consistency.
  


  2026-06-23
  ReM-MoA: Reasoning Memory Sustains Mixture-of-Agents Scaling
  
      
      
  
  
      
  


  
      • A memory-augmented Mixture-of-Agents framework built on a Ranked Reasoning Memory that persistently stores/ranks cross-layer reasoning traces via a comparative Reviewer Agent, paired with Curated Diversified Memory Routing to preserve both reasoning quality and exploration diversity.
      • Scalable multi-agent LLM reasoning; at each layer a Reviewer Agent comparatively scores traces with rationales and later agents receive distinct high/low/contrastive trace subsets, with an optional frontier-model (GPT-5.5) LoRA distillation pipeline to upgrade the Reviewer.
      • Across five reasoning benchmarks (MATH, MMLU-redux, Formal Logic, CRUX, HellaSwag) it consistently beats prior MoA variants and the gap widens with depth — e.g., MATH at L=9: ReM-MoA* 84.0% vs. AttentionMoA 76.9% vs. Standard MoA 61.0%.
  


  2026-06-19
  When Does Overlap Help? OSU-Mem and a Cell-Conditional Analysis of Trajectory Memory for LLM Agents
  
      
      
  
  
      
  


  
      • OSU-Mem organizes agent trajectory memory into overlapping semantic units with budgeted coarse-to-fine retrieval, and shows via cell-conditional analysis that overlap helps only when evidence steps share tool calls or entities (T+E+) and hurts when they share neither (T−E−).
      • Budgeted retrieval from long-horizon LLM-agent trajectories under a strict token budget; builds OSUs from entity/tool/subgoal/similarity views, then query-adaptive centroid-scored expansion, evaluated on a synthetic benchmark, τ-bench, and ToolBench with a 2×2 tool/entity cross-tabulation.
      • +39.9% Recall and +61.5% Hit@2 over the strongest baseline at B=256 on the synthetic benchmark; wins on T+E+ but loses on T−E− in τ-bench; on ToolBench overlap beats disjoint construction with a monotonic dose-response.
  


  2026-05-30
  Memory Shot for Long-Term Dialogue
  
      
      
  
  
      
  


  
      • MemShot renders raw dialogue spans directly into structured visual "memory shots" (images preserving speaker turns, timestamps, and turn boundaries) and leverages an MLLM's internal visual reasoning, avoiding fragile, heavyweight text-based memory construction.
      • Long-term dialogue memory-augmented QA; segments dialogue into contiguous spans, renders each into a hierarchical header+chat visual unit, retrieves top-k units (Qwen3-VL-Embedding-8B), and answers with Qwen3-VL-Instruct MLLMs (2B/8B/32B).
      • Competitive-to-superior on LoCoMo (79.61 overall Acc @32B) and LongMemEval (74.80 overall Acc @32B) while delivering ~70× faster memory construction (≈9.56s), beating visual-memory baseline MemOCR by over 10%.
  

  
    2026-06-25
    MIRROR: Novelty-Constrained Memory-Guided MCTS Red-Teaming for Agentic RAG
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • This paper studies red-teaming for multimodal agentic RAG systems whose attack surface spans retrieved text, images, direct user queries, and orchestrator-level tool manipulation.
      • MIRROR combines an episodic memory bank of successful attack traces with Monte Carlo tree search; retrieved memories provide search priors, while a deterministic novelty gate blocks copying from known or retrieved attacks.
      • Across four attack surfaces, the framework validates candidates through deterministic replay or structured tool-call parsing, aiming to make memory-guided adversarial search both more effective and less dependent on recycled templates.
    
  
    
      2026-06-23
      Escaping the Self-Confirmation Trap: An Execute-Distill-Verify Paradigm for Agentic Experience Learning
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper studies experience-driven self-evolution for LLM agents and identifies a Self-Confirmation Trap: single-agent loops may treat wrong-but-self-consistent trajectories as successful experience, causing erroneous memories to be retrieved and reused later.
        • It proposes EDV, an Execute-Distill-Verify framework in which multiple heterogeneous agents first explore the same task space, a third-party distillation agent compares candidate trajectories to produce experience candidates, and an execution group verifies them through consensus before memory insertion.
        • By decoupling execution, experience distillation, and verification, EDV turns isolated self-reflection into collaborative experience construction and filters noisy or erroneous content before it enters shared or private memory. Experiments on tau2-bench, Mind2Web, and MMTB show consistent improvements over strong baselines, highlighting the importance of reliable memory construction for agent self-evolution.
      
    
    
      2026-06-18
      Grouped Query Experts: Mixture-of-Experts on GQA Self-Attention
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper proposes Grouped Query Experts (GQE), a mixture-of-experts layer on top of grouped-query attention that targets the high cost of dense self-attention at long context lengths.
        • Within each GQA group, a router selects k query-head experts per token while leaving all key-value heads dense and unchanged. This preserves the KV-cache advantages of GQA while reducing active query-head computation according to token difficulty or information content.
        • On a fixed 30B token budget at the 250M parameter scale, GQE matches the downstream accuracy of an all-active GQA baseline while activating only half of the query heads per token, suggesting a path to more efficient long-context processing.
      
    
    
      2026-06-18
      Multi-Agent Transactive Memory
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper introduces Multi-Agent Transactive Memory (MATM), which organizes action–observation trajectories generated by heterogeneous agents into group-level shared memory. Producer agents contribute execution experience, while consumer agents retrieve prior trajectories, enabling the reuse of procedural knowledge that would otherwise be discarded after a single task.
        • MATM employs a state-conditioned key–value index, using the current task and recent interaction history as retrieval keys and subsequent trajectory segments as values. It further applies a learning-to-rank model that integrates producer reliability, consumer characteristics, retrieval scores, and trajectory attributes to perform personalized reranking.
        • Experiments in ALFWorld and WebArena demonstrate that retrieving shared trajectories improves task performance and reduces interaction steps without requiring direct inter-agent coordination or joint training, with benefits extending across agents of varying capability levels. The work thereby extends individual experiential memory into a collective knowledge infrastructure for open agent ecosystems.
      
    
    
      2026-06-17
      What Must Generalist Agents Remember?
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper formally investigates the information that generalist agents must retain to sustain near-optimal behavior across multiple environments and objectives. It defines states with identical observations but conflicting optimal actions as observational bottlenecks that reveal the necessity of memory.
        • The separation theorem establishes that when different domains require mutually incompatible optimal actions at such a bottleneck, any unified near-optimal policy must induce distinct memory distributions. Consequently, a memoryless policy that relies solely on the current observation cannot simultaneously maintain a high success rate and cross-domain robustness.
        • The paper further proves that if memory is sufficient to estimate the value functions of a set of relevant objectives, local transition dynamics can be approximately reconstructed from it. Memory therefore serves simultaneously as a mechanism for domain disambiguation, environment-model reconstruction, and a substrate for planning. These findings establish theoretical necessity but do not directly prescribe a specific engineering architecture for memory.
      
    
    
      2026-06-17
      User as Engram: Internalizing Per-User Memory as Local Parametric Edits
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper decomposes personalized memory into user-specific content and reasoning skills shared across users. It proposes storing user facts through localized row edits in the hash-keyed memory table of the Engram model, while a single shared adapter provides fact interpretation and indirect reasoning capabilities.
        • Unlike per-user LoRA modules, which exert dense effects on global weights, localized Engram edits operate only at precisely triggered positions and leave all other positions unchanged. Facts belonging to different users are written into non-overlapping hash slots, enabling additive and lossless multi-user composition within a shared table.
        • The paper reports that the proposed design matches per-user LoRA in direct recall, improves indirect-reasoning accuracy by an average factor of 5.6, and reduces memory consumption by approximately 33,000 times. After roughly 100 facts, it also outperforms retrieval pipelines using larger models. Its applicability, however, depends on the underlying model possessing an editable Engram memory architecture.
      
    
    
      2026-06-16
      Closing the Feedback Loop: From Experience Extraction to Insight Governance in Verbal Reinforcement Learning
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper identifies a retention–forgetting dilemma faced by parameter-free verbal reinforcement learning in non-stationary environments: retaining obsolete rules indefinitely induces negative transfer, whereas permanently deleting prior knowledge causes catastrophic forgetting when similar conditions recur.
        • The authors propose a three-layer memory architecture comprising rules, evidence, and skills, connected through a feedback-driven curation loop. Rules distill experience, evidence records the cross-episode reliability of rules, and skills govern rule selection, conflict resolution, and abstention when necessary.
        • A financial forecasting case study shows that the same accumulated experience can produce performance below a zero-shot baseline when governance is absent, whereas incorporating the curation loop improves both predictive accuracy and risk-adjusted returns. This finding suggests that the central bottleneck in continual agent learning is not merely experience extraction, but also the governance of knowledge lifecycles and application permissions.
      
    
    
      2026-06-16
      Memory as a Wasting Asset: Pricing Flash Endurance for Embodied Agents, and the Limits of Doing So
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper models the finite program/erase endurance of robotic flash storage as non-renewable depreciating capital. It introduces an endurance shadow price η and uses it to construct a wear-augmented per-byte index for optimizing memory placement across RAM, onboard non-volatile storage, and cloud infrastructure.
        • Theoretical analysis shows that threshold-based placement policies can achieve cost optimality under different value–write correlation levels χ. Only when χ is positive can the optimal policy become non-monotonic, moving frequently written, high-value memories away from local flash storage. Real-world logs show that χ is positive for cyclic long-horizon operations, near zero for short-horizon tasks, and negative for non-cyclic teleoperation.
        • Endurance constraints are generally inactive for high-end TLC devices rated for approximately 3,000 P/E cycles, but may become binding for QLC or eMMC devices rated for approximately 1,000 P/E cycles. The paper also explicitly notes that wear-aware management primarily improves device longevity and cost efficiency; it has not yet been shown to increase task value or task success rates.
      
    
    
      2026-06-15
      Posterior Twins: Distributional Behavioral Simulation for Enterprise Decisions
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper introduces Posterior Twins, extending the output of enterprise digital twins from a single most likely behavior to a posterior distribution over behaviors conditioned on a specific decision context. This formulation captures states such as adoption, churn, hesitation, and risk migration across different population segments.
        • The system uses governed historical memory as its evidence base and integrates behavioral-model routing, scenario orchestration, distribution aggregation, and auditing mechanisms. Evaluation employs both modal accuracy and Wasserstein-1 distance to distinguish point-prediction correctness from overall distributional fidelity.
        • On 226 held-out samples, TL-Twin Alpha achieves the lowest Wasserstein-1 distance in the reported results, at 1.16, while Gamma and Delta exhibit more balanced operating points. The study demonstrates the need for distributional evaluation in enterprise simulation, although its conclusions remain constrained by the scale of a single benchmark and the particular system configurations examined.
      
    
    
      2026-06-15
      Trust-Aware Multi-Agent Traceability: Confidence-Calibrated Knowledge Graphs for Consistent Software Artifact Management
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper addresses error propagation in multi-agent software-engineering pipelines by employing a shared knowledge graph as both centralized semantic memory and a coordination interface. This enables downstream agents to evaluate and inherit upstream artifacts according to calibrated confidence estimates.
        • The method comprises two-stage traceability-link prediction combining embedding-based retrieval with LLM-based multi-criteria analysis, a trace-seed mechanism for comparing confidence at generation and verification time, and protocols for threshold gating, confidence-disagreement detection, and conflict resolution.
        • An automotive software-engineering case study and ablation experiments indicate that confidence calibration is essential to the effective operation of the coordination protocol. However, because the evidence is derived primarily from a domain-specific case, the work is better understood as an architectural validation of trustworthy multi-agent artifact governance than as a universally applicable conclusion across all collaborative settings.
      
    
    
      2026-06-15
      HiMPO: Hindsight-Informed Memory Policy Optimization for Less-Entangled Credit in Long-Horizon Agents
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper focuses on entangled causal credit assignment in memory-writing operations for long-horizon agents. A final failure may originate from tool invocation, noisy observations, or subsequent reasoning, yet trajectory-level rewards can mistakenly penalize an earlier memory update that was itself correct.
        • HiMPO first compares the task-relevant information recoverable from the new and previous memories under the same pre-write state to estimate the local utility of a memory update. It then calibrates this utility using a bounded hindsight-relevance filter and applies the resulting memory-specific advantage exclusively to memory tokens.
        • Across open-domain evaluations and compressed-memory question-answering tasks, the method outperforms multiple memory and reinforcement-learning baselines. Controlled interventions further demonstrate that HiMPO reduces responsibility leakage caused by tool errors and improves the accuracy and interpretability of credit attribution for memory writes.
      
    
    
      2026-06-15
      User as Code: Executable Memory for Personalized Agents
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper proposes the “User as Code” paradigm, implementing the user model of a personalized agent as a continuously evolving software project. Typed Python objects store user state, while ordinary functions encode constraints, aggregation logic, and response rules, allowing memory representation and memory reasoning to share the same executable medium.
        • The system employs a two-stage pipeline comprising an append-only fact log and periodic code checkpoints. This preserves the original history while organizing it into verifiable structured state, thereby supporting contradiction resolution, cross-record aggregation, and safety rules that are proactively triggered by state changes.
        • UaC achieves a conventional factual recall rate of 78.8% on LOCOMO and approximately 99% on historical aggregation questions, substantially exceeding the 6%–43% performance of retrieval-based memory. Its central contribution extends beyond improved recall: it transforms user memory from a passive query database into a proactively serving system capable of deterministic execution.
      
    
    
      2026-06-15
      TokenPilot: Cache-Efficient Context Management for LLM Agents
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper observes that although conventional context pruning and dynamic memory eviction reduce input-token counts, they also alter sequence boundaries and prompt layouts, resulting in prefix mismatches and KV-cache invalidation. Context sparsity and cache continuity therefore exhibit a systematic tension.
        • TokenPilot adopts a dual-granularity management strategy. At the global level, Ingestion-Aware Compaction compresses environmental noise as information enters the context and stabilizes the prompt prefix. At the local level, Lifecycle-Aware Eviction performs conservative batched offloading according to the remaining task utility of individual context segments.
        • In both independent and continuous operation modes on PinchBench and Claw-Eval, the paper reports cost reductions of 56%–61% and 61%–87%, respectively, while maintaining task performance comparable to existing systems. These findings establish cache-compatible stable layout as an independent design objective for cost optimization in long-horizon agents.
      
    
    
      2026-06-14
      FragFuse: Bypassing Access Control of Large Language Model Agents via Memory-Based Query Fragmentation and Fusion
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper reveals that long-term memory introduces a cross-turn temporal channel into agent access control. A prohibited request that would ordinarily trigger refusal can be decomposed into superficially benign fragments, written separately into memory, and subsequently recombined during retrieval.
        • FragFuse comprises three stages: refusal-sensitive fragment identification, memory injection using marker-based carriers, and fusion-oriented retrieval attacks. It further uses surrogate models to optimize fusion instructions and marker design, enabling automated attack generation under a black-box threat model.
        • The paper reports an average access-control bypass rate of 86.3% and an end-to-end harmful-task success rate of 41.1%. Prompt-injection detectors and perplexity-based detectors provide limited defensive effectiveness. These results demonstrate that security review must encompass the complete lifecycle of memory writing, storage, retrieval, and fusion rather than inspecting only the current user query.
      
    
    
      2026-06-14
      DYNA: Dynamic Episodic Memory Networks for Augmenting Large Language Models with Temporal Knowledge Graphs in Continuous Learning
      
        
        
        
        
      
      
        
          
        
      
    
    
      
        • This paper introduces DYNA, which uses a frozen large language model as its reasoning core and constructs a continuously updatable external episodic memory by representing events as nodes and temporal relations such as “before,” “after,” and “co-occurs with” as timestamped directed edges.
        • During querying, the system uses random walks, node centrality, and graph-structural information to identify relevant events, then combines the retrieved results with the model’s internal knowledge to generate answers. This avoids the training costs and parameter-level knowledge interference associated with continual fine-tuning.
        • Across three categories of temporal-memory tasks, the paper reports that DYNA reduces catastrophic forgetting by approximately 7% relative to fine-tuning and improves temporal-ordering accuracy by approximately 5% relative to standard RAG. The positive correlation between graph clustering coefficients and retrieval performance further indicates that memory topology itself is an important determinant of performance.
      
    
    
    2026-06-12
    AgentSpec: Understanding Embodied Agent Scaffolds Through Controlled Composition
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • This paper introduces AgentSpec, formalizing embodied agents as typed compositions of perception, memory, reasoning, reflection, action, and optional learning modules. Standardized interfaces support the independent replacement, ablation, and controlled recombination of these components.
      • The study systematically compares different reasoning, memory, reflection, and reinforcement-learning components across DeliveryBench, ALFRED, MiniGrid, and RoboTHOR. The results show that agent performance is not determined by the strength of any single module, but is significantly influenced by module compatibility, task environment, and component interactions.
      • The experiments specifically demonstrate that structured, multi-granularity memory provides more stable support for long-horizon state tracking, although its benefits depend on alignment between the memory representation and the downstream reasoning strategy. The work thus transforms agent scaffolding from an empirically configured engineering artifact into an analyzable compositional design space.
    
  
  
    2026-06-11
    EvoArena: Tracking Memory Evolution for Robust LLM Agents in Dynamic Environments
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Introduces EvoArena, a benchmark suite for simulating dynamic environment changes to evaluate memory robustness in LLM agents.
      • Proposes EvoMem, a patch-based memory paradigm that explicitly tracks structured memory evolution over time.
      • Results show that current agents perform poorly under evolving environments, while EvoMem significantly improves performance.
    
  
  
    2026-06-11
    MemRefine: LLM-Guided Compression for Long-Term Agent Memory
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Proposes MemRefine, an LLM-driven memory compression framework under fixed storage budgets.
      • Uses semantic and factual consistency evaluation to iteratively delete, merge, or retain memory entries.
      • Maintains or exceeds baseline performance under strict memory constraints.
    
  
  
    2026-06-11
    Getting Better at Working With You: Compiling User Corrections into Runtime Enforcement for Coding Agents
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Introduces TRACE, which compiles user corrections into runtime constraints for LLM agents.
      • Converts feedback into executable rules for continuous behavior correction.
      • Significantly reduces preference violations in interactive tasks.
    
  
  
    2026-06-11
    G-Long: Graph-Enhanced Memory Management for Efficient Long-Term Dialogue Agents
   
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Proposes G-Long, a graph-based memory system using structured triples for long-term dialogue management.
      • Employs lightweight LMs for structured extraction and attention-aware importance scoring.
      • Achieves efficient and high-quality memory retrieval with reduced computational cost.
    
  
  
    2026-06-11
    Multi-Turn Reasoning When Context Arrives in Pieces: Scalable Sharding and Memory-Augmented RL
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Addresses multi-turn reasoning failures caused by fragmented context input in dialogue systems.
      • Introduces a compact rolling memory mechanism replacing full history tracking.
      • Improves zero-shot reasoning and generalization across long-context tasks.
    
  
  
    2026-06-10
    Arbor: Tree Search as a Cognition Layer for Autonomous Agents
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Introduces Arbor, a multi-agent framework using tree search as a shared cognitive layer.
      • Maintains an explicit evolving search tree as shared working memory for coordination.
      • Improves scalability, reproducibility, and reasoning efficiency in large state spaces.
    
  
  
    2026-06-10
    Substrate Asymmetry in User-Side Memory: A Diagnostic Framework
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Decomposes user-side memory into orthogonal axes rather than treating personalization as a single capability.
      • Identifies three key dimensions: behavioral consistency, factual presence, and factual absence.
      • Reveals asymmetries across models and highlights alignment and routing trade-offs.
    
  
  
    2026-06-10
    Organize then Retrieve: Hierarchical Memory Navigation for Efficient Agents
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Proposes HORMA, a hierarchical memory organization framework for efficient navigation and retrieval.
      • Structures experience into layered representations to reduce loss and latency in unstructured retrieval.
      • Improves performance and efficiency in long-horizon dialogue tasks.
    
  
  
    2026-06-05
    Position: Hippocampal Explicit Memory Is the Cornerstone for AGI
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Argues that explicit hippocampal-like memory is fundamental for achieving AGI-level capabilities.
      • Claims implicit statistical learning alone is insufficient for planning, reasoning, and meta-cognition.
      • Outlines computational requirements for implementing explicit memory systems in AI.
    
  
  
    2026-06-09
    Trace Only What You Need: Structure-Aware On-Demand Hypergraph Memory for Long-Document Question Answering
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Introduces DocTrace, a multi-agent RAG framework with structure-aware hypergraph memory.
      • Builds document structure trees and on-demand shared memory graphs for reasoning reuse.
      • Achieves strong improvements over structured RAG baselines on long-document QA tasks.
    
  
  
    2026-06-09
    REAL: A Reasoning-Enhanced Graph Framework for Long-Term Memory Management of LLMs
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Proposes REAL, a time- and confidence-aware directed graph for long-term memory management.
      • Supports non-destructive updates with multi-version factual memory retention.
      • Achieves +22.72% average improvement in long-term memory tasks.
    
  
  
    2026-06-09
    Infini Memory: Maintainable Topic Documents for Long-Term LLM Agent Memory
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Proposes Infini Memory, which organizes agent memory into maintainable topic-centric documents.
      • Uses buffer-and-consolidation updates to continuously refine semantic memory over time.
      • Enables iterative retrieval via tool-based memory reading rather than single-pass lookup.
    
  
  
    2026-06-09
    ActiveMem: Distributed Active Memory for Long-Horizon LLM Reasoning
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Introduces ActiveMem, decoupling planning and memory systems for long-horizon reasoning tasks.
      • Uses lightweight planners with distributed memory modules running in parallel.
      • Improves efficiency while achieving state-of-the-art performance on complex benchmarks.
    
  
  
    2026-06-08
    Memory Beyond Recall: A Dual-Process Cognitive Memory System for Self-Evolving LLM Agents
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Proposes DCPM, a dual-process memory system separating explicit and implicit cognitive memory layers.
      • Uses day-time writing and night-time consolidation mechanisms for long-term evolution.
      • Demonstrates strong performance in cross-session reasoning and personalization tasks.
    
  
  
    2026-06-10
    MemToolAgent: Leveraging Memory for Tool Using Agents Based on Environment and User Feedback
    
      
      
      
      
    
    
      
        
      
    
  
  
    
      • Proposes MemToolAgent, which enhances tool-using agents via structured memory extraction and retrieval.
      • Converts past interactions into reusable memory entries for continuous improvement.
      • Improves personalization and task accuracy through memory-augmented reasoning.
    
  
  
    2026-06-05
    AdMem: Advanced Memory for Task-solving Agents
    
      
      
      
    
    
      
        
      
    
  
  
    
      • Proposes AdMem, a unified memory framework integrating semantic, episodic, and procedural memory.
      • Uses multi-agent coordination for memory generation, reward annotation, and adaptive retrieval.
      • Improves robustness and success rate in long-horizon task-solving scenarios.
    
  
  
    2026-06-04
    AdaMEM: Test-Time Adaptive Memory for Language Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Addresses the difficulty of using past experience when language agents face dynamic test-time conditions.
      • Combines offline long-term trajectory memory with online short-term policy memory to guide decisions.
      • Shows consistent gains over static memory baselines, highlighting test-time adaptation as a practical memory direction.
    
  
  
    2026-06-04
    Ask Only When Needed: Proactive Retrieval from Memory and Skills for Experience-Driven Lifelong Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Studies when a lifelong agent should consult prior experience rather than always retrieving memory.
      • Organizes experience into factual, episodic, and skill memory, and learns retrieval as an explicit policy action.
      • Improves task success while reducing unnecessary interactions, showing the value of proactive memory control.
    
  
  
    2026-06-04
    Beyond Semantic Organization: Memory as Execution State Management for Long-Horizon Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Argues that semantic similarity alone fragments decision trajectories in long-horizon agent tasks.
      • Proposes MAGE, a hierarchical execution-state tree with grow, compress, maintain, and revise operations.
      • Improves task success and reduces token use by preserving valid state paths and isolating erroneous branches.
    
  
  
    2026-06-04
    Beyond Similarity: Trustworthy Memory Search for Personal AI Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Identifies semantic-similarity memory search as a trust boundary for personal AI agents.
      • Introduces MemGate, a lightweight query-conditioned gate that decides whether retrieved memories should enter context.
      • Reduces cross-domain leakage, sycophancy, tool drift, and memory-induced jailbreak risks while preserving utility.
    
  
  
    2026-06-04
    EMBER: Efficient Memory via Budgeted Evidence Retention for Long-Horizon Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Focuses on which evidence should survive when long-horizon agents have fixed retained-memory budgets.
      • Learns to store source-backed evidence capsules with retrieval keys and update metadata during ingestion.
      • Improves retained-evidence recall and answer quality, showing that memory quality depends on budgeted evidence survival.
    
  
  
    2026-06-04
    Membrane: A Self-Evolving Contrastive Safety Memory for LLM Agent Defense
    
      
      
      
      
    
    
      
    
  
  
    
      • Targets evolving jailbreak attacks where static safety classifiers and naive memory guardrails are insufficient.
      • Builds contrastive safety memory cells pairing harmful queries with superficially similar benign requests.
      • Improves agent-level defense while reducing over-refusal and maintaining robustness under memory poisoning.
    
  
  
    2026-06-04
    Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Challenges the static retrieve-then-reason pipeline used by many memory-augmented agents.
      • Represents memory as a Cue-Tag-Content graph and lets the agent actively reconstruct relevant paths during reasoning.
      • Outperforms strong baselines on long-memory benchmarks while reducing token and runtime cost.
    
  
  
    2026-06-04
    TOKI: A Bitemporal Operator Algebra for Contradiction Resolution in LLM-Agent Persistent Memory
    
      
      
      
      
    
    
      
    
  
  
    
      • Treats contradiction resolution in persistent agent memory as a write-time consistency problem.
      • Defines bitemporal operators with explicit isolation assumptions, provenance annotations, and audit rows.
      • Clarifies the correctness contract needed by production memory systems when beliefs evolve or conflict.
    
  
  
    2026-06-03
    ABBEL: Learning Natural-Language Belief States for Memory-Efficient Interaction
    
      
      
      
      
    
    
      
    
  
  
    
      • Addresses the cost of keeping full interaction histories in long sequential decision tasks.
      • Learns recursively updated natural-language belief states and directly supervises their information content.
      • Reduces summary errors and memory footprint, narrowing the gap with full-context agents.
    
  
  
    2026-06-03
    PersonaTree: Structured Lifecycle Memory for Person Understanding in LLM Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Focuses on building durable person understanding from long-term interactions.
      • Organizes evidence, claims, confidence, and query-conditioned paths into a structured persona tree.
      • Improves personalization by returning only the evidence depth needed for each query.
    
  
  
    2026-06-03
    RAMPART: Registry-based Agentic Memory with Priority-Aware Runtime Transformation
    
      
      
      
      
    
    
      
    
  
  
    
      • Addresses runtime context assembly for LLM agents with explicit memory policies.
      • Defines a registry-based memory model with primitives such as promote, gate, write, evict, and rollback.
      • Shows that grouping and priority management of memory blocks can improve task success across models.
    
  
  
    2026-06-03
    Scaling Self-Evolving Agents via Parametric Memory
    
      
      
      
      
    
    
      
    
  
  
    
      • Addresses the limitation that retrieval memories influence prompts but rarely change future agent behavior.
      • Compresses historical experience into explicit memory and uses lightweight online updates as parametric memory.
      • Establishes a scaling direction for agents that continuously improve after deployment.
    
  
  
    2026-06-03
    Temporal Order Matters for Agentic Memory: Segment Trees for Long-Horizon Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Argues that event order is central to long-horizon memory but often lost in similarity-based organization.
      • Introduces SegTreeMem, an online segment-tree structure that preserves temporal order while forming hierarchical memory.
      • Improves long-memory answering and shows performance depends on keeping order during memory construction.
    
  
  
    2026-06-03
    Topology Matters: Measuring Memory Leakage in Multi-Agent LLMs
    
      
      
      
      
    
    
      
    
  
  
    
      • Studies how graph topology affects leakage of private information across multi-agent LLM systems.
      • Introduces MAMA with Engram seeding and Resonance extraction phases over controlled synthetic PII documents.
      • Finds denser connectivity, shorter distance, and higher target centrality increase leakage risk.
    
  
  
    2026-06-02
    DMF: A Deterministic Memory Framework for Conversational AI Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Targets nondeterminism and token cost in LLM-summary-based conversational memory pipelines.
      • Uses classical NLP, vector geometry, mathematical scoring, survival scores, and decay rules.
      • Achieves competitive accuracy while reducing token usage and improving reproducibility.
    
  
  
    2026-06-02
    InfoMem: Training Long-Context Memory Agents with Answer-Conditioned Information Gain
    
      
      
      
      
    
    
      
    
  
  
    
      • Addresses sparse rewards in training chunk-wise memory agents for long-context tasks.
      • Uses answer-conditioned information gain to evaluate whether final memory supports the ground-truth answer.
      • Provides a more targeted training signal for deciding what information should be retained.
    
  
  
    2026-06-02
    MemTrain: Self-Supervised Context Memory Training
    
      
      
      
      
    
    
      
    
  
  
    
      • Targets the lack of high-quality labeled data for training memory agents.
      • Uses self-supervised masked reconstruction and intermediate memory recall objectives on unlabeled corpora.
      • Improves memory-intensive reasoning on long-text and search-based QA tasks.
    
  
  
    2026-06-02
    RGMem: Renormalization Group-inspired Memory Evolution for Language Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Targets long-term user-state modeling under evolving and potentially conflicting conversational evidence.
      • Uses a renormalization-group-inspired multi-scale process with hierarchical coarse-graining and thresholded updates.
      • Improves cross-session continuity and adaptation to changing user preferences over flat retrieval or static summaries.
    
  
  
    2026-06-02
    SaliMory: Orchestrating Cognitive Memory for Conversational Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Addresses memory-related failures in conversational agents by supervising memory operations more explicitly.
      • Uses hierarchical staged rewards and contrastive refinement to train filtering, consolidation, and recall behavior.
      • Improves end-to-end accuracy and personalization while reducing memory-operation errors.
    
  
  
    2026-06-02
    Training-Free Lexical-Dense Fusion for Conversational-Memory Retrieval
    
      
      
      
      
    
    
      
    
  
  
    
      • Studies retrieval over multi-session conversational history where lexical and semantic cues have complementary strengths.
      • Combines BM25 with dense late-interaction scoring without additional training.
      • Improves controllable, reproducible retrieval for multi-hop, temporal, and adversarial memory questions.
    
  
  
    2026-06-01
    DELTAMEM: Incremental Experience Memory for LLM Agents via Residual Trees
    
      
      
      
      
    
    
      
    
  
  
    
      • Targets redundancy and retrieval conflict when agents accumulate many task experiences.
      • Organizes goal-conditioned experience and scene-level knowledge into residual trees with self-organization.
      • Enables compact experience reconstruction and improves performance across interactive environments.
    
  
  
    2026-06-01
    Memory Retrieval for Changing Preferences
    
      
      
      
      
    
    
      
    
  
  
    
      • Addresses personalization when user preferences change and older memories may conflict with newer evidence.
      • Formulates retrieval as selecting historical turns that provide evidence about the latent preference state.
      • Outperforms embedding-only retrieval in preference-dense long-context dialogue tasks.
    
  
  
    2026-05-31
    Don't Ask the LLM to Track Freshness: A Deterministic Recipe for Memory Conflict Resolution
    
      
      
      
      
    
    
      
    
  
  
    
      • Shows that LLM-based judgment is unreliable for resolving freshness conflicts in evolving memory.
      • Replaces direct LLM tracking with candidate extraction and version-aware deterministic aggregation.
      • Improves conflict resolution and clarifies that aggregation, not storage, is the main bottleneck.
    
  
  
    2026-05-31
    Honest Lying: Understanding Memory Confabulation in Reflexive Agents
    
      
      
      
      
    
    
      
    
  
  
    
      • Studies how reflexive agents may store false self-explanations as persistent memory.
      • Introduces diagnostic signals for reflection dependence and replaces open-ended self-diagnosis with trajectory-level failure extraction.
      • Reduces confabulated memory use across environments and improves the reliability of reflective agents.
    
  
  
    2026-05-31
    Joint Agent Memory and Exploration Learning via Novelty Signals
    
      
      
      
      
    
    
      
    
  
  
    
      • Explores the mutual dependence between memory and exploration in open-ended agent environments.
      • Uses novelty-driven interaction to jointly train memory and exploration policies.
      • Improves generalization in unseen environments while reducing token consumption.
    
  
  
    2026-05-30
    MemPro: Agentic Memory Systems as Evolvable Programs
    
      
      
      
      
    
    
      
    
  
  
    
      • Challenges fixed memory construction-retrieval pipelines that stop improving after deployment.
      • Treats the entire memory system as an evolvable program with version trees and failure-driven edits.
      • Shows memory pipelines can continuously improve across benchmarks through iterative diagnosis and debugging.
    
  
  
    2026-05-07
    Belief Memory: Agent Memory Under Partial Observability
    
      
      
      
      
    
    
      
    
  
  
    
      • Proposes BeliefMem, a memory framework that shifts the memory paradigm from storing deterministic conclusions to maintaining an attribute-level belief representation to combat self-reinforcing errors in partially observable environments.
      • Maintains multiple candidate conclusions with probabilities updated via Noisy-OR evidence merge, and features a belief-aware retrieval mechanism to preserve uncertainty for agent decision-making.
      • Demonstrates superior average performance on the LoCoMo and ALFWorld benchmarks over existing deterministic memory methods, showing strong memory correction capabilities and data efficiency.
    
  
  
    2026-05-07
    MemReranker: Reasoning-Aware Reranking for Agent Memory Retrieval
    
      
      
      
      
    
    
      
    
  
  
    
      • Proposes MemReranker (0.6B/4B), a family of reasoning-aware reranking models for agent memory systems that moves beyond simple semantic matching by leveraging a multi-stage LLM knowledge distillation pipeline.
      • Combines Elo/Bradley-Terry calibrated scoring, BCE pointwise distillation, and InfoNCE contrastive fine-tuning to achieve well-calibrated relevance scores and hard-sample discrimination.
      • Demonstrates state-of-the-art performance on memory retrieval benchmarks (LOCOMO, LongMemEval), matching the ranking quality of larger closed-source models (e.g., GPT-4o-mini) with significantly lower inference latency.
    
  
  
    2026-05-07
    Event-Causal RAG: A Retrieval-Augmented Generation Framework for Long Video Reasoning in Complex Scenarios
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proposes Event-Causal RAG (EC-RAG), a lightweight framework for infinite long-video reasoning that asynchronously segments video streams into semantically complete events and abstracts them into State-Event-State (SES) graph memory, replacing traditional fixed-length clip memory.
      • Designs a Dual-Store Memory system integrating a vector database for semantic matching and a graph database for causal-topological retrieval, achieving low-overhead storage and efficient spatiotemporal memory merging in streaming environments.
      • Introduces a bidirectional graph retrieval strategy to efficiently identify relevant event causal chains, significantly improving causal reasoning accuracy and preventing out-of-memory issues without requiring expensive long-sequence fine-tuning of backbone video foundation models.
    
  
  
    2026-05-06
    Tree-based Credit Assignment for Multi-Agent Memory System
    
      
      
      
      
    
    
      
    
  
  
    
      • Proposes TreeMem, a tree-based reinforcement learning framework for multi-agent memory systems that derives agent-specific credit directly from final downstream rewards without task-specific annotations.
      • Expands each memory agent's (builder, summarizer, retrieval) outputs into multiple subsequent branches, estimating the contributions of intermediate actions via Monte Carlo averaging.
      • Converts coarse final rewards into granular optimization signals, enabling heterogeneous memory agents to specialize effectively and outperforming strong baselines on long-horizon benchmarks.
    
  
  
    2026-05-05
    MemFlow: Intent-Driven Memory Orchestration for Small Language Model Agents
    
    
    
    
    
    
    
    
    
    
  
  
    
    • Proposes MemFlow, a training-free memory orchestration framework for Small Language Models (SLMs) that replaces open-ended reasoning loops with intent-driven memory routing to handle long-horizon memory tasks.
    • Features a specialized multi-agent pipeline (Router, Memory, Answer, and Validator) with dynamic context packing to ensure deterministic evidence preparation and grounded responses under strict token budgets.
    
  
  
    2026-05-05
    Governed Collaborative Memory as Artificial Selection in LLM-Based Multi-Agent Systems
    
      
      
      
      
    
    
      
    
  
  
    
      • Proposes governed collaborative memory as an artificial selection regime for LLM-based multi-agent systems, determining which candidate memories persist as durable, shared institutional state.
      • Introduces a layered architecture separating agent-local, shared institutional, archive, and project-continuity memory, emphasizing memory evaluation for provenance fidelity, selection traceability, and role preservation.
    
  
  
    2026-05-05
    Learning to Forget -- Hierarchical Episodic Memory for Lifelong Robot Deployment
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proposes H²-EMV, a hierarchical episodic memory framework for lifelong robot deployment that uses LLM-based relevance judgment and selective forgetting to manage memory scale.
      • Integrates user feedback to update natural-language forgetting rules, achieving personalized memory management while maintaining QA accuracy and reducing query overhead.
    
  
  
    2026-05-05
    MEMSAD: Gradient-Coupled Anomaly Detection for Memory Poisoning in Retrieval-Augmented Agents
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Formalizes multiple attack scenarios for persistent external memory poisoning in retrieval-augmented agents and proposes MEMSAD, a semantic anomaly detection defense.
      • Proves via gradient-coupling theorem that anomaly score gradients align with retrieval objective gradients, enabling certifiable detection radii and optimal calibration sample complexity.
    
  
  
    2026-05-05
    ScrapMem: A Bio-inspired Framework for On-device Personalized Agent Memory via Optical Forgetting
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Introduces ScrapMem, a bio-inspired on-device agent memory framework that uses optical forgetting to progressively reduce old memory resolution for storage efficiency.
      • Constructs an Episodic Memory Graph with causal-temporal event links to maintain semantic consistency, achieving superior retrieval performance on ATM-Bench with significantly lower storage cost.
    
  
  
    2026-05-04
    A Semantic Autonomy Framework for VLM-Integrated Indoor Mobile Robots: Hybrid Deterministic Reasoning and Cross-Robot Adaptive Memory
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proposes the Semantic Autonomy Stack (SAS), a six-layer framework for VLM-integrated indoor robots, featuring a hybrid reasoning mechanism that resolves routine instructions deterministically to bypass VLM inference latency.
      • Introduces a five-category semantic memory framework that compiles learned preferences into a shared digest, enabling cross-session learning and cross-robot knowledge transfer without retraining.
    
  
  
    2026-05-04
    The Dynamic Gist-Based Memory Model (DGMM): A Memory-Centric Architecture for Artificial Intelligence
    
    
    
    
    
    
    
    
    
    
  
  
    
    • Proposes the Dynamic Gist-Based Memory Model (DGMM), a memory-centric architectural framework that represents experience as an explicit, persistent, and graph-structured episodic-semantic memory.
    • Formally characterizes memory operations into four distinct regimes (ingestion, consolidation, recall, and analysis), decoupling memory storage from downstream interpretation.
    • Defines architectural invariants such as episodic persistence and locality of cue-conditioned surprise, enabling stable memory structures to support evolving interpretation over time without retraining.
    
  
  
    2026-05-04
    MAGE: Safeguarding LLM Agents against Long-Horizon Threats via Shadow Memory
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proposes MAGE, inspired by shadow stack in system security, maintaining an independent safety memory that distills and preserves critical security context across long task trajectories.
      • Evaluates pending actions against the safety memory before execution, enabling earlier detection of long-horizon attacks with minimal impact on agent utility.
    
  
  
    2026-05-04
    Symmetry-Protected Lyapunov Neutral Modes in Equivariant Recurrent Networks
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proves that group-orbit tangent directions in equivariant recurrent networks produce symmetry-protected zero Lyapunov exponents, forming long-lived neutral memory modes.
      • Demonstrates through S¹, T^q, SO(n), U(m) systems and equivariant RNN experiments that strict equivariance enhances long-range memory retention, generalization, and stability.
    
  
  
    2026-05-03
    Planner Matters! An Efficient and Unbalanced Multi-agent Collaboration Framework for Long-horizon Planning
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proposes an unbalanced multi-agent collaboration framework with planner, actor, and memory manager roles, showing that planning contributes most to task performance.
      • Introduces planner-only RL optimization with trajectory-level rewards, validated on web navigation, system control, and tool-use benchmarks for efficient long-horizon automation.
    
  
  
    2026-05-02
    MemORAI: Memory Organization and Retrieval via Adaptive Graph Intelligence for LLM Conversational Agents
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proposes MemORAI, a memory organization and retrieval framework that utilizes selective memory filtering with dual-layer compression to retain user-persona-relevant content and preserve global context.
      • Constructs a provenance-enriched multi-relational knowledge graph to track factual origins at the turn level, enabling fine-grained and transparent memory auditing.
      • Introduces Dynamic Weighted PageRank for query-adaptive subgraph retrieval, applying query-conditioned edge weighting to significantly improve context-sensitive retrieval precision and personalized response generation.
    
  
  
    2026-05-01
    From Unstructured Recall to Schema-Grounded Memory: Reliable AI Memory via Iterative, Schema-Aware Extraction
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Argues AI memory should be schema-constrained rather than retrieval-based recall, proposing an iterative schema-aware write pipeline with object detection, field detection, and value extraction.
      • Adds verification, retry, and state control to the ingestion process, outperforming baselines on structured extraction and end-to-end memory tasks requiring stable facts and state updates.
    
  
  
    2026-05-01
    Learning How and What to Memorize: Cognition-Inspired Two-Stage Optimization for Evolving Memory
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proposes MemCoE, a cognition-inspired two-stage optimization framework: stage one induces global memory criteria via contrastive feedback, stage two uses multi-round RL to learn criteria-compliant memory evolution strategies.
      • Validates on three personalized memory benchmarks, demonstrating improvements in preference memory, robustness, transferability, and efficiency.
    
  
  
    2026-04-30
    Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses
    
      
      
      
      
      
    
    
      
    
  
  
    
      • Proposes AHE, an observability-driven closed-loop mechanism that automatically evolves coding-agent harnesses across component, experience, and decision layers.
      • Compresses large trajectory volumes into usable evidence via self-prediction and outcome verification, significantly improving coding-agent performance with cross-model transferability.
    
  
  
    2026-04-30
    EviMem: Evidence-Gap-Driven Iterative Retrieval for Long-Term Conversational Memory