MemEngine: A Unified and Modular Library for Developing Advanced Memory of LLM-based Agents

Quanyu Dai; Rui Li; Xu Chen; Zeyu Zhang; Zhenhua Dong; Zhongyang Li

REVIEW 3 major objections 5 minor 2 cited by

MemEngine: A Unified and Modular Library for Developing Advanced Memory of LLM-based Agents

T0 review · 3 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper introduces MemEngine, a library that reimplements nine published memory models for LLM-based agents under one modular, pluggable framework.

desk verdict A tidy, honest systems paper for a memory library; the real gap is verification that the nine reimplemented models actually behave like the originals. read the letter →

arxiv 2505.02099 v1 pith:H4MRRMGL submitted 2025-05-04 cs.AI

Zeyu Zhang , Quanyu Dai , Xu Chen , Rui Li , Zhongyang Li , Zhenhua Dong This is my paper · ORCID

classification cs.AI

keywords LLM-basedagentsagentmemorymodelsmodularlibraryunifiedframeworkoperationsfunctionsMemEngine

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper introduces MemEngine, a library that reimplements nine published memory models for large-language-model agents inside one framework, and claims this is the first such unified implementation. The point is to let developers switch memory models, tune their prompts and hyper-parameters, and build new models from shared building blocks without rewriting agent code. A sympathetic reader would treat the contribution as an engineering standardization: instead of each research model living in its own non-pluggable pipeline, memory becomes a modular component with common interfaces.

What carries the argument

The central object is the three-level hierarchy of memory functions, memory operations, and memory models. Each level is modular and reuses lower levels: functions are the atoms, operations are the reactions, and models are the molecules. A configuration module lets users adjust hyper-parameters and prompts at any level, and a utility module handles storage, visualization, remote clients, and automatic model selection. This hierarchy is what turns memory from a fixed component into a pluggable, customizable one.

What would settle it

Run the original implementation of any one of the nine models and MemEngine's reimplementation on identical task traces and check whether stored, recalled, and optimized memory contents match; any divergence beyond documented configuration differences would show that the 'reasonable adaptations' are not faithful.

Watch

Extended reading notes

Core claim

MemEngine organizes memory into three hierarchical levels. The lowest level, memory functions, provides primitive abilities such as encoding, retrieval, reflection, summarization, triggering, utilization, forgetting, truncation, judging, and LLM calls. The middle level, memory operations, combines functions into pipelines such as store, recall, manage, and optimize. The top level, memory models, assembles operations to reproduce the behavior of nine research models: full-context memory, long-term and short-term memory, generative-agents-style weighted retrieval with self-reflection, memory-bank-style summarization with forgetting, self-controlled recall, operating-system-style hierarchical memory, trajectory-optimization memory, and tree-structured memory. The paper states that all models expose the same interfaces and can be switched, configured, and deployed locally or remotely.

Load-bearing premise

The load-bearing premise is that the nine reimplementations, which the paper says involve 'reasonable adaptations', genuinely reproduce the original models' behavior, even though no evaluation, unit tests, or comparisons are reported.

Editorial extensions

If this is right

Researchers can swap one memory model for another in an agent with minimal code changes, making model comparisons a configuration change.
New memory models can be assembled by reusing existing operations and functions, reducing duplicated implementation of retrieval, summarization, and reflection.
The same memory service can be deployed locally or on a server and accessed remotely, allowing lightweight devices to offload memory.
The library's compatibility layer means agents built in other frameworks can adopt MemEngine's memory without rewriting their own memory logic.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If the reimplementations are faithful, MemEngine effectively turns memory-model selection into an empirical hyper-parameter choice, which could accelerate ablation studies across a large class of agent memory designs.
Because the paper reports no evaluation of the reimplementations, the library's scientific value depends on a validation suite comparing each model to its original; that suite is a natural immediate addition.
The function-level modularity points toward multimodal memory: new encoders, retrievers, and storage backends could be added without changing the operation and model layers.
Standardizing nine models under one interface may reveal which memory operations contribute most to agent performance, since all other components can be held fixed.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Worth knowing: this is a short systems paper for MemEngine, a Python library that unifies memory implementations for LLM agents under a three-level abstraction: functions, operations, and models. It ships nine memory models from the literature (Generative Agents, MemoryBank, MemGPT, Reflexion, etc.), plus configuration, utilities, local/remote deployment, and AutoGPT compatibility. The paper is honest about being an engineering contribution: no quantitative claims, no experiments, just the artifact and its design. The comparison table against existing agent libraries and independent memory libraries is genuinely useful for practitioners trying to choose a memory layer.

