SEDM: Selective Self-Evolving Distributed Memory for Agents

Yichen Liu; Anna Min; Yinzhi Wang; Yuhang Yao; Yichen Han; Rui Zhang; Jiantao He; Zhiheng Li

cs.AISep 11, 2025

SEDM: Selective Self-Evolving Distributed Memory for Agents

Authors: Yichen Liu, Anna Min, Yinzhi Wang, Yuhang Yao, Yichen Han, Rui Zhang, Jiantao He, Zhiheng Li,

Organizations: Gradient · Zhejiang University · Rice University

Abstract

Agents in a society can reuse each other's experience, but indiscriminate memory use increases processing cost and can reduce task success. We present SEDM (Selective Self-Evolving Distributed Memory), a framework that selects both what agents share and when recipients use it. On the sender side, SEDM admits memories through paired execution tests, ranks them by relevance and measured utility, and abstracts them for cross-domain reuse. On the recipient side, Calibrated Memory Gating (CMG) predicts success with and without memory in a single forward pass, learning from paired outcomes including ties. It injects memory only when the calibrated success gain outweighs a context-cost penalty. SEDM exceeds the strongest evaluated baseline on LoCoMo open-domain questions by 15.1 F1 points and outperforms G-Memory on FEVER and HotpotQA with 16-32% fewer prompt tokens. In a controlled HotpotQA study, CMG achieves success comparable to always using memory with 18% fewer agent input tokens. Within the full SEDM pipeline on LoCoMo, CMG outperforms both always-use and no-memory policies for two SEDM memories while using 19-31% fewer input tokens than always-use. These results show that selective use can recover value from shared memories that hurt performance when injected indiscriminately.

Figures & tables

Figure 1: Memory strategies for agent societies. (a) Without memory, agents do not reuse experience. (b) With a fixed memory, all past experiences are stored and retrieved memory is always injected. (c) SEDM is selective on the sender side, through verifiable admission (write) and utility-guided organization, and on the recipient side, where the CMG gate decides whether the receiving agent uses the retrieved memories $M(q)$ .

Figure 2: Full SEDM architecture. SEDM integrates SCEC-based verifiable write admission, utility-aware memory scheduling, cross-domain knowledge diffusion, and calibrated memory gating (CMG), which decides whether to USE or SKIP retrieved memories.

Method	Single Hop		Multi-Hop		Open Domain		Temporal		Adversarial
Method	F1 $\uparrow$	B1 $\uparrow$	F1 $\uparrow$	B1 $\uparrow$	F1 $\uparrow$	B1 $\uparrow$	F1 $\uparrow$	B1 $\uparrow$	F1 $\uparrow$	B1 $\uparrow$
LoCoMo ( Maharana et al., 2024 )	40.4	29.1	25.0	19.8	12.0	11.2	18.4	14.8	69.2	68.8
ReadAgent ( Lee et al., 2024 )	9.7	7.7	9.2	6.5	5.3	5.1	12.6	8.9	9.8	9.0
MemoryBank ( Zhong et al., 2024 )	6.6	5.2	5.0	4.8	5.6	5.9	9.7	7.0	7.4	6.5
MemGPT ( Packer et al., 2024 )	41.0	34.3	26.7	17.7	9.2	7.4	25.5	19.4	43.2	42.7
A-Mem ( Xu et al., 2025 )	44.7	37.1	27.0	20.1	12.1	12.0	45.9	36.7	50.0	49.5

Table 1: Results on LoCoMo. F1: token F1; B1: BLEU-1. Best result per column in bold. SEDM here injects every retrieved memory (no CMG); CMG is evaluated in Sections 4.5 – 4.6 .

	FEVER			HotpotQA
Method	Acc.	Prompt	Compl.	EM	Prompt	Compl.
No memory	57	1.65M	24K	34	2.46M	29K
G-Memory	62	3.62M	109K	38	4.63M	114K
SEDM w/o CMG, adding components
+ SCEC admission	64	2.19M	53K	37	3.52M	52K
+ self-scheduling	66	2.47M	53K	39	3.88M	55K

