A-Mem: Agentic Memory for LLM Agents 

 1 Introduction 

 2 Related Work 

 2.1 Memory for LLM Agents 

 2.2 Retrieval-Augmented Generation 

 3 Methodolodgy 

 3.1 Note Construction 

 3.2 Link Generation 

 3.3 Memory Evolution 

 3.4 Retrieve Relative Memory 

 4 Experiment 

 4.1 Dataset and Evaluation 

 4.2 Implementation Details 

 4.3 Empricial Results 

 4.4 Ablation Study 

 4.5 Hyperparameter Analysis 

 4.6 Scaling Analysis 

 4.7 Memory Analysis 

 5 Conclusions 

 6 Limitations 

 A Experiment 

 A.1 Detailed Baselines Introduction 

 A.2 Evaluation Metric 

 A.3 Comparison Results 

 A.4 Memory Analysis 

 A.5 Hyperparameters setting 

 B Prompt Templates and Examples 

 B.1 Prompt Template of Note Construction 

 B.2 Prompt Template of Link Generation 

 B.3 Prompt Template of Memory Evolution 

 B.4 Examples of Q/A with A-Mem 

A-Mem: Agentic Memory for LLM Agents

Wujiang Xu 1 ,
Zujie Liang 2 ,
Kai Mei 1 ,
Hang Gao 1 ,
Juntao Tan 1 ,
Yongfeng Zhang 1,3 

 1 Rutgers University    2 Independent Researcher    3 AIOS Foundation    

 wujiang.xu@rutgers.edu 

Abstract

While large language model (LLM) agents can effectively use external tools for complex real-world tasks, they require memory systems to leverage historical experiences. Current memory systems enable basic storage and retrieval but lack sophisticated memory organization, despite recent attempts to incorporate graph databases. Moreover, these systems’ fixed operations and structures limit their adaptability across diverse tasks. To address this limitation, this paper proposes a novel agentic memory system for LLM agents that can dynamically organize memories in an agentic way. Following the basic principles of the Zettelkasten method, we designed our memory system to create interconnected knowledge networks through dynamic indexing and linking. When a new memory is added, we generate a comprehensive note containing multiple structured attributes, including contextual descriptions, keywords, and tags. The system then analyzes historical memories to identify relevant connections, establishing links where meaningful similarities exist. Additionally, this process enables memory evolution – as new memories are integrated, they can trigger updates to the contextual representations and attributes of existing historical memories, allowing the memory network to continuously refine its understanding. Our approach combines the structured organization principles of Zettelkasten with the flexibility of agent-driven decision making, allowing for more adaptive and context-aware memory management.
Empirical experiments on six foundation models show superior improvement against existing SOTA baselines.

 Code for Benchmark Evaluation : 

 https://github.com/WujiangXu/AgenticMemory 

 Code for Production-ready Agentic Memory : 

 https://github.com/WujiangXu/A-mem-sys 

 1 Introduction

Large Language Model (LLM) agents have demonstrated remarkable capabilities in various tasks, with recent advances enabling them to interact with environments, execute tasks, and make decisions autonomously [ 23 , 33 , 7 ] . They integrate LLMs with external tools and delicate workflows to improve reasoning and planning abilities. Though LLM agent has strong reasoning performance, it still needs a memory system to provide long-term interaction ability with the external environment [ 35 ] .

Existing memory systems [ 25 , 39 , 28 , 21 ] for LLM agents provide basic memory storage functionality. These systems require agent developers to predefine memory storage structures, specify storage points within the workflow, and establish retrieval timing.
Meanwhile, to improve structured memory organization, Mem0 [ 8 ] , following the principles of RAG [ 9 , 18 , 30 ] , incorporates graph databases for storage and retrieval processes. While graph databases provide structured organization for memory systems, their reliance on predefined schemas and relationships fundamentally limits their adaptability. This limitation manifests clearly in practical scenarios - when an agent learns a novel mathematical solution, current systems can only categorize and link this information within their preset framework, unable to forge innovative connections or develop new organizational patterns as knowledge evolves. Such rigid structures, coupled with fixed agent workflows, severely restrict these systems’ ability to generalize across new environments and maintain effectiveness in long-term interactions. The challenge becomes increasingly critical as LLM agents tackle more complex, open-ended tasks, where flexible knowledge organization and continuous adaptation are essential. Therefore, how to design a flexible and universal memory system that supports LLM agents’ long-term interactions remains a crucial challenge.

 (a) Traditional memory system.

 (b) Our proposed agentic memory.

 Figure 1 : Traditional memory systems require predefined memory access patterns specified in the workflow, limiting their adaptability to diverse scenarios. Contrastly, our A-Mem enhances the flexibility of LLM agents by enabling dynamic memory operations. 

In this paper, we introduce a novel agentic memory system, named as A-Mem , for LLM agents that enables dynamic memory structuring without relying on static, predetermined memory operations. Our approach draws inspiration from the Zettelkasten method [ 15 , 1 ] , a sophisticated knowledge management system that creates interconnected information networks through atomic notes and flexible linking mechanisms.
Our system introduces an agentic memory architecture that enables autonomous and flexible memory management for LLM agents. For each new memory, we construct comprehensive notes, which integrates multiple representations: structured textual attributes including several attributes and embedding vectors for similarity matching.
Then A-Mem analyzes the historical memory repository to establish meaningful connections based on semantic similarities and shared attributes. This integration process not only creates new links but also enables dynamic evolution when new memories are incorporated, they can trigger updates to the contextual representations of existing memories, allowing the entire memories to continuously refine and deepen its understanding over time.
The contributions are summarized as:

We present A-Mem , an agentic memory system for LLM agents that enables autonomous generation of contextual descriptions, dynamic establishment of memory connections, and intelligent evolution of existing memories based on new experiences. This system equips LLM agents with long-term interaction capabilities without requiring predetermined memory operations.

We design an agentic memory update mechanism where new memories automatically trigger two key operations: link generation and memory evolution. Link generation automatically establishes connections between memories by identifying shared attributes and similar contextual descriptions. Memory evolution enables existing memories to dynamically adapt as new experiences are analyzed, leading to the emergence of higher-order patterns and attributes.