The three-level abstraction is the main intellectual contribution, and it is well explained. Lower-level functions (encoder, retrieval, reflector, summarizer, judge, LLM interface) compose into operations (store, recall, manage, optimize), which compose into complete models. That is a clean decomposition, and it makes the library's extensibility plausible. The documentation and repo are linked, which is more than many systems papers do.

Soft spots, in proportion. The central claim — 'first library that implements a wide variety of memory models under a unified framework' — rests on the nine reimplementations being faithful. Section 3.2 says only 'reasonable adaptations' and defers to docs. No unit tests, no side-by-side comparisons with original code or papers, no demonstration that core mechanisms survive. If GAMemory's weighted retrieval with recency/importance/relevance plus self-reflection is actually implemented, fine; but if it has been replaced by a generic store/recall wrapper, the claim weakens. This is the evidentiary gap. It is not a fatal flaw for a systems paper — the code is the evidence — but the paper alone does not establish fidelity. Minor: 'first library' is a hard claim to prove, and the self-citations in the intro ([11], [13]) are not load-bearing, so no circularity concern.

The paper is for practitioners building LLM agents who want pluggable memory without reimplementing ten models. A serious referee should check the repo, probe one or two model implementations against the original papers, and ask the authors to add a small verification table (which original component maps to which operation/function).

My recommendation: send it to peer review. It is a legitimate engineering contribution with a public artifact, and the design is clean. I would accept with minor revisions conditional on the authors either providing a reproducibility appendix or explicitly narrowing the fidelity claim. If they cannot show that the models actually match their sources, the 'abundant memory implementation' bullet should be softened.

Referee Report

3 major / 5 minor

Summary. The paper presents MemEngine, a Python library that aims to provide a unified, modular framework for memory components in LLM-based agents. The library organizes memory into three levels (functions, operations, and models) and claims to implement nine memory models from prior research, including Generative Agents, MemoryBank, SCM, MemGPT, Reflexion, and MemTree. The paper describes the architecture, compares MemEngine with existing agent-memory libraries, and illustrates usage modes (default, configurable, automatic) and deployment options (local and remote). No experimental evaluation, unit tests, or comparisons with original implementations are included. The central claim, stated in Section 1, is that MemEngine is the first library to implement a wide variety of research memory models under a unified and modular framework.

Significance. If the implementation is faithful to the cited memory models, MemEngine could be a useful resource for the LLM-agent community, lowering the cost of experimenting with different memory mechanisms. The paper's strengths are its concrete artifact (public repository and documentation), its modular three-level design, and its comparison table covering both agent libraries and standalone memory libraries. These strengths do not, however, substitute for validation: the central claim that MemEngine 'implements' the listed research models is only as strong as the fidelity of the reimplementations, and the manuscript provides no evidence of that fidelity. The modular abstraction itself is sensible, and the paper is clearly written, but the absence of tests or behavioral comparisons leaves the core claim unverified.

major comments (3)