Table 2: Accuracy and token cost on FEVER and HotpotQA. Prompt/Compl.: total prompt and completion tokens. SEDM rows add components cumulatively. SEDM here injects every retrieved memory (no CMG); CMG is evaluated in Sections 4.5 – 4.6 .

Collect $\downarrow$ / Test $\rightarrow$	FEVER	HotpotQA	LoCoMo
No memory	57	34	–
FEVER	66	41	38.1
HotpotQA	64	39	38.6
LoCoMo	65	34	37.6

Table 3: Cross-domain evaluation of SEDM w/o CMG. Rows give the dataset on which memory is collected, and columns the dataset on which it is tested (FEVER: accuracy; HotpotQA: EM; LoCoMo: overall token F1). The LoCoMo scores come from the original cross-domain runs and are not directly comparable to the per-type scores in Table 1 .

Gate	Success [95% CI]	Injection rate	Agent input tokens	Gate latency (s)
Always skip (no memory)	0.249 [0.213, 0.286]	0%	1,629	–
Always use	0.333 [0.292, 0.376]	100%	3,736	–
Similarity threshold ( $\tau$ = 0.2)	0.333 [0.292, 0.376]	100%	3,736	–
Single-token SFT (winner labels)	0.333 [0.292, 0.376]	100%	3,736	0.24
Winner head (winner labels)	0.333 [0.292, 0.376]	100%	3,736	0.12
CoT gate (generative)	0.262 [0.225, 0.301]	9%	1,734	3.09

Table 4: Gate comparison in the controlled HotpotQA study (test split, 489 questions, seed 42). Token savings are relative to always use. All learned gates share the Qwen3-4B backbone; latency was measured on a shared A40, and the two single-pass heads differ only by server load.

Panel of Figure 3 — Figure 3: Quality–cost trade-off of CMG. Each blue curve sweeps the price $\lambda$ from large (left, memory almost never used) to $\lambda=0$ (right). The dashed line is the expected result of random gating between no memory and always using memory; black squares mark always using memory. (a) HotpotQA test split, seed 42, with the generative CoT gate for reference. (b, c) LoCoMo test conversation, mean of three seeds, for the two SEDM memories. In all three settings the CMG curve lies above random gating.

SEDM memory: admission only
Setting	Succ.	F1	Inj.	Tok.
No memory	0.544	0.556	0%	1,476
SEDM, no gate	0.539	0.564	100%	2,790
SEDM + CMG (val. $\lambda{=}0$ )	0.556	0.577	65%	2,263
SEDM + CMG ( $\lambda{=}0.05$ )	0.568	0.579	30%	1,825
Oracle	0.606	–	–	–

Table 5: CMG inside the full SEDM pipeline on LoCoMo (test conversation 2, 193 questions). CMG rows are means over three seeds. Succ.: SBERT

\geq

0.7; F1: token F1; Inj.: injection rate; Tok.: mean agent input tokens per question. The two “No memory” rows are independent runs of the same agent.

Appendix figures & tables5 assets

Supplementary material from the paper’s appendix.

Appendix

Head	NLL	Brier	ECE
$p_{\textsc{skip}}$	0.543 $\to$ 0.538	0.177 $\to$ 0.177	0.051 $\to$ 0.049
$p_{\textsc{use}}$	0.584 $\to$ 0.579	0.198 $\to$ 0.196	0.060 $\to$ 0.044

Appendix

Table 6: Top: test calibration of CMG before

\to

after temperature scaling (seed 42). Bottom: fitted temperatures and test success rate across seeds. For seed 43, validation selected

\lambda=0.05

Panel of Figure 4 — Figure 4: Injection rate of CMG as the price $\lambda$ grows (test splits, mean of three seeds). The legend gives the effect of always using memory on the test split. The more a memory helps, the more often CMG injects it at every price.

Split	$n$	$S_{\textsc{skip}}$	$S_{\textsc{use}}$	00	01	10 / 11
Train	2,962	0.249	0.307	1,814	409	239 / 500
Validation	496	0.244	0.288	312	63	41 / 80
Calibration	496	0.254	0.310	300	70	42 / 84
Test	489	0.249	0.333	294	73	32 / 90