We conduct comprehensive evaluations of our system using a long-term conversational dataset, comparing performance across six foundation models using six distinct evaluation metrics, demonstrating significant improvements. Moreover, we provide T-SNE visualizations to illustrate the structured organization of our agentic memory system.

 2 Related Work

 2.1 Memory for LLM Agents

Prior works on LLM agent memory systems have explored various mechanisms for memory management and utilization [ 23 , 21 , 8 , 39 ] . Some approaches complete interaction storage, which maintains comprehensive historical records through dense retrieval models [ 39 ] or read-write memory structures [ 24 ] . Moreover, MemGPT [ 25 ] leverages cache-like architectures to prioritize recent information. Similarly, SCM [ 32 ] proposes a Self-Controlled Memory framework that enhances LLMs’ capability to maintain long-term memory through a memory stream and controller mechanism.
However, these approaches face significant limitations in handling diverse real-world tasks. While they can provide basic memory functionality, their operations are typically constrained by predefined structures and fixed workflows. These constraints stem from their reliance on rigid operational patterns, particularly in memory writing and retrieval processes. Such inflexibility leads to poor generalization in new environments and limited effectiveness in long-term interactions. Therefore, designing a flexible and universal memory system that supports agents’ long-term interactions remains a crucial challenge.

 2.2 Retrieval-Augmented Generation

Retrieval-Augmented Generation (RAG) has emerged as a powerful approach to enhance LLMs by incorporating external knowledge sources [ 18 , 6 , 10 ] . The standard RAG [ 37 , 34 ] process involves indexing documents into chunks, retrieving relevant chunks based on semantic similarity, and augmenting the LLM’s prompt with this retrieved context for generation. Advanced RAG systems [ 20 , 12 ] have evolved to include sophisticated pre-retrieval and post-retrieval optimizations.
Building upon these foundations, recent researches has introduced agentic RAG systems that demonstrate more autonomous and adaptive behaviors in the retrieval process. These systems can dynamically determine when and what to retrieve [ 4 , 14 ] , generate hypothetical responses to guide retrieval, and iteratively refine their search strategies based on intermediate results [ 31 , 29 ] .

However, while agentic RAG approaches demonstrate agency in the retrieval phase by autonomously deciding when and what to retrieve [ 4 , 14 , 38 ] , our agentic memory system exhibits agency at a more fundamental level through the autonomous evolution of its memory structure. Inspired by the Zettelkasten method, our system allows memories to actively generate their own contextual descriptions, form meaningful connections with related memories, and evolve both their content and relationships as new experiences emerge. This fundamental distinction in agency between retrieval versus storage and evolution distinguishes our approach from agentic RAG systems, which maintain static knowledge bases despite their sophisticated retrieval mechanisms.

 3 Methodolodgy

Our proposed agentic memory system draws inspiration from the Zettelkasten method, implementing a dynamic and self-evolving memory system that enables LLM agents to maintain long-term memory without predetermined operations. The system’s design emphasizes atomic note-taking, flexible linking mechanisms, and continuous evolution of knowledge structures.

 Figure 2 : Our A-Mem architecture comprises three integral parts in memory storage. During note construction, the system processes new interaction memories and stores them as notes with multiple attributes. The link generation process first retrieves the most relevant historical memories and then employs an LLM to determine whether connections should be established between them. The concept of a ’box’ describes that related memories become interconnected through their similar contextual descriptions, analogous to the Zettelkasten method. However, our approach allows individual memories to exist simultaneously within multiple different boxes. During the memory retrieval stage, we extract query embeddings using a text encoding model and search the memory database for relevant matches. When related memory is retrieved, similar memories that are linked within the same box are also automatically accessed. 

 3.1 Note Construction

Building upon the Zettelkasten method’s principles of atomic note-taking and flexible organization, we introduce an LLM-driven approach to memory note construction. When an agent interacts with its environment, we construct structured memory notes that capture both explicit information and LLM-generated contextual understanding. Each memory note m i m_{i} in our collection ℳ = { m 1 , m 2 , … , m N } \mathcal{M}=\{m_{1},m_{2},...,m_{N}\} is represented as:

 m i = { c i , t i , K i , G i , X i , e i , L i } m_{i}=\{c_{i},t_{i},K_{i},G_{i},X_{i},e_{i},L_{i}\} 

 (1) 

where c i c_{i} represents the original interaction content, t i t_{i} is the timestamp of the interaction, K i K_{i} denotes LLM-generated keywords that capture key concepts, G i G_{i} contains LLM-generated tags for categorization, X i X_{i} represents the LLM-generated contextual description that provides rich semantic understanding, and L i L_{i} maintains the set of linked memories that share semantic relationships.
To enrich each memory note with meaningful context beyond its basic content and timestamp, we leverage an LLM to analyze the interaction and generate these semantic components. The note construction process involves prompting the LLM with carefully designed templates P s ​ 1 P_{s1} :

 K i , G i , X i ​ LLM ​ ( c i ​ \Vert ​ t i ​ \Vert ​ P s ​ 1 ) K_{i},G_{i},X_{i}\leftarrow\text{LLM}(c_{i}\;\Vert t_{i}\;\Vert P_{s1}) 

 (2) 

Following the Zettelkasten principle of atomicity, each note captures a single, self-contained unit of knowledge. To enable efficient retrieval and linking, we compute a dense vector representation via a text encoder [ 27 ] that encapsulates all textual components of the note:

 e i = f enc ​ [ concat ​ ( c i , K i , G i , X i ) ] e_{i}=f_{\text{enc}}[\;\text{concat}(c_{i},K_{i},G_{i},X_{i})\;] 

 (3) 

By using LLMs to generate enriched components, we enable autonomous extraction of implicit knowledge from raw interactions. The multi-faceted note structure ( K i K_{i} , G i G_{i} , X i X_{i} ) creates rich representations that capture different aspects of the memory, facilitating nuanced organization and retrieval. Additionally, the combination of LLM-generated semantic components with dense vector representations provides both context and computationally efficient similarity matching.

 3.2 Link Generation

