Agent memory

Overview

An agent that acts over many steps needs a way to keep what happened and bring back the part that matters for the next decision. The survey defines agent memory as three operations applied to stored items: writing, management and reading 2404.13501 §3.4. Every design in the survey is a choice of where the information comes from, what form it is stored in, and how each operation is carried out.

The survey's narrow definition keeps only the history of the current trial. Its broad definition also draws on earlier trials, earlier tasks and external knowledge 2404.13501 §3.2 2404.13501 §3.3. The LLM itself is treated as a fixed function from memory and context to the next action, so the memory design sits around the model 2404.13501 §3.4.

A perspective on biomedical agents gives the same idea a module role. It lists memory as one of four modules of a compound agent, next to perception, interaction and reasoning. Short-term memory sits in the context window or in latent embeddings. Long-term memory sits in the weights or in an external store, and can be updated by fine-tuning, interactive learning, model editing, or by editing the store itself 2404.02831 §5.3. The paper reports no experiments, so it gives the vocabulary but no evidence for these options.

Once several agents or tools share one memory, a written item can be read and acted on by others before anyone checks it. A wrong note can then lead to an action that cannot be undone 2607.23929 §1. The survey's write operation has no separate check step 2404.13501 §3.4, so this is a gap that the variant under "Admission of writes" addresses.

Variants

Each variant is a choice along one of four axes. The survey gives no benchmark that compares them, so the choices are listed here as design axes, not as ranked options.

Source of the memory

• Inside the current trial. The history of the present task. Almost all systems in the survey use it, but it cannot carry knowledge across tasks 2404.13501 §5.1.1.
• Across trials. Summaries of earlier attempts, successful and failed, and the lessons drawn from them. Reflexion is the main example and Retroformer trains the reflection model 2404.13501 §5.1.2. Card: Zhang et al., agent memory survey.
• External knowledge. Sources such as an encyclopedia, a game wiki, an API or a database. It gives facts the agent could not collect itself, and an API call can cut down on outdated knowledge 2404.13501 §5.1.3.

Form of the memory

• Textual, complete. The whole history is concatenated into the prompt. It is the simplest form, and its cost grows with the length of the history 2404.13501 §5.2.1.
• Textual, recent. Only the last few steps or a time window are kept, based on the principle of locality 2404.13501 §5.2.1.
• Textual, retrieved. Entries are embedded when written, scored against the current query when read, and the top-K are placed in the prompt. The survey leaves the similarity function open; Generative Agents combines similarity with recency and importance, and MemoryBank uses a dense retriever with FAISS indexing 2404.13501 §5.2.1.
• Parametric, fine-tuning. Domain knowledge is injected into the weights with supervised training, often with LoRA. The survey notes the risk of catastrophic forgetting and the cost of repeating training 2404.13501 §5.2.2.
• Parametric, editing. Only the facts that change are edited, and other knowledge is left alone. The survey lists MAC, MEND and KnowledgeEditor 2404.13501 §5.2.2. See model editing.

Textual memory is more interpretable and cheaper to write. Parametric memory is cheaper to read, because it adds nothing to the prompt. The survey states this as its reasoning and gives no measurements 2404.13501 §5.2.3.

Operations

• Writing turns the latest action and observation into a stored item. The item may be the raw observation or a summary. Examples are an entity relation kept in a database (TiM) and topic keys (MemoChat) 2404.13501 §5.3.1.
• Management merges similar items, reflects to form higher-level items, or forgets unimportant ones. Examples are daily summaries (MemoryBank) and reflection that runs once enough events have built up (Generative Agents) 2404.13501 §5.3.2.
• Reading selects what the next action needs. The survey says this is usually a similarity computation. Examples are SQL queries (ChatDB) and top-K examples (ExpeL) 2404.13501 §5.3.3.

Admission of writes

This axis is about whether a written item is trusted at once. The survey does not treat it as a separate design choice, so the two options below come from the MemTX paper.