[Section 3.2] The paper's central claim is that MemEngine implements a wide variety of memory models from research works, but the only statement about implementation fidelity is that 'we make some reasonable adaptations in their implementations' (Section 3.2), with details deferred to documentation and source code. The nine models include nontrivial mechanisms from the original papers, such as GAMemory's weighted retrieval with self-reflection, MBMemory's dynamic summarization and forgetting trigger, and MGMemory's operating-system-style paging between memory tiers. Without unit tests, behavioral comparisons against the original implementations, or a precise specification of the adaptations, the reader cannot verify that MemEngine actually reproduces these mechanisms rather than providing generic store-and-recall wrappers. This is a load-bearing gap for the central claim and should be addressed before publication, for example by adding a validation section or an appendix that documents each adaptation and shows that the core behavior of each model is preserved.
[Section 1 and Section 2] The claim that MemEngine is 'the first library that implements a wide variety of memory models from research works under a unified and modular framework' is a strong negative claim that is not established by the comparison in Section 2 and Table 1. Table 1 uses subjective categories such as 'Comprehensive Default Models' and 'Advanced Model Customization' without definitions or external evidence, and it does not rule out other libraries (e.g., later versions of Zep or MemoryScope) from satisfying these criteria. The authors should either temper the 'first' claim, define the criteria precisely, or provide reproducible evidence that competing libraries lack the stated capabilities.
[Section 4.1] The 'automatic mode' is described as automatically selecting memory models, hyper-parameters, and prompts based on 'a specific task's criteria,' but no algorithm, search procedure, or evaluation metric is specified anywhere in the paper. Since automatic selection is one of the library's advertised user-facing features, and since no experiments demonstrate that the automatic selector produces sensible choices, this part of the 'user-friendly' claim is unsupported. The authors should either describe the selection mechanism or remove this claim from the list of supported features.

minor comments (5)

[Section 2] MemoryScope and Zep appear in Table 1 but are not introduced in the text; the list of independent memory libraries in Section 2 mentions only Memary, Cognee, Mem0, and Agentmemory. Please add a sentence describing MemoryScope and Zep for consistency.
[Section 3.2] FUMemory, LTMemory, and STMemory are listed among the implemented memory models, but unlike the other six models, they are not associated with any cited research work. If they are baselines rather than research models, this should be stated explicitly.
[Section 3.5] The phrase 'statistic manners' should be 'static manners'.
[Section 4.1] The tool name 'vllm' should be capitalized as 'vLLM'.
[Section 1] The qualifier 'first' appears twice without a scope or a reference to a systematic search; consider adding 'to our knowledge' and citing the sources for the comparison.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: MemEngine is an artifact/software paper with no fitted parameters, derived predictions, or self-citation chain bearing on the central claim.

full rationale

The paper's central claim (Section 1: 'MemEngine is the first library that implements a wide variety of memory models from research works under a unified and modular framework') is a software-engineering and novelty claim, not the output of a derivation. There are no equations, no fitted parameters, and no quantity is predicted from data, so the self-definitional and fitted-input patterns cannot apply. The only potential concern is fidelity of the reimplementations: Section 3.2 says 'we make some reasonable adaptations in their implementations' and defers details to documentation and source code, with no unit tests or comparison against the original models. That is an evidentiary and verification gap about faithfulness, not a circular reduction: the claim that the models are implemented does not presuppose the claim that they are effective or faithful, and no benchmark result is being predicted from the adaptations. Two self-citations ([11], [13]) appear in the Introduction to support general statements that agents are widely applied and that memory is critical; neither is load-bearing for the library's design or for the 'first library' claim. No circular step can be exhibited, so the score is 0.

Assumptions & free parameters 0 free parameters · 3 assumptions · 0 invented entities

This is an engineering paper, so there are no fitted free parameters or invented theoretical entities. The central claim rests on architectural assumptions: that the modular decomposition is expressive enough, that reimplementations preserve original model behavior, and that external backends work as expected.

assumptions (3)

domain assumption The three-level hierarchy (functions, operations, models) is sufficient to express and unify all implemented memory models.
Section 3.1 introduces this hierarchy as the organizing principle; no proof is given that every memory model fits this decomposition.
domain assumption The 'reasonable adaptations' made when reimplementing published models preserve the essential behavior and effectiveness of the originals.
Section 3.2 states adaptations are made, but no evaluation verifies fidelity.
domain assumption LLM and embedding backends (e.g., E5) behave as expected within the library.
Section 3.4 relies on pre-trained models and LLMs as building blocks.

how reviews work

0 comments

Cite this review

Pith. "Pith review of MemEngine: A Unified and Modular Library for Developing Advanced Memory of LLM-based Agents." pith.science (2026). https://pith.science/paper/H4MRRMGL