Our system implements an autonomous link generation mechanism that enables new memory notes to form meaningful connections without predefined rules. When the constrctd memory note m n m_{n} is added to the system, we first
leverage its semantic embedding for similarity-based retrieval.
For each existing memory note m j ​ ℳ m_{j}\in\mathcal{M} , we compute a similarity score:

 s n , j = e n ​ e j | e n | ​ | e j | s_{n,j}=\frac{e_{n}\cdot e_{j}}{|e_{n}||e_{j}|} 

 (4) 

The system then identifies the top- k k most relevant memories:

 ℳ near n = { m j | rank ​ ( s n , j ) ​ k , m j ​ ℳ } \mathcal{M}_{\text{near}}^{n}=\{m_{j}|\;\text{rank}(s_{n,j})\leq k,m_{j}\in\mathcal{M}\} 

 (5) 

Based on these candidate nearest memories, we prompt the LLM to analyze potential connections based on their potential common attributes. Formally, the link set of memory m n m_{n} update like:

 L i ​ LLM ​ ( m n ​ \Vert ​ ℳ near n ​ \Vert ​ P s ​ 2 ) L_{i}\leftarrow\text{LLM}(m_{n}\;\Vert\mathcal{M}_{\text{near}}^{n}\;\Vert P_{s2}) 

 (6) 

Each generated link l i l_{i} is structured as:
 L i = { m i , … , m k } L_{i}=\{m_{i},...,m_{k}\} .
By using embedding-based retrieval as an initial filter, we enable efficient scalability while maintaining semantic relevance. A-Mem can quickly identify potential connections even in large memory collections without exhaustive comparison.
More importantly, the LLM-driven analysis allows for nuanced understanding of relationships that goes beyond simple similarity metrics. The language model can identify subtle patterns, causal relationships, and conceptual connections that might not be apparent from embedding similarity alone. We implements the Zettelkasten principle of flexible linking while leveraging modern language models. The resulting network emerges organically from memory content and context, enabling natural knowledge organization.

 3.3 Memory Evolution

After creating links for the new memory, A-Mem evolves the retrieved memories based on their textual information and relationships with the new memory. For each memory m j m_{j} in the nearest neighbor set ℳ near n \mathcal{M}_{\text{near}}^{n} , the system determines whether to update its context, keywords, and tags. This evolution process can be formally expressed as:

 m j ∗ ​ LLM ​ ( m n ​ \Vert ​ ℳ near n ​ m j ​ \Vert ​ m j ​ \Vert ​ P s ​ 3 ) m_{j}^{*}\leftarrow\text{LLM}(m_{n}\;\Vert\mathcal{M}_{\text{near}}^{n}\setminus m_{j}\;\Vert m_{j}\;\Vert P_{s3}) 

 (7) 

The evolved memory m j ∗ m_{j}^{*} then replaces the original memory m j m_{j} in the memory set ℳ \mathcal{M} . This evolutionary approach enables continuous updates and new connections, mimicking human learning processes. As the system processes more memories over time, it develops increasingly sophisticated knowledge structures, discovering higher-order patterns and concepts across multiple memories. This creates a foundation for autonomous memory learning where knowledge organization becomes progressively richer through the ongoing interaction between new experiences and existing memories.

 3.4 Retrieve Relative Memory

In each interaction, our A-Mem performs context-aware memory retrieval to provide the agent with relevant historical information. Given a query text q q from the current interaction, we first compute its dense vector representation using the same text encoder used for memory notes:

 e q = f enc ​ ( q ) e_{q}=f_{\text{enc}}(q) 

 (8) 

The system then computes similarity scores between the query embedding and all existing memory notes in ℳ \mathcal{M} using cosine similarity:

 s q , i = e q ​ e i | e q | ​ | e i | , where ​ e i ​ m i , m i ​ ℳ s_{q,i}=\frac{e_{q}\cdot e_{i}}{|e_{q}||e_{i}|},\text{where}\;e_{i}\in m_{i},\;\forall m_{i}\in\mathcal{M} 

 (9) 

Then we retrieve the k most relevant memories from the historical memory storage to construct a contextually appropriate prompt.

 ℳ retrieved = { m i | rank ​ ( s q , i ) ​ k , m i ​ ℳ } \mathcal{M}_{\text{retrieved}}=\{m_{i}|\text{rank}(s_{q,i})\leq k,m_{i}\in\mathcal{M}\} 

 (10) 

These retrieved memories provide relevant historical context that helps the agent better understand and respond to the current interaction. The retrieved context enriches the agent’s reasoning process by connecting the current interaction with related past experiences stored in the memory system.

 4 Experiment

 4.1 Dataset and Evaluation

To evaluate the effectiveness of instruction-aware recommendation in long-term conversations, we utilize the LoCoMo dataset [ 22 ] , which contains significantly longer dialogues compared to existing conversational datasets [ 36 , 13 ] . While previous datasets contain dialogues with around 1K tokens over 4-5 sessions, LoCoMo features much longer conversations averaging 9K tokens spanning up to 35 sessions, making it particularly suitable for evaluating models’ ability to handle long-range dependencies and maintain consistency over extended conversations.
The LoCoMo dataset comprises diverse question types designed to comprehensively evaluate different aspects of model understanding: (1) single-hop questions answerable from a single session; (2) multi-hop questions requiring information synthesis across sessions; (3) temporal reasoning questions testing understanding of time-related information; (4) open-domain knowledge questions requiring integration of conversation context with external knowledge; and (5) adversarial questions assessing models’ ability to identify unanswerable queries. In total, LoCoMo contains 7,512 question-answer pairs across these categories. Besides, we use a new dataset, named DialSim [ 16 ] , to evaluate the effectiveness of our memory system. It is question-answering dataset derived from long-term multi-party dialogues. The dataset is derived from popular TV shows (Friends, The Big Bang Theory, and The Office), covering 1,300 sessions spann

... [OUTPUT TRUNCATED - 30000 chars omitted out of 80000 total] ...

 1 − r / c if  ​ c ​ r BP=\begin{cases}1&\text{if }c>r\\