• Direct write. The item is stored and can be read as soon as it is written. This is how the surveyed designs work 2404.13501 §3.4.
• Staged, checked and committed. A write starts as a tentative record. It becomes a belief only after four checks: evidence, validity window, semantic conflict with a belief already accepted, and no revoked ancestor 2607.23929 §3.2. Irreversible tool calls are blocked while any unsettled record the transaction did not read exists 2607.23929 §3.3. Withdrawing a belief revokes its descendants by type: beliefs are revoked, derived views are rebuilt, and tool actions are compensated or logged as leaks 2607.23929 §3.4. Card: MemTX.

When to use which

The survey gives no thresholds. It does not say at what history length a design should change, so measure your own agent before choosing. The MemTX results are on its authors' own suites, so measure your own tool set too.

Implementation sketch

The loop is the same for all variants: write, manage, read, then act. The variants differ in what write, manage and read do, as the survey's unified formula shows 2404.13501 §3.4. The survey does not say whether reading comes before or after management, so the order is a choice to make and test.

# One agent step with a memory  [arxiv:2404.13501 §3.4]
# Input:  memory M; the latest action and observation; the next context
# Output: updated memory M; next action

def agent_step(memory, action, observation, next_context):
    # Write: turn the raw interaction into a stored item  [§5.3.1]
    item = write(action, observation)
    # Manage: merge, reflect or forget over the stored items  [§5.3.2]
    memory = manage(memory, item)
    # Read: pick what the next action needs  [§5.3.3]
    recalled = read(memory, next_context)
    # Act: the LLM is a fixed function of the recalled memory  [§3.4]
    next_action = llm(recalled, next_context)
    return memory, next_action

For retrieved textual memory, read embeds the query, scores each entry, and keeps the top K. Take K and the similarity function from your own tests, since the survey does not fix either 2404.13501 §5.2.1.

If the memory is shared and feeds irreversible tools, put a gate in front of those tools. MemTX blocks the call while any tentative record is unsettled and the transaction did not read it 2607.23929 §3.3.

# Action gate for one irreversible tool call  [arxiv:2607.23929 §3.3]
# Reversible tools are not gated.
def gate_allows(tx, store):
    # Block while an unsettled record exists that this transaction did not read  [§3.3]
    for record in store.records:
        if record.state == "tentative" and record.id not in tx.snapshot:
            return False
    return True

Evaluation

The survey splits evaluation into two parts 2404.13501 §6.

• Direct tests check the memory alone. Human judges can rate coherence and rationality. Objective measures are result correctness, reference accuracy as an F1 score against the memory that should have been used, and the time and peak GPU memory of each operation 2404.13501 §6.1.
• Indirect tests measure the agent's task result, with and without the memory, as an ablation 2404.13501 §6.2.

The survey notes that no open benchmark targets agent memory alone 2404.13501 §6.3. MemTX builds its own suites instead: 90 scripted cases with 60 traps and 30 controls, and a 56-case hardened suite 2607.23929 §4. Its scorer is rule-based, and all systems in its comparison share one harness, so only the memory manager differs 2607.23929 §4.

Two reported effects of memory design come from a multi-agent simulation rather than a benchmark. Both are author-reported, use nine gpt-3.5-turbo agents in one simulated world, and report no external baseline. Memory depth has a negative correlation with convergence time (r = −0.3836, p < 0.001, N = 83) 2406.14373 §7.4. Removing memory is reported with convergence times of 21 and 36 days, but the text does not say which setting is which 2406.14373 §7.5. Treat these as a hint to measure memory depth, not as a tuned value.

Contradictions

None known. The three cards measure different things: the survey classifies designs and runs no experiments, the simulation measures convergence in one world, and MemTX measures task success and harm on its own suites. No card reports a number that another card disputes.

Papers

• Zhang et al., agent memory survey: a survey that defines agent memory by its write, manage and read operations and classifies 28 systems by source, form and operation. It runs no experiments.
• Gao et al., AI agents for biomedical discovery: a perspective that sorts biomedical agents into four autonomy levels and names memory as one of four modules. It reports no experiments.
• Artificial Leviathan: a simulation of nine LLM agents with a 30-action memory; it reports memory depth and deletion effects on convergence. It is a thought experiment, not a memory benchmark.
• MemTX: a commit protocol for shared agent memory with staged writes, an action gate and typed cascading repair. Results are on the authors' own suites. The repository has no license, so only the method is described here.