@misc{pith2026250502099,
  author       = {Pith},
  title        = {Pith review of: MemEngine: A Unified and Modular Library for Developing Advanced Memory of LLM-based Agents},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/H4MRRMGL}},
  note         = {Machine review of arXiv:2505.02099}
}

read the original abstract

Recently, large language model based (LLM-based) agents have been widely applied across various fields. As a critical part, their memory capabilities have captured significant interest from both industrial and academic communities. Despite the proposal of many advanced memory models in recent research, however, there remains a lack of unified implementations under a general framework. To address this issue, we develop a unified and modular library for developing advanced memory models of LLM-based agents, called MemEngine. Based on our framework, we implement abundant memory models from recent research works. Additionally, our library facilitates convenient and extensible memory development, and offers user-friendly and pluggable memory usage. For benefiting our community, we have made our project publicly available at https://github.com/nuster1128/MemEngine.

Figures

Figures reproduced from arXiv: 2505.02099 by the authors.

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

MemTools: A Unified Research Framework for Interoperable Agent Memory
cs.CL 2026-07 conditional novelty 5.0 of 10

MemTools decouples agent-memory lifecycle stages via declarative data contracts, separates evaluation protocols from benchmark datasets, and unifies symbolic, neural, and multimodal memory in one runtime, enabling hyb...
Learn to Memorize: Optimizing LLM-based Agents with Adaptive Memory Framework
cs.LG 2025-08 conditional novelty 5.0 of 10

A learnable memory cycle with adaptive retrieval, merging, and storage, trained online, improves LLM agent accuracy on HotpotQA and MemDaily for most backbones.

Reference graph

Works this paper leans on

14 extracted references · 6 canonical work pages · cited by 2 Pith papers

[11]

Lei Wang, Chen Ma, Xueyang Feng, Zeyu Zhang, Hao Yang, Jingsen Zhang, Zhiyuan Chen, Jiakai Tang, Xu Chen, Yankai Lin, et al. 2024. A survey on large language model based autonomous agents. FCS 18, 6 (2024), 186345

work page 2024
[13]

Zeyu Zhang, Xiaohe Bo, Chen Ma, Rui Li, Xu Chen, Quanyu Dai, Jieming Zhu, Zhenhua Dong, and Ji-Rong Wen. 2024. A survey on the memory mechanism of large language model based agents. arXiv preprint arXiv:2404.13501 (2024)

arXiv 2024
[1]

Weize Chen, Yusheng Su, Jingwei Zuo, Cheng Yang, Chenfei Yuan, Chi-Min Chan, Heyang Yu, Yaxi Lu, Yi-Hsin Hung, Chen Qian, et al. 2023. Agentverse: Facilitating multi-agent collaboration and exploring emergent behaviors. InICLR

work page 2023
[2]

Dawei Gao, Zitao Li, Xuchen Pan, Weirui Kuang, Zhijian Ma, Bingchen Qian, Fei Wei, Wenhao Zhang, Yuexiang Xie, Daoyuan Chen, et al. 2024. Agentscope: A flexible yet robust multi-agent platform. arXiv preprint arXiv:2402.14034 (2024)

arXiv 2024
[3]

Sirui Hong, Xiawu Zheng, Jonathan Chen, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, et al . 2023. Metagpt: Meta programming for multi-agent collaborative framework. arXiv preprint arXiv:2308.00352 (2023)

arXiv 2023
[4]

Guohao Li, Hasan Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023. Camel: Communicative agents for" mind" exploration of large language model society. NeurIPS 36 (2023), 51991–52008

work page 2023
[5]

Zhiwei Liu, Weiran Yao, Jianguo Zhang, Liangwei Yang, Zuxin Liu, Juntao Tan, Prafulla K Choubey, Tian Lan, Jason Wu, Huan Wang, et al . 2024. AgentLite: A Lightweight Library for Building and Advancing Task-Oriented LLM Agent System. arXiv preprint arXiv:2402.15538 (2024)

arXiv 2024
[6]

Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G Patil, Ion Stoica, and Joseph E Gonzalez. 2023. Memgpt: Towards llms as operating systems. arXiv preprint arXiv:2310.08560 (2023)