e^{1-r/c}&\text{if }c\leq r\end{cases} 

 (15) 

 p n = \slimits@ i ​ \slimits@ k ​ min ⁡ ( h i ​ k , m i ​ k ) \slimits@ i ​ \slimits@ k ​ h i ​ k p_{n}=\frac{\tsum\slimits@_{i}\tsum\slimits@_{k}\min(h_{ik},m_{ik})}{\tsum\slimits@_{i}\tsum\slimits@_{k}h_{ik}} 

 (16) 

Here, c c is candidate length, r r is reference length, h i ​ k h_{ik} is the count of n-gram i in candidate k, and m i ​ k m_{ik} is the maximum count in any reference. In QA, BLEU-1 evaluates the lexical precision of generated answers, particularly useful for generative QA systems where exact matching might be too strict.

ROUGE-L [ 19 ] measures the longest common subsequence between the generated and reference texts.

 ROUGE-L = ( 1 + β 2 ) ​ R l ​ P l R l + β 2 ​ P l \text{ROUGE-L}=\frac{(1+\beta^{2})R_{l}P_{l}}{R_{l}+\beta^{2}P_{l}} 

 (17) 

 R l = LCS ​ ( X , Y ) | X | R_{l}=\frac{\text{LCS}(X,Y)}{|X|} 

 (18) 

 P l = LCS ​ ( X , Y ) | Y | P_{l}=\frac{\text{LCS}(X,Y)}{|Y|} 

 (19) 

where X X is reference text, Y Y is candidate text, and LCS is the Longest Common Subsequence.

ROUGE-2 [ 19 ] calculates the overlap of bigrams between the generated and reference texts.

 ROUGE-2 = \slimits@ bigram ref ​ min ⁡ ( Count ref ​ ( bigram ) , Count cand ​ ( bigram ) ) \slimits@ bigram ref ​ Count ref ​ ( bigram ) \text{ROUGE-2}=\frac{\tsum\slimits@_{\text{bigram}\in\text{ref}}\min(\text{Count}_{\text{ref}}(\text{bigram}),\text{Count}_{\text{cand}}(\text{bigram}))}{\tsum\slimits@_{\text{bigram}\in\text{ref}}\text{Count}_{\text{ref}}(\text{bigram})} 

 (20) 

Both ROUGE-L and ROUGE-2 are particularly useful for evaluating the fluency and coherence of generated answers, with ROUGE-L focusing on sequence matching and ROUGE-2 on local word order.

METEOR [ 5 ] computes a score based on aligned unigrams between the candidate and reference texts, considering synonyms and paraphrases.

 METEOR = F mean ​ ( 1 − Penalty ) \text{METEOR}=F_{\text{mean}}\cdot(1-\text{Penalty}) 

 (21) 

 F mean = 10 ​ P ​ R R + 9 ​ P F_{\text{mean}}=\frac{10P\cdot R}{R+9P} 

 (22) 

 Penalty = 0.5 ​ ( ch m ) 3 \text{Penalty}=0.5\cdot(\frac{\text{ch}}{m})^{3} 

 (23) 

where P P is precision, R R is recall, ch is number of chunks, and m m is number of matched unigrams. METEOR is valuable for QA evaluation as it considers semantic similarity beyond exact matching, making it suitable for evaluating paraphrased answers.

SBERT Similarity [ 27 ] measures the semantic similarity between two texts using sentence embeddings.

 SBERT_Similarity = cos ⁡ ( SBERT ​ ( x ) , SBERT ​ ( y ) ) \text{SBERT\_Similarity}=\cos(\text{SBERT}(x),\text{SBERT}(y)) 

 (24) 

 cos ⁡ ( a , b ) = a ​ b \| ​ a ​ \| ​ \| ​ b ​ \| \cos(a,b)=\frac{a\cdot b}{\|a\|\|b\|} 

 (25) 

SBERT( x x ) represents the sentence embedding of text. SBERT Similarity is particularly useful for evaluating semantic understanding in QA systems, as it can capture meaning similarities even when the lexical overlap is low.

 Table 5 : 