Appendix

Table 7: Paired outcomes per split. 01: only use succeeds; 10: only skip succeeds.

$\lambda$	Seed 42	Seed 43	Seed 44
0	0.329 / 69%	0.323 / 82%	0.325 / 77%
0.05	0.315 / 40%	0.301 / 45%	0.317 / 56%
0.1	0.288 / 24%	0.282 / 19%	0.305 / 38%
0.2	0.282 / 13%	0.270 / 5%	0.290 / 19%
0.5	0.262 / 3%	0.249 / 0%	0.260 / 2%
1	0.249 / 0%	0.249 / 0%	0.249 / 0%

Appendix

Table 8: Test success / injection rate of calibrated CMG for each

\lambda

and seed. The shape of the curve is stable; the injection rate at a given

\lambda

varies across seeds, so gates are best compared at matched injection rates.

Gate	Success	Injection	Latency (s)
Always skip	0.275	0%	–
Always use	0.245	100%	–
Winner head	0.270	–	–
Single-token SFT	0.270	–	–
CoT gate	0.270	5%	2.70
CMG, $\lambda=0$	0.275	1%	0.06

Appendix

Table 9: Pilot results (200 test questions, seed 42). CMG seeds 42/43/44: 0.275 / 0.275 / 0.255.

LLM Agent Memory

Large language model agent memory lets agents retain, organize, retrieve, and update information across interactions and long-running tasks.

See all 373 papers

Self-Evolving Multi-Agent Systems via Decentralized Memory
May 21, 2026Guangya Hao, Yunbo Long, Zhuokai ZhaoMulti-Agent LLM Systems LLM Agent Memory
University of Cambridge · University of Chicago
MemCodex: Self-Programming Hierarchical Memory for Language Agents
Sep 30, 2026Xiaoqiang Wang, Bang LiuAgent Memory Management Memory-Augmented Language Model Agents
Université de Montréal · Mila – Quebec AI Institute
Towards Autonomous Memory Agents
Feb 25, 2026Xinle Wu, Rui Zhang, Mustafa Anis Hussain +1Memory-Augmented Language Model Agents Memory Management for LLM Agents
National University of Singapore, Singapore

May 21, 2026J/K move · Enter open · S save

Self-Evolving Multi-Agent Systems via Decentralized Memory

Guangya Hao, Yunbo Long, Zhuokai Zhao

University of Cambridge · University of Chicago

Multi-Agent LLM Systems LLM Agent Memory Self-Evolving Agents

Open paper AskPDF arXiv

Self-evolving multi-agent systems (MAS) have emerged as a promising route to LLM agents that continually improve from experience, with persistent memory at their foundation. However, existing designs almost exclusively adopt a centralized repository shared across agents, incurring communication and coordination overhead, raising privacy concerns, and collapsing agent diversity. We propose DecentMem, a decentralized memory framework in which each agent maintains its own dual-pool memory -- an exploitation pool of consolidated past trajectories and an exploration pool of LLM-generated candidates for unseen contexts. The two pools are reweighted online based on stage-wise feedback from an LLM-as-a-judge. Theoretically, we prove that this design guarantees global reachability of the solution space and achieves

O(\log T)

cumulative regret, matching the stochastic bandit lower bound up to constants. In practice, across three MAS frameworks (AutoGen, DyLAN, AgentNet), three Qwen3 backbones (4B/8B/14B), two Gemma4 backbones (E2B/E4B) and five benchmarks spanning math, code, QA, and embodied tasks, DecentMem improves average accuracy by up to 23.8% over the strongest centralized memory baseline and by up to 52.5% over the no-memory baseline, while reducing token usage by up to 49%.

Abstract

LLM Agent Memory

Explore similar work

Self-Evolving Multi-Agent Systems via Decentralized Memory

MemCodex: Self-Programming Hierarchical Memory for Language Agents

Towards Autonomous Memory Agents