arXiv 2023

Show all 14 references

[7]

Joon Sung Park, Joseph O’Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang, and Michael S Bernstein. 2023. Generative agents: Interactive simulacra of human behavior. In UIST. 1–22

2023
[8]

Alireza Rezazadeh, Zichao Li, Wei Wei, and Yujia Bao. 2024. From Isolated Conversations to Hierarchical Schemas: Dynamic Tree Memory Representation for LLMs. arXiv preprint arXiv:2410.14052 (2024)

2024 arXiv
[9]

Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. 2024. Reflexion: Language agents with verbal reinforcement learning. NeurIPS 36 (2024)

2024
[10]

Bing Wang, Xinnian Liang, Jian Yang, Hui Huang, Shuangzhi Wu, Peihao Wu, Lu Lu, Zejun Ma, and Zhoujun Li. 2023. Enhancing large language model with self-controlled memory framework. arXiv preprint arXiv:2304.13343 (2023)

2023 arXiv
[12]

Liang Wang, Nan Yang, Xiaolong Huang, Binxing Jiao, Linjun Yang, Daxin Jiang, Rangan Majumder, and Furu Wei. 2022. Text embeddings by weakly-supervised contrastive pre-training. arXiv preprint arXiv:2212.03533 (2022)

2022 arXiv
[14]

Wanjun Zhong, Lianghong Guo, Qiqi Gao, He Ye, and Yanlin Wang. 2024. Mem- orybank: Enhancing large language models with long-term memory. In AAAI, Vol. 38. 19724–19731. 11https://www.mindspore.cn/

2024

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.

[1] [11]

Lei Wang, Chen Ma, Xueyang Feng, Zeyu Zhang, Hao Yang, Jingsen Zhang, Zhiyuan Chen, Jiakai Tang, Xu Chen, Yankai Lin, et al. 2024. A survey on large language model based autonomous agents. FCS 18, 6 (2024), 186345

work page 2024

[2] [13]

Zeyu Zhang, Xiaohe Bo, Chen Ma, Rui Li, Xu Chen, Quanyu Dai, Jieming Zhu, Zhenhua Dong, and Ji-Rong Wen. 2024. A survey on the memory mechanism of large language model based agents. arXiv preprint arXiv:2404.13501 (2024)

arXiv 2024

[3] [1]

Weize Chen, Yusheng Su, Jingwei Zuo, Cheng Yang, Chenfei Yuan, Chi-Min Chan, Heyang Yu, Yaxi Lu, Yi-Hsin Hung, Chen Qian, et al. 2023. Agentverse: Facilitating multi-agent collaboration and exploring emergent behaviors. InICLR

work page 2023

[4] [2]

Dawei Gao, Zitao Li, Xuchen Pan, Weirui Kuang, Zhijian Ma, Bingchen Qian, Fei Wei, Wenhao Zhang, Yuexiang Xie, Daoyuan Chen, et al. 2024. Agentscope: A flexible yet robust multi-agent platform. arXiv preprint arXiv:2402.14034 (2024)

arXiv 2024

[5] [3]

Sirui Hong, Xiawu Zheng, Jonathan Chen, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, et al . 2023. Metagpt: Meta programming for multi-agent collaborative framework. arXiv preprint arXiv:2308.00352 (2023)

arXiv 2023

[6] [4]

Guohao Li, Hasan Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023. Camel: Communicative agents for" mind" exploration of large language model society. NeurIPS 36 (2023), 51991–52008

work page 2023

[7] [5]

Zhiwei Liu, Weiran Yao, Jianguo Zhang, Liangwei Yang, Zuxin Liu, Juntao Tan, Prafulla K Choubey, Tian Lan, Jason Wu, Huan Wang, et al . 2024. AgentLite: A Lightweight Library for Building and Advancing Task-Oriented LLM Agent System. arXiv preprint arXiv:2402.15538 (2024)

arXiv 2024

[8] [6]

Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G Patil, Ion Stoica, and Joseph E Gonzalez. 2023. Memgpt: Towards llms as operating systems. arXiv preprint arXiv:2310.08560 (2023)

arXiv 2023