Experimental results on LoCoMo dataset of QA tasks across five categories (Multi Hop, Temporal, Open Domain, Single Hop, and Adversial) using different methods. Results are reported in ROUGE-2 and ROUGE-L scores, abbreviated to RGE-2 and RGE-L. The best performance is marked in bold, and our proposed method A-Mem (highlighted in gray) demonstrates competitive performance across six foundation language models.

 Model 
 Method 
 Category 

 Multi Hop 
 Temporal 
 Open Domain 
 Single Hop 
 Adversial 

 RGE-2 
 RGE-L 
 RGE-2 
 RGE-L 
 RGE-2 
 RGE-L 
 RGE-2 
 RGE-L 
 RGE-2 
 RGE-L 

 GPT 

 4o-mini 

 LoCoMo 
 9.64 
 23.92 
 2.01 
 18.09 
 3.40 
 11.58 
 26.48 
 40.20 
 60.46 
 69.59 

 ReadAgent 
 2.47 
 9.45 
 0.95 
 13.12 
 0.55 
 5.76 
 2.99 
 9.92 
 6.66 
 9.79 

 MemoryBank 
 1.18 
 5.43 
 0.52 
 9.64 
 0.97 
 5.77 
 1.64 
 6.63 
 4.55 
 7.35 

 MemGPT 
 10.58 
 25.60 
 4.76 
 25.22 
 0.76 
 9.14 
 28.44 
 42.24 
 36.62 
 43.75 

 A-Mem 
 10.61 
 25.86 
 21.39 
 44.27 
 3.42 
 12.09 
 29.50 
 45.18 
 42.62 
 50.04 

 4o 

 LoCoMo 
 11.53 
 30.65 
 1.68 
 8.17 
 3.21 
 16.33 
 45.42 
 63.86 
 45.13 
 52.67 

 ReadAgent 
 3.91 
 14.36 
 0.43 
 3.96 
 0.52 
 8.58 
 4.75 
 13.41 
 4.24 
 6.81 

 MemoryBank 
 1.84 
 7.36 
 0.36 
 2.29 
 2.13 
 6.85 
 3.02 
 9.35 
 1.22 
 4.41 

 MemGPT 
 11.55 
 30.18 
 4.66 
 15.83 
 3.27 
 14.02 
 43.27 
 62.75 
 28.72 
 35.08 

 A-Mem 
 12.76 
 31.71 
 9.82 
 25.04 
 6.09 
 16.63 
 33.67 
 50.31 
 30.31 
 36.34 

 Qwen2.5 

 1.5b 

 LoCoMo 
 1.39 
 9.24 
 0.00 
 4.68 
 3.42 
 10.59 
 3.25 
 11.15 
 35.10 
 43.61 

 ReadAgent 
 0.74 
 7.14 
 0.10 
 2.81 
 3.05 
 12.63 
 1.47 
 7.88 
 20.73 
 27.82 

 MemoryBank 
 1.51 
 11.18 
 0.14 
 5.39 
 1.80 
 8.44 
 5.07 
 13.72 
 29.24 
 36.95 

 MemGPT 
 1.16 
 11.35 
 0.00 
 7.88 
 2.87 
 14.62 
 2.18 
 9.82 
 23.96 
 31.69 

 A-Mem 
 4.88 
 17.94 
 5.88 
 27.23 
 3.44 
 16.87 
 12.32 
 24.38 
 36.32 
 46.60 

 3b 

 LoCoMo 
 0.49 
 4.83 
 0.14 
 3.20 
 1.31 
 5.38 
 1.97 
 6.98 
 12.66 
 17.10 

 ReadAgent 
 0.08 
 4.08 
 0.00 
 1.96 
 1.26 
 6.19 
 0.73 
 4.34 
 7.35 
 10.64 

 MemoryBank 
 0.43 
 3.76 
 0.05 
 1.61 
 0.24 
 6.32 
 1.03 
 4.22 
 9.55 
 13.41 

 MemGPT 
 0.69 
 5.55 
 0.05 
 3.17 
 1.90 
 7.90 
 2.05 
 7.32 
 10.46 
 14.39 

 A-Mem 
 2.91 
 12.42 
 8.11 
 27.74 
 1.51 
 7.51 
 8.80 
 17.57 
 21.39 
 27.98 

 Llama 3.2 

 1b 

 LoCoMo 
 2.51 
 11.48 
 0.44 
 8.25 
 1.69 
 13.06 
 2.94 
 13.00 
 39.85 
 52.74 

 ReadAgent 
 0.53 
 6.49 
 0.00 
 4.62 
 5.47 
 14.29 
 1.19 
 8.03 
 34.52 
 45.55 

 MemoryBank 
 2.96 
 13.57 
 0.23 
 10.53 
 4.01 
 18.38 
 6.41 
 17.66 
 41.15 
 53.31 

 MemGPT 
 1.82 
 9.91 
 0.06 
 6.56 
 2.13 
 11.36 
 2.00 
 10.37 
 38.59 
 50.31 

 A-Mem 
 4.82 
 19.31 
 1.84 
 20.47 
 5.99 
 18.49 
 14.82 
 29.78 
 46.76 
 60.23 

 3b 

 LoCoMo 
 0.98 
 7.22 
 0.03 
 4.45 
 2.36 
 11.39 
 2.85 
 8.45 
 25.47 
 30.26 

 ReadAgent 
 2.47 
 1.78 
 3.01 
 3.01 
 5.07 
 5.22 
 3.25 
 2.51 
 15.78 
 14.01 

 MemoryBank 
 1.83 
 6.96 
 0.25 
 3.41 
 0.43 
 4.43 
 2.73 
 7.83 
 14.64 
 18.59 

 MemGPT 
 0.72 
 5.39 
 0.11 
 2.85 
 0.61 
 5.74 
 1.45 
 4.42 
 16.62 
 21.47 

 A-Mem 
 6.02 
 17.62 
 7.93 
 27.97 
 5.38 
 13.00 
 16.89 
 28.55 
 35.48 
 42.25 

 Table 6 : 
Experimental results on LoCoMo dataset of QA tasks across five categories (Multi Hop, Temporal, Open Domain, Single Hop, and Adversial) using different methods. Results are reported in METEOR and SBERT Similarity scores, abbreviated to ME and SBERT. The best performance is marked in bold, and our proposed method A-Mem (highlighted in gray) demonstrates competitive performance across six foundation language models.

 Model 
 Method 
 Category 

 Multi Hop 
 Temporal 
 Open Domain 
 Single Hop 
 Adversial 

 ME 
 SBERT 
 ME 
 SBERT 
 ME 
 SBERT 
 ME 
 SBERT 
 ME 
 SBERT 

 GPT 

 4o-mini 

 LoCoMo 
 15.81 
 47.97 
 7.61 
 52.30 
 8.16 
 35.00 
 40.42 
 57.78 
 63.28 
 71.93 

 ReadAgent 
 5.46 
 28.67 
 4.76 
 45.07 
 3.69 
 26.72 
 8.01 
 26.78 
 8.38 
 15.20 

 MemoryBank 
 3.42 
 21.71 
 4.07 
 37.58 
 4.21 
 23.71 
 5.81 
 20.76 
 6.24 
 13.00 

 MemGPT 
 15.79 
 49.33 
 13.25 
 61.53 
 4.59 
 32.77 
 41.40 
 58.19 
 39.16 
 47.24 

 A-Mem 
 16.36 
 49.46 
 23.43 
 70.49 
 8.36 
 38.48 
 42.32 
 59.38 
 45.64 
 53.26 

 4o 

 LoCoMo 
 16.34 
 53.82 
 7.21 
 32.15 
 8.98 
 43.72 
 53.39 
 73.40 
 47.72 
 56.09 

 ReadAgent 
 7.86 
 37.41 
 3.76 
 26.22 
 4.42 
 30.75 
 9.36 
 31.37 
 5.47 
 12.34 

 MemoryBank 
 3.22 
 26.23 
 2.29 
 23.49 
 4.18 
 24.89 
 6.64 
 23.90 
 2.93 
 10.01 

 MemGPT 
 16.64 
 55.12 
 12.68 
 35.93 
 7.78 
 37.91 
 52.14 
 72.83 
 31.15 
 39.08 

 A-Mem 
 17.53 
 55.96 
 13.10 
 45.40 
 10.62 
 38.87 
 41.93 
 62.47 
 32.34 
 40.11 

 Qwen2.5 

 1.5b 

 LoCoMo 
 4.99 
 32.23 
 2.86 
 34.03 
 5.89 
 35.61 
 8.57 
 29.47 
 40.53 
 50.49 

 ReadAgent 
 3.67 
 28.20 
 1.88 
 27.27 
 8.97 
 35.13 
 5.52 
 26.33 
 24.04 
 34.12 

 MemoryBank 
 5.57 
 35.40 
 2.80 
 32.47 
 4.27 
 33.85 
 10.59 
 32.16 
 32.93 
 42.83 

 MemGPT 
 5.40 
 35.64 
 2.35 
 39.04 
 7.68 
 40.36 
 7.07 
 30.16 
 27.24 
 40.63 

 A-Mem 
 9.49 
 43.49 
 11.92 
 61.65 
 9.11 
 42.58 
 19.69 
 41.93 
 40.64 
 52.44 

 3b 

 LoCoMo 
 2.00 
 24.37 
 1.92 
 25.24 
 3.45 
 25.38 
 6.00 
 21.28 
 16.67 
 23.14 

 ReadAgent 
 1.78 
 21.10 
 1.69 
 20.78 
 4.43 
 25.15 
 3.37 
 18.20 
 10.46 
 17.39 

 MemoryBank 
 2.37 
 17.81 
 2.22 
 21.93 
 3.86 
 20.65 
 3.99 
 16.26 
 15.49 
 20.77 

 MemGPT 
 3.74 
 24.31 
 2.25 
 27.67 
 6.44 
 29.59 
 6.24 
 22.40 
 13.19 
 20.83 

 A-Mem 
 6.25 
 33.72 
 14.04 
 62.54 
 6.56 
 30.60 
 15.98 
 33.98 
 27.36 
 33.72 

 Llama 3.2 

 1b 

 LoCoMo 
 5.77 
 38.02 
 3.38 
 45.44 
 6.20 
 42.69 
 9.33 
 34.19 
 46.79 
 60.74 

 ReadAgent 
 2.97 
 29.26 
 1.31 
 26.45 
 7.13 
 39.19 
 5.36 
 26.44 
 42.39 
 54.35 

 MemoryBank 
 6.77 
 39.33 
 4.43 
 45.63 
 7.76 
 42.81 
 13.01 
 37.32 
 50.43 
 60.81 

 MemGPT 
 5.10 
 32.99 
 2.54 
 41.81 
 3.26 
 35.99 
 6.62 
 30.68 
 45.00 
 61.33 

 A-Mem 
 9.01 
 45.16 
 7.50 
 54.79 
 8.30 
 43.42 
 22.46 
 47.07 
 53.72 
 68.00 

 3b 

 LoCoMo 
 3.69 
 27.94 
 2.96 
 20.40 
 6.46 
 32.17 
 6.58 
 22.92 
 29.02 
 35.74 

 ReadAgent 
 1.21 
 17.40 
 2.33 
 12.02 
 3.39 
 19.63 
 2.46 
 14.63 
 14.37 
 21.25 

 MemoryBank 
 3.84 
 25.06 
 2.73 
 13.65 
 3.05 
 21.08 
 6.35 
 22.02 
 17.14 
 24.39 

 MemGPT 
 2.78 
 22.06 
 2.21 
 14.97 
 3.63 
 23.18 
 3.47 
 17.81 
 20.50 
 26.87 

 A-Mem 
 9.74 
 39.32 
 13.19 
 59.70 
 8.09 
 32.27 
 24.30 
 42.86 
 39.74 
 46.76 

 Table 7 : 
Experimental results on LoCoMo dataset of QA tasks across five categories (Multi Hop, Temporal, Open Domain, Single Hop, and Adversial) using different methods. Results are reported in F1 and BLEU-1 (%) scores with different foundation models.

 Method 
 Category 

 Multi Hop 
 Temporal 
 Open Domain 
 Single Hop 
 Adversial 

 F1 
 BLEU-1 
 F1 
 BLEU-1 
 F1 
 BLEU-1 
 F1 
 BLEU-1 
 F1 
 BLEU-1 

 DeepSeek-R1-32B 

 LoCoMo 
 8.58 
 6.48 
 4.79 
 4.35 
 12.96 
 12.52 
 10.72 
 8.20 
 21.40 
 20.23 

 MemGPT 
 8.28 
 6.25 
 5.45 
 4.97 
 10.97 
 9.09 
 11.34 
 9.03 
 30.77 
 29.23 

 A-Mem 
 15.02 
 10.64 
 14.64 
 11.01 
 14.81 
 12.82 
 15.37 
 12.30 
 27.92 
 27.19 

 Claude 3.0 Haiku 

 LoCoMo 
 4.56 
 3.33 
 0.82 
 0.59 
 2.86 
 3.22 
 3.56 
 3.24 
 3.46 
 3.42 

 MemGPT 
 7.65 
 6.36 
 1.65 
 1.26 
 7.41 
 6.64 
 8.60 
 7.29 
 7.66 
 7.37 

 A-Mem 
 19.28 
 14.69 
 16.65 
 12.23 
 11.85 
 9.61 
 34.72 
 30.05 
 35.99 
 34.87 

 Claude 3.5 Haiku 

 LoCoMo 
 11.34 
 8.21 
 3.29 
 2.69 
 3.79 
 3.58 
 14.01 
 12.57 
 7.37 
 7.12 

 MemGPT 
 8.27 
 6.55 
 3.99 
 2.76 
 4.71 
 4.48 
 16.52 
 14.89 
 5.64 
 5.45 

 A-Mem 
 29.70 
 23.19 
 31.54 
 27.53 
 11.42 
 9.47 
 42.60 
 37.41 
 13.65 
 12.71 

 A.3 Comparison Results

Our comprehensive evaluation using ROUGE-2, ROUGE-L, METEOR, and SBERT metrics demonstrates that A-Mem achieves superior performance while maintaining remarkable computational efficiency. Through extensive empirical testing across various model sizes and task categories, we have established A-Mem as a more effective approach compared to existing baselines, supported by several compelling findings.
In our analysis of non-GPT models, specifically Qwen2.5 and Llama 3.2, A-Mem consistently outperforms all baseline approaches across all metrics. The Multi-Hop category showcases particularly striking results, where Qwen2.5-15b with A-Mem achieves a ROUGE-L score of 27.23, dramatically surpassing LoComo’s 4.68 and ReadAgent’s 2.81 - representing a nearly six-fold improvement. This pattern of superiority extends consistently across METEOR and SBERT scores.
When examining GPT-based models, our results reveal an interesting pattern. While LoComo and MemGPT demonstrate strong capabilities in Open Domain and Adversarial tasks, A-Mem shows remarkable superiority in Multi-Hop reasoning tasks. Using GPT-4o-mini, A-Mem achieves a ROUGE-L score of 44.27 in Multi-Hop tasks, more than doubling LoComo’s 18.09. This significant advantage maintains consistency across other metrics, with METEOR scores of 23.43 versus 7.61 and SBERT scores of 70.49 versus 52.30.
The significance of these results is amplified by A-Mem ’s exceptional computational efficiency. Our approach requires only 1,200-2,500 tokens, compared to the substantial 16,900 tokens needed by LoComo and MemGPT. This efficiency stems from two key architectural innovations: First, our novel agentic memory architecture creates interconnected memory networks through atomic notes with rich contextual descriptions, enabling more effective capture and utilization of information relationships. Second, our selective top-k retrieval mechanism facilitates dynamic memory evolution and structured organization. The effectiveness of these innovations is particularly evident in complex reasoning tasks, as demonstrated by the consistently strong Multi-Hop performance across all evaluation metrics. Besides, we also show the experimental results with different foundational models including DeepSeek-R1-32B [ 11 ] , Claude 3.0 Haiku [ 2 ] and Claude 3.5 Haiku [ 3 ] .

 A.4 Memory Analysis

In addition to the memory visualizations of the first two dialogues shown in the main text, we present additional visualizations in Fig. 5 that demonstrate the structural advantages of our agentic memory system. Through analysis of two dialogues sampled from long-term conversations in LoCoMo [ 22 ] , we observe that A-Mem (shown in blue) consistently produces more coherent clustering patterns compared to the baseline system (shown in red). This structural organization is particularly evident in Dialogue 2, where distinct clusters emerge in the central region, providing empirical support for the effectiveness of our memory evolution mechanism and contextual description generation. In contrast, the baseline memory embeddings exhibit a more scattered distribution, indicating that memories lack structural organization without our link generation and memory evolution components. These visualizations validate that A-Mem can autonomously maintain meaningful memory structures through its dynamic evolution and linking mechanisms.

 (a) Dialogue 3

 (b) Dialogue 4

 (c) Dialogue 5

 (d) Dialogue 6

 (e) Dialogue 7

 (f) Dialogue 8

 (g) Dialogue 9

 (h) Dialogue 10

 Figure 5 : T-SNE Visualization of Memory Embeddings Showing More Organized Distribution with A-Mem (blue) Compared to Base Memory (red) Across Different Dialogues. Base Memory represents A-Mem without link generation and memory evolution. 

 A.5 Hyperparameters setting

All hyperparameter k values are presented in Table 8 . For models that have already achieved state-of-the-art (SOTA) performance with k=10, we maintain this value without further tuning.

 Table 8 : Selection of k values in retriever across specific categories and model choices. 

 Model 
 Multi Hop 
 Temporal 
 Open Domain 
 Single Hop 
 Adversial 

 GPT-4o-mini 
 40 
 40 
 50 
 50 
 40 

 GPT-4o 
 40 
 40 
 50 
 50 
 40 

 Qwen2.5-1.5b 
 10 
 10 
 10 
 10 
 10 

 Qwen2.5-3b 
 10 
 10 
 50 
 10 
 10 

 Llama3.2-1b 
 10 
 10 
 10 
 10 
 10 

 Llama3.2-3b 
 10 
 20 
 10 
 10 
 10 

 Appendix B Prompt Templates and Examples

 B.1 Prompt Template of Note Construction

 The prompt template in Note Construction: P s ​ 1 P_{s1} 

 Generate a structured analysis of the following content by: 

1. Identifying the most salient keywords (focus on nouns, verbs, and key concepts) 

2. Extracting core themes and contextual elements 

3. Creating relevant categorical tags 

Format the response as a JSON object:

{

"keywords": [
// several specific, distinct keywords that capture key concepts and terminology
// Order from most to least important
// Don’t include keywords that are the name of the speaker or time
// At least three keywords, but don’t be too redundant.
],

"context":
// one sentence summarizing:
// - Main topic/domain
// - Key arguments/points
// - Intended audience/purpose
,

"tags": [
// several broad categories/themes for classification
// Include domain, format, and type tags
// At least three tags, but don’t be too redundant.
] 

} 

Content for analysis: 

 B.2 Prompt Template of Link Generation

 The prompt template in Link Generation: P s ​ 2 P_{s2} 

 You are an AI memory evolution agent responsible for managing and evolving a knowledge base.

Analyze the the new memory note according to keywords and context, also with their several nearest neighbors memory.

The new memory context: 

{context}
content: {content} 

keywords: {keywords} 

The nearest neighbors memories:
{nearest_neighbors_memories} 

Based on this information, determine:

Should this memory be evolved? Consider its relationships with other memories. 

 B.3 Prompt Template of Memory Evolution

 The prompt template in Memory Evolution: P s ​ 3 P_{s3} 

 You are an AI memory evolution agent responsible for managing and evolving a knowledge base. 

Analyze the the new memory note according to keywords and context, also with their several nearest neighbors memory. 

Make decisions about its evolution. 

The new memory context:{context}

content: {content} 

keywords: {keywords} 

The nearest neighbors memories:{nearest_neighbors_memories} 

Based on this information, determine: 

1. What specific actions should be taken (strengthen, update_neighbor)? 

1.1 If choose to strengthen the connection, which memory should it be connected to? Can you give the updated tags of this memory? 

1.2 If choose to update neighbor, you can update the context and tags of these memories based on the understanding of these memories. 

Tags should be determined by the content of these characteristic of these memories, which can be used to retrieve them later and categorize them. 

All the above information should be returned in a list format according to the sequence: [[new_memory],[neighbor_memory_1],

...[neighbor_memory_n]] 

These actions can be combined. 

Return your decision in JSON format with the following structure:
{{ 

"should_evolve": true/false, 

"actions": ["strengthen", "merge", "prune"], 

"suggested_connections": ["neighbor_memory_ids"], 

"tags_to_update": ["tag_1",..."tag_n"], 

"new_context_neighborhood": ["new context",...,"new context"], 

"new_tags_neighborhood": [["tag_1",...,"tag_n"],...["tag_1",...,"tag_n"]], 

}} 

 B.4 Examples of Q/A with A-Mem 

 Example: 

 Question 686: Which hobby did Dave pick up in October 2023? 

Prediction: photography 

Reference: photography 

talk start time:10:54 am on 17 November, 2023 

memory content: Speaker Davesays : Hey Calvin, long time no talk! A lot has happened. I’ve taken up photography and it’s been great - been taking pics of the scenery around here which is really cool. 

memory context: The main topic is the speaker’s new hobby of photography, highlighting their enjoyment of capturing local scenery, aimed at engaging a friend in conversation about personal experiences.

memory keywords: [ ’photography’ , ’scenery’, ’conversation’, ’experience’, ’hobby’] 

memory tags: [’hobby’, ’photography’ , ’personal development’, ’conversation’, ’leisure’] 

talk start time:6:38 pm on 21 July, 2023 

memory content: Speaker Calvinsays : Thanks, Dave! It feels great having my own space to work in. I’ve been experimenting with different genres lately, pushing myself out of my comfort zone. Adding electronic elements to my songs gives them a fresh vibe. It’s been an exciting process of self-discovery and growth! 

memory context: The speaker discusses their creative process in music, highlighting experimentation with genres and the incorporation of electronic elements for personal growth and artistic evolution.

memory keywords: [’space’, ’experimentation’, ’genres’, ’electronic’, ’self-discovery’, ’growth’]

memory tags: [’music’, ’creativity’, ’self-improvement’, ’artistic expression’] 

NeurIPS Paper Checklist

The checklist is designed to encourage best practices for responsible machine learning research, addressing issues of reproducibility, transparency, research ethics, and societal impact. Do not remove the checklist: The papers not including the checklist will be desk rejected. The checklist should follow the references and follow the (optional) supplemental material. The checklist does NOT count towards the page
limit.

Please read the checklist guidelines carefully for information on how to answer these questions. For each question in the checklist:

 • 

You should answer [Yes] , [No] , or [N/A] .

 • 

 [N/A] means either that the question is Not Applicable for that particular paper or the relevant information is Not Available.

 • 

Please provide a short (1–2 sentence) justification right after your answer (even for NA).

 The checklist answers are an integral part of your paper submission. They are visible to the reviewers, area chairs, senior area chairs, and ethics reviewers. You will be asked to also include it (after eventual revisions) with the final version of your paper, and its final version will be published with the paper.

The reviewers of your paper will be asked to use the checklist as one of the factors in their evaluation. While " [Yes] " is generally preferable to " [No] ", it is perfectly acceptable to answer " [No] " provided a proper justification is given (e.g., "error bars are not reported because it would be too computationally expensive" or "we were unable to find the license for the dataset we used"). In general, answering " [No] " or " [N/A] " is not grounds for rejection. While the questions are phrased in a binary way, we acknowledge that the true answer is often more nuanced, so please just use your best judgment and write a justification to elaborate. All supporting evidence can appear either in the main paper or the supplemental material, provided in appendix. If you answer [Yes] to a question, in the justification please point to the section(s) where related material for the question can be found.

IMPORTANT, please:

 • 

 Delete this instruction block, but keep the section heading “NeurIPS Paper Checklist" ,

 • 

 Keep the checklist subsection headings, questions/answers and guidelines below. 

 • 

 Do not modify the questions and only use the provided macros for your answers .

 1. 

 Claims 

Question: Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?

Answer: [Yes] 

Justification: The abstract and the introduction summarizes our main contributions.

Guidelines:

 • 

The answer NA means that the abstract and introduction do not include the claims made in the paper.

 • 

The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.

 • 

The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.

 • 

It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.

 2. 

 Limitations 

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes] 

Justification: This paper cover a section of the limiations.

Guidelines:

 • 

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

 • 

The authors are encouraged to create a separate "Limitations" section in their paper.

 • 

The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.

 • 

The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

 • 

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.

 • 

The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.

 • 

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.

 • 

While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren’t acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

 3. 

 Theory assumptions and proofs 

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [N/A] 

Justification: N/A

Guidelines:

 • 

The answer NA means that the paper does not include theoretical results.

 • 

All the theorems, formulas, and proofs in the paper should be numbered and cross-referenced.

 • 

All assumptions should be clearly stated or referenced in the statement of any theorems.

 • 

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.

 • 

Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.

 • 

Theorems and Lemmas that the proof relies upon should be properly referenced.

 4. 

 Experimental result reproducibility 

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes] 

Justification: Both code and datasets are available.

Guidelines:

 • 

The answer NA means that the paper does not include experiments.

 • 

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.

 • 

If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.

 • 

Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

 • 

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

 (a) 

If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

 (b) 

If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

 (c) 

If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).

 (d) 

We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

 5. 

 Open access to data and code 

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes] 

Justification: We provide the code link in the abstract.

Guidelines:

 • 

The answer NA means that paper does not include experiments requiring code.

 • 

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/public/guides/CodeSubmissionPolicy ) for more details.

 • 

While we encourage the release of code and data, we understand that this might not be possible, so “No” is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).

 • 

The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submis