betaFeedback

WorksComputer Science

Forget the Lineage: Forward-Secure, Lineage-Complete Cryptographic Erasure for LLM-Agent Memory

Abstract

Large language model (LLM) agents keep a long-term memory that the model itself writes: summaries, extracted facts and embeddings derived from what users said. Deleting a message is therefore not enough: its derivatives, storage residue and backups survive. We define lineage-complete forward-secure erasure: after a forget request, an adversary that later obtains all storage and the agent's current keys learns nothing about the forgotten input or any memory derived from it. We present LinEra, which encrypts each memory under a key derived from its parents' keys along the derivation graph; source keys come from a puncturable pseudorandom function, so forgetting is a single puncture and every descendant becomes unreadable without being located. A sound lineage rule records as parents everything the writer saw, which confines all influence of a source to its descendants. We prove security and lineage integrity and integrate LinEra with mem0. With real LLMs from two families (1.5B to 7B parameters) writing the memory of LoCoMo conversations, an attacker holding every file and the current keys recovers, on all ten conversations written by the largest model, 70 of 71 forgotten secrets after logical deletion, 67 with per-object or epoch keys, and none with LinEra; the same holds for every writer tested. The price is a larger forgetting radius, which follows a simple law in the writer's fan-in: forgetting 1% of turns erases 73.0% of derived memories with session-level summaries but only 3.8% with four-turn windows, which also answer better; re-deriving restores what is lost.

Introduction

Large language model (LLM) agents now keep a long-term memory of their users. Memory layers such as mem0 [1] turn conversations into facts and summaries, store them with their embeddings, and bring them back into later prompts. This memory is personal data, and users can ask to have it erased [2]. Erasure is harder than it looks, because most of the memory was not written by the user: it was written by the model, from what the user said.

Example. Alice tells her assistant that her new door code is 74200. That evening the agent writes a summary of the day and a fact “Alice’s door code is 74200”. A week later it writes a profile entry from that summary. When Alice asks the agent to forget her message, deleting the message is not enough: the fact, the summary and the profile entry still hold the code, and so may the free pages of the database, the vector index and last night’s backup. In our experiments, the 1.5-billion-parameter model that wrote the memory copied the exact secret into a derived memory for 14 of 35 planted secrets, and its topic for 22 of them.

This paper asks a precise question: after a forget request, can we guarantee that the forgotten input and everything derived from it are unreadable, for good, even for someone who later steals the whole storage and the system’s current keys? Existing answers fall short. Logical deletion across memory layers [3] trusts the store after the fact. Replaying the agent without the input [4] is costly and leaves storage residue. Cryptographic erasure with one key per object, as in Holepunch [5], or one key per epoch, as proposed against soft-deleted vectors [6], erases the targeted object but not the memories that the model derived from it.

Our approach. We make the key of every memory depend on the keys of the memories it was derived from. Source keys come from a puncturable pseudorandom function (PPRF) [7, 8]; the key of a derived memory is an HKDF of its parents’ keys. Forgetting a source is a single puncture of the PPRF. Every descendant then becomes undecryptable at once, wherever its ciphertext lives, without being located. To know the parents, we use a sound lineage rule: the parents of a memory are everything the model saw when it wrote it. This rule needs no access to the model, only to the prompt, and it is what makes the cryptographic guarantee meaningful (Lemma 1).

Findings. On 128 LoCoMo sessions whose memory was written by a real model, an attacker holding every file and the current keys recovers 35 of 35 forgotten secrets after logical deletion, 22 after per-object or epoch keys, and none after LinEra with the sound rule. The guarantee has a price, and we measure it precisely: a memory written from ff source turns survives a random forget rate pp with probability close to (1−p)f(1-p)^f. A typical session-level writer that also reads earlier summaries has a fan-in of more than a hundred turns, so forgetting 1% of the turns erases 74.8% of the derived memories. The remedy is to keep the writer’s context small: when the same model extracts facts from four-turn windows, the radius at 1% falls to 3.9% (against 64.4% for the session writer on the same conversations), and answer quality is not hurt. Re-deriving the lost memories from what survives restores answer quality in both settings, at the cost of one model call per affected session or window. A larger writer, Qwen2.5-7B, on all ten LoCoMo conversations confirms each of these findings: 67 of 71 forgotten secrets leak with per-object keys and none with LinEra, and the radius at 1% is 73.0% for the session writer (predicted 77.2%) and 3.8% for four-turn windows.

Contributions.

  1. A security definition, LC-FS, for lineage-complete forward-secure erasure in agent memory, and a lemma that connects it to what an LLM writer can have seen (Section 4).

  1. LinEra, a key graph over a GGM puncturable PRF with an encrypted vector index whose shard keys follow the lineage, crash-consistent state and compaction, and a 140-line integration into mem0 (Section 5).

  1. Proofs of LC-FS security in the random-oracle model and, with a polynomial loss, in the standard model, and of lineage integrity (Section 6, Appendices Appendix A and Appendix B).

  1. An evaluation with real LLM writers from two model families and three sizes (1.5B to 7B parameters) on LoCoMo and LongMemEval: four leakage channels, the fan-in law of the forgetting radius (checked for writer contexts from 2 turns to whole sessions), its utility cost and two remedies (re-derivation and small-context writing), system costs up to 10610^6 objects, and a case study on mem0 (Section 8).

Background: How Agent Memories Grow

Long-term memory layers for LLM agents, such as mem0 [1], follow the same loop. New messages arrive. The framework retrieves related memories by embedding search and shows them, together with the new messages and a short window of recent ones, to a language model. The model writes new memories: extracted facts (“Alice moved to Lyon”), updates of older facts, or session summaries. Each memory is embedded and indexed. Later retrievals bring these memories back into new prompts, so memories are written from memories.

Two consequences matter for erasure. First, most of what the store holds was written by the model, not received from the user. In our LoCoMo run, the writer produced 967 derived memories from 2,795 turns. Second, information moves between objects in ways that the store does not see: a fact can paraphrase a message, and a summary can carry a detail from an older summary. Deleting the message that a user points at leaves these copies in place. Storage adds a third layer of copies: deleted rows stay in free database pages, soft-deleted vectors stay in index files [6], and backups keep everything. As we found when reading its code, mem0 2.2.1 even writes the old text of a deleted memory into its history table.

Related Work

Puncturable primitives and forward security. Puncturable PRFs were introduced as constrained PRFs [7, 9, 10], with GGM [8] as the basic instance and adaptive security studied in [11]. Puncturable encryption gives forward secrecy to asynchronous messaging [12] and to 0-RTT key exchange through Bloom-filter encryption [13] and session resumption [14]. Puncturable key wrapping [15] punctures a key-encryption key over a fixed set of tags. All of these treat the protected items as independent. Our contribution is to make the key of an item depend on the keys of the items it was derived from, so that one puncture erases a closure that is not known in advance.

Secure and cryptographic deletion. Reardon et al. survey secure deletion [16]; cryptographic erasure (delete the key, not the data) is the standard answer when storage cannot be overwritten. Holepunch [5] deletes files with a GGM PPRF and crash-consistent state, and we reuse its state-handling ideas. Cloud schemes provide fine-grained erasure in outsourced storage [17] and erasable, portable storage with oblivious key management [18]. None of them models data that is derived from deleted data by a third process, here a language model.

Forgetting in LLM agents. Machine unlearning removes the influence of training data from model weights [19]; it is complementary to our work, which concerns external memory. For agents, ForgetAgent [3] deletes logically across the layers of a multi-layer memory and issues deletion receipts; execution-state unlearning [4] replays an agent’s execution without the forgotten input; benchmark studies [20] and behavioural analyses [21, 22] show that deleted memories keep influencing later answers. Ghost Vectors [6] shows that soft-deleted vectors in HNSW indexes can be reconstructed and proposes per-epoch encryption. MemLineage [23] records a signed derivation DAG to fight memory poisoning, i.e., for integrity rather than erasure. MemoRepair [24] and agentic unlearning [25] withdraw or invalidate the memories derived from a deleted source, logically and without a guarantee against a later theft of the storage, and a recent benchmark [26] finds that current memory systems rarely complete a forget request end to end. These works either rely on the store behaving honestly after deletion, or erase only the targeted object. LinEra is, to our knowledge, the first scheme with a formal guarantee that covers derived memories and holds against a later theft of the storage and of the current secret state.

Revocation in agent memory. In earlier work with colleagues [27] we bounded the work needed to repair an agent memory when a source is found to be wrong (an integrity and availability question) using the same dependency graph. LinEra addresses the confidentiality side: once a source must be forgotten, how to make it and all its derivatives unreadable for good. The two can share the lineage capture of Section 5.

System and Threat Model

Memory objects and their lineage

An agent memory is a set of objects. A source object is an input that the agent received: a user message, a tool result, a document chunk. A derived object is text or a vector that the agent itself wrote from other objects: a session summary, an extracted fact, a merged profile entry, a note, an embedding. Each object oo has a public random tag to∈T={0,1}nt_o \in\mathcal{T} = \{0,1\}^{n} (n=32n = 32 in our implementation) and a set of parents P(o)P(o) of earlier objects. Sources have no parents. The parent relation forms a directed acyclic graph (DAG), which we call the lineage graph. We write Anc⁡(o)\operatorname{Anc}(o) for the ancestors of oo and, for a set Φ\Phi of objects, Cl⁡(Φ)=Φ∪{o:Anc⁡(o)∩Φ≠∅}\operatorname{Cl}(\Phi) = \Phi\cup\{o : \operatorname{Anc}(o) \cap\Phi\ne\varnothing\} for its lineage closure: Φ\Phi and everything derived from it, directly or not.

Example. On Monday Alice tells the agent “my new door code is 74200” (source ss). That evening the agent writes a summary rr of the day (parents: all Monday messages) and a fact ff “Alice has a new door code” (same parents). On Tuesday it retrieves rr to write a weekly profile ww. Then Cl⁡({s})={s,r,f,w}\operatorname{Cl}(\{s\}) = \{s,r,f,w\}.

Which parents? The lineage rule

The lineage graph is not given; the memory pipeline must record it. A lineage rule decides P(d)P(d) when a derived object dd is written. We study two rules.

  • Sound rule. P(d)P(d) is every object whose plaintext is in the writer’s context when dd is written: the new messages, the conversation window that the framework shows, and every memory returned by retrieval.

  • Attributed rule. P(d)P(d) is a subset chosen by an attribution function; in our experiments, the three context objects whose embeddings are closest to dd.

The sound rule needs no knowledge of the model. It only observes what enters the prompt. Its justification is the following simple lemma, which is the bridge between information flow and cryptography.

Lemma 1 (Context confinement). Model the writer as a function W(ctx,θ,ω)W(\mathit{ctx}, \theta, \omega) of its context, its weights θ\theta and its randomness ω\omega. Let the sources be independent random variables and record lineage with the sound rule. Then, for every source ss, the joint content of all objects outside Cl⁡({s})\operatorname{Cl}(\{s\}) is a function of the other sources, θ\theta and the writer randomness; hence it is independent of the content of ss.

Proof. By induction in creation order. A source o≠so \ne s is independent of ss by assumption. A derived d∉Cl⁡({s})d \notin\operatorname{Cl}(\{s\}) has no parent in Cl⁡({s})\operatorname{Cl}(\{s\}), since otherwise dd would be in the closure. By the sound rule its context is exactly the content of its parents, which by induction does not depend on ss; so neither does d=W(⋅)d = W(\cdot).

The lemma is the reason why the sound rule is “sound”: whatever a forgotten source could have influenced is inside its closure. It also states the three limits that no storage scheme can remove: what the weights θ\theta already know, information about ss that other sources also carry (if Alice repeats her code in another message, forgetting one message does not forget the code), and anything that was copied out of the system before the request. The attributed rule gives no such guarantee: a fact can copy a detail from a context object that the attribution function did not select.

Adversary

The adversary sees the storage at all times: ciphertexts, the lineage graph, files, backups, free pages and logs. This captures an honest-but-curious cloud host or a backup operator. It does not see the secret state SS of the store before the forget request. At some later time it corrupts the system and obtains everything: all storage ever written and the current secret state. This captures a stolen laptop, a seized server, a compelled disclosure or a compromised operator after the erasure request. The goal is that nothing about forgotten objects and their descendants can be learned from this view. RAM content at the very moment of forgetting, side channels on the running process and the model weights are out of scope.

Security definition

Definition 1 (LC-FS security). Let Π=(Setup,Put,Forget)\Pi= (\mathsf{Setup}, \mathsf{Put}, \mathsf{Forget}) be a memory store. The game GΠlcfs(A)\mathsf{G}_{\Pi}^{\mathrm{lcfs}}(\mathcal{A}) runs as follows.

  1. The challenger runs S←Setup(1λ)S \leftarrow\mathsf{Setup}(1^\lambda) and draws b←{0,1}b \leftarrow\{0,1\}. The public view Σ\Sigma (all ciphertexts ever written, including overwritten and deleted ones, and the lineage graph) starts empty.

  2. A\mathcal{A} adaptively calls three oracles and always receives the new part of Σ\Sigma:

    • New(P,m)\mathsf{New}(P,m): stores content mm as a new object with parents PP (existing objects) and returns its tag;

    • Chal(P,m0,m1)\mathsf{Chal}(P,m_0,m_1), with ∣m0∣=∣m1∣|m_0| = |m_1|: stores mbm_b as a new object with parents PP; the object is marked as a challenge object;

    • Forget(t)\mathsf{Forget}(t): runs Forget(S,t)\mathsf{Forget}(S,t) and adds tt to Φ\Phi.

  3. A\mathcal{A} calls Corrupt\mathsf{Corrupt} and receives the current state SS. It outputs b′b'.

A\mathcal{A} is valid if every challenge object is in Cl⁡(Φ)\operatorname{Cl}(\Phi) at corruption time. Its advantage is Adv⁡Πlcfs(A)=∣2Pr⁡[b′=b]−1∣\operatorname{Adv}_{\Pi}^{\mathrm{lcfs}}(\mathcal{A}) = |2\Pr[b' = b] - 1|. Π\Pi is lineage-complete forward-secure (LC-FS) if this advantage is negligible for every efficient valid A\mathcal{A}.

Three design choices of the definition deserve a word. First, the adversary chooses the contents and parents of all objects, so the definition covers any writer, honest or adversarial. Second, several challenge objects are allowed, anywhere in the closure. This models a summary of a forgotten message, a fact extracted from that summary, and so on: by Lemma 1 these are exactly the objects whose content may depend on the forgotten source, and the game lets them depend on the bit bb. Third, the adversary gets every ciphertext ever written, so backups and storage residue are included by construction. Note that a store which deletes rows but keeps keys (logical deletion), or that erases only the forgotten object (per-object keys), is trivially broken: the adversary forgets a source and wins with a challenge child.

LinEra in one example

Figure 1. LinEra in one example. Keys flow along the lineage (grey arrows). Forgetting s1s_1 punctures the PPRF at ts1t_{s_1}: ks1k_{s_1} can no longer be computed, so neither can the keys of its descendants rr and ff, even by an attacker who later steals the store and the current key SS. s2s_2 and gg stay readable.

The LinEra Construction

Building block: a puncturable PRF

A puncturable pseudorandom function (PPRF) [7, 9, 10] is a PRF F(K,⋅)F(K, \cdot) with an extra operation Puncture⁡(K,x)\operatorname{Puncture}(K, x). It returns a new key K{x}K_{\{x\}} that still computes F(K,y)F(K, y) for every y≠xy \ne x, but reveals nothing about F(K,x)F(K, x). We use the classic tree construction of Goldreich, Goldwasser and Micali (GGM) [8] on nn-bit inputs, with the length-doubling generator G(s)=(G0(s),G1(s))G(s) = (G_0(s), G_1(s)), Gb(s)=SHA⁡G_b(s) = \operatorname{SHA}-256(b∥sb \mathbin\Vert s). The key is a set of tree nodes (prefix, seed) that together cover all non-punctured inputs; initially it is the root. To evaluate xx, one walks down from the node that covers xx. To puncture xx, one removes that node and keeps the siblings of the path to xx: at most nn new nodes. Holepunch [5] uses the same tool to delete files from a disk; we use it as the root of a key graph.

Key derivation along the lineage graph

The secret state is a PPRF key SS. Every object oo has a key

ko=F(S,to)if P(o)=∅,ko=HKDF⁡(kp1∥⋯∥kpm∥F(S,to);Io)otherwise,(1)\begin{aligned} k_o &= F(S, t_o) && \text{if } P(o)=\varnothing,\\ k_o &= \operatorname{HKDF}(k_{p_1}\Vert\cdots\Vert k_{p_m}\Vert F(S,t_o); I_o) && \text{otherwise,} \tag*{(1)} \end{aligned}

where Io="lf/lineage"∥toI_o = \text{"lf/lineage"}\Vert t_o, p1<⋯<pmp_1 < \cdots< p_m are the parents sorted by tag, and HKDF is used with an empty salt [28, 29]. The content mm of oo is stored as co=AEAD⁡ko(m;AD⁡=to∥tp1∥⋯∥tpm)c_o = \operatorname{AEAD}_{k_o}(m; \operatorname{AD} = t_o\Vert t_{p_1}\Vert\cdots\Vert t_{p_m}) with ChaCha20-Poly1305 and a random nonce [30, 31]. The tags and the parent lists are stored in clear next to the ciphertext. Two properties follow at once.

Algorithm 1 LinEra operations (state SS, store Σ\Sigma, key cache CC).
1: procedure Put(mm, PP)
2: t←t \leftarrow fresh random tag; record (t,P)(t,P)
3: k←Key⁡(t)k \leftarrow\operatorname{Key}(t); c←AEAD⁡k(m;t∥sort⁡(P))c \leftarrow\operatorname{AEAD}_k(m;t\Vert\operatorname{sort}(P)); append (t,P,c)(t,P,c) to Σ\Sigma
4: return tt
5: procedure Key(tt)
6: y←F(S,t)y \leftarrow F(S,t)
7: if P(t)=∅P(t)=\varnothing then return yy
8: return HKDF⁡(kp1∥⋯∥kpm∥y;It)\operatorname{HKDF}(k_{p_1}\Vert\cdots\Vert k_{p_m}\Vert y;I_t)
9: procedure Forget(tt)
10: D←{t}∪Desc⁡(t)D \leftarrow\{t\}\cup\operatorname{Desc}(t); decrypt the vector shards that contain DD
11: S←Puncture⁡(S,t)S \leftarrow\operatorname{Puncture}(S,t); write SS atomically (temp file, fsync, rename)
12: drop C[u]C[u] for u∈Du\in D; rebuild the shards without DD (new version)
13: delete the rows of DD
14: procedure Rotate
15: S′←S' \leftarrow fresh PPRF key; re-encrypt every readable object under the keys derived from S′S'; S←S′S\leftarrow S'

Table 1. Algorithm 1 LinEra operations.

  • One puncture erases a whole closure. To compute kdk_d one needs the keys of all parents, hence, by induction, F(S,ta)F(S,t_a) for every ancestor aa. After Puncture⁡(S,ts)\operatorname{Puncture}(S,t_s), no descendant of ss can be decrypted, and the store never has to find them.

  • Every object can be forgotten alone. The term F(S,to)F(S,t_o) in the derived case gives each derived object its own puncture point. Forgetting a wrong fact punctures the fact and its descendants only.

Including the parents in the associated data binds each ciphertext to its lineage: a storage attacker who rewires P(d)P(d) makes decryption fail (integrity, § 6).

Forgetting, crash consistency and compaction

Algorithm 1 summarises the operations. A forget request is durable as soon as the new state is on disk; we write it with the usual temporary-file, fsync, rename sequence, so a crash leaves either the old or the new state. Deleting rows afterwards is only hygiene. Each puncture adds at most nn nodes of 40 bytes to SS. Rotate re-encrypts the survivors under a fresh PPRF key and brings SS back to one node; it can run in the background, like the compaction of Holepunch [5].

An encrypted vector index whose keys follow the lineage

Agent memories are found by embedding search. Embeddings are themselves derived data: text can be largely recovered from them [32], and soft-deleted vectors survive in popular index files [6]. LinEra therefore keeps vectors in shards of at most BB objects (we use B=64B=64 in the agent experiments and B=256B=256 for scaling). A shard with members MM and version vv is one AEAD ciphertext under

kshard=HKDF⁡(∥u∈sort⁡(M)ku;"lf/shard"∥sid⁡∥v).k_{\mathrm{shard}}=\operatorname{HKDF}(\Vert_{u\in\operatorname{sort}(M)}k_u;\text{"lf/shard"}\Vert\operatorname{sid}\Vert v).

A shard can be decrypted only while all its members are readable. When a forget request hits a member, the shard is decrypted first, the PPRF is punctured, and the shard is rebuilt without the closure under version v+1v + 1. Old copies of the shard, in backups or free pages, die with the punctured key. Search decrypts and caches the shards in RAM and scans them; an approximate graph index [33] can be built per shard inside the same envelope. If the process crashes between the puncture and the rebuild, the surviving members are simply re-embedded from their (still readable) text.

Capturing lineage in a real memory framework

The sound rule needs one hook: the store must know what the writer sees. We implemented it for mem0 [1] (version 2.2.1), an open-source memory layer, in about 140 lines. The LinEra vector store implements mem0’s storage interface. A thin wrapper stores each incoming message as a source object and opens a lineage context. During the call, every memory that mem0 retrieves through the store’s search or get is added to the context; every memory that mem0 then inserts or updates receives the context as parents. The context also contains the earlier messages that mem0 shows the model (its last ten messages) when, and only when, the model is called. We found that mem0 keeps a second, plaintext SQLite database of raw messages and of the history of each memory; its delete operation even writes the old text of the deleted memory into it. The wrapper therefore keeps that history in RAM only.

Two ways to pay less for the guarantee

The sound rule erases more than what logical deletion erases: it also erases memories that merely saw the forgotten source. Section 8 measures this forgetting radius. We propose two remedies that keep the guarantee.

  • Re-derivation. After a forget request, every session that lost derived memories is summarised again by the same writer, from its surviving sources and surviving memories. The new memories get sound parents. The cost is one model call per affected session.

  • Small-context writing. The radius grows with the number of source turns that the writer sees, directly or through retrieved summaries. Writing memories from short windows of a few turns, without feeding earlier summaries back into the writer, keeps every memory’s parent set small, so a forgotten source reaches only the few memories written from its window.

Security Analysis

We model G0,G1G_0,G_1 (SHA-256 with a one-byte prefix) and HKDF as independent random oracles [34] and the AEAD as one-time IND-CPA secure. Let λ=256\lambda= 256 be the seed and key length.

Theorem 1 (LinEra is LC-FS secure). Let A\mathcal{A} be a valid adversary that makes qGq_G queries to GG and qHq_H queries to HKDF, forgets a set Φ\Phi of objects, and causes NKN_K keys (object keys and shard keys) to be derived. Let CC be the number of ciphertexts in Σ\Sigma that encrypt challenge content (challenge objects and the shard versions that contain their vectors). Then there is an adversary B\mathcal{B}, running in about the time of A\mathcal{A}, such that

Adv⁡LinEralcfs(A)≤2qG∣Φ∣(n+1)+2qHNK2λ+2C⋅Adv⁡AEADot−ind(B).\operatorname{Adv}^{\mathrm{lcfs}}_{\mathrm{LinEra}}(\mathcal{A}) \le\frac{2q_G|\Phi|(n+1)+2q_HN_K}{2^\lambda}+2C\cdot\operatorname{Adv}^{\mathrm{ot-ind}}_{\mathrm{AEAD}}(\mathcal{B}).

Proof idea (full proof in Appendix Appendix A). Three game hops. (i) After puncturing, the GGM nodes on the paths to the punctured tags are never revealed; in the random-oracle model their values, and so the leaf values F(S,t)F(S,t) for t∈Φt \in\Phi, look uniform unless A\mathcal{A} queries the oracle on one of at most ∣Φ∣(n+1)|\Phi|(n+1) hidden 256-bit seeds. (ii) Every key in the closure is then an HKDF output on an input that contains at least one uniform, hidden 256-bit block: its own punctured leaf, or the key of a parent in the closure. By induction along the DAG, all these keys look uniform. Shard keys are handled the same way, since a shard that contains a closure member mixes that member’s key. (iii) Each challenge ciphertext is then produced under a fresh uniform key used once, and one-time IND-CPA security of the AEAD hides bb. With qG=qH=264q_G=q_H=2^{64}, ∣Φ∣=NK=230|\Phi|=N_K=2^{30} and n=32n=32, the first term is below 2−1552^{-155}.

Remark 1 (Standard model). The random oracles can be removed. Appendix Appendix B proves LC-FS from the PRG security of GG, a block-keyed PRF assumption on HKDF (a dual-PRF-style property of HMAC [35, 28]) and one-time IND-CPA of the AEAD, with key separation between encryption and derivation. GGM is only selectively secure [7, 10, 9], and our adversary chooses which objects to forget adaptively; we avoid the exponential cost of guessing all punctured points [11] by guessing only one forgotten ancestor of each challenge object, so the loss is polynomial (a factor C′NℓC'N\ell, Theorem 3).

Theorem 2 (Lineage integrity). Without the secret state, an adversary that modifies the storage cannot make Get⁡(t)\operatorname{Get}(t) return a content other than the one stored for tt, nor make the store accept a parent list other than the one recorded at creation, except with probability Adv⁡AEADint−ctx\operatorname{Adv}^{\mathrm{int-ctx}}_{\mathrm{AEAD}} per forged ciphertext.

Proof sketch. The key of tt depends on its recorded parents through (1), and the parent tags are part of the associated data. Changing the parent list either changes the key (a ciphertext under a key the adversary never saw) or the associated data; both are ciphertext forgeries. Our test suite checks this case (a rewired summary fails to decrypt).

What leaks. The lineage graph, object sizes and creation times are in clear: the store needs the parent tags to derive keys before decrypting. After forgetting, the adversary therefore learns that some object with kk children existed, but not its content. Hiding the graph would require encrypting it under a key that is itself forward-secure; we leave this to future work. The scheme also does not protect the model weights, RAM at the time of forgetting, or copies made before the request (Lemma 1).

Why the baselines fail the definition. Logical deletion keeps all keys (or no encryption at all): the adversary reads the challenge child. Per-object keys (Holepunch-style) puncture only the forgotten object: its children keep their own keys. Epoch keys (the fix proposed for soft-deleted vectors [6]) re-encrypt the other objects of the forgotten object’s epoch under a fresh key, so every child remains readable. Each attack uses one forget and one challenge child; § 8 shows that real LLM pipelines create such children.

Implementation

LinEra is a Python library of about 400 lines. It uses the cryptography package for ChaCha20-Poly1305 and HKDF-SHA-256 and SQLite for storage. The GGM PPRF works on 32-bit tags and stores each frontier node as a (depth, prefix, seed) triple; the state file is written with the temporary-file, fsync, rename sequence and is meant to be sealed by the platform key store. Object keys are memoised in RAM; a forget request drops the cached keys of its closure. The vector index of § 5 stores each shard as one ciphertext and seals the open shard on commit. The mem0 adapter takes about 140 lines. Three baselines share the same interface: logical deletion (plaintext rows and an HNSW index [33] from hnswlib with soft deletion, as offered by hnswlib), per-object keys (a GGM key per object, no lineage, in the spirit of Holepunch [5]) and epoch keys (one key per epoch of five sessions; a forget re-encrypts the rest of the epoch and destroys the old key, as proposed against soft-deleted vectors [6]). In the two encrypted baselines the vector of an object is encrypted under the same key as its text. A test suite (12 tests) checks puncturing, serialisation, closure erasure, theft after forgetting, compaction, lineage tampering, key derivation along a 5,000-deep chain with a cold cache (derivation is iterative, not recursive), shard rebuilds, stale shard backups, and the mem0 adapter.

Evaluation

We answer four questions. Do forgotten secrets survive in an LLM-written memory under each scheme (E1, E2)? How far does a forget request reach, and what controls it (E5)? What does the guarantee cost in answer quality (E3)? What does it cost in time and space (E4)? We end with a case study on mem0.

Setup

Machine and models. The memory writer, the re-deriver and the question answerer are always the same open model, at temperature 0. The main runs use Qwen2.5-1.5B-Instruct [36] quantised to 4 bits (Q4_K_M, llama.cpp) on CPU: the memory logs and the system costs come from one virtual machine with two cores of an Intel Xeon at 2.1 GHz and 7.8 GiB of RAM, and every answer of Tables 4 and 5 was computed on one Apple M5 Pro (llama.cpp 0.3.36, CPU only, fresh cache), so that each table comes from a single machine. To check that our findings do not depend on one model family, we repeat the main runs on two conversations with Llama-3.2-3B-Instruct [37] (4 bits). An extended campaign (§ 8.5) replays everything with a larger writer, Qwen2.5-7B-Instruct in 16-bit precision (vLLM 0.33 [38], one NVIDIA H100), on all ten LoCoMo conversations. Embeddings come from bge-small-en-v1.5 [39] (384 dimensions). The random seed is 20261109 everywhere.

Memory pipeline. We replay LoCoMo [40], a benchmark of very long two-person conversations. Because the main writer runs on CPU, it covers the first 5 of the 10 conversations (the extended campaign covers all of them): 128 sessions and 2,795 turns. For each session, in order, the pipeline retrieves the three most similar earlier derived memories and asks the model for a summary and up to eight facts, as mem0-style extractors do. The model wrote 967 derived memories (124,003 prompt tokens, 1.5 hours of generation). We log exactly what each prompt contained. Every scheme and every lineage rule is then evaluated by replaying this log, so all of them store the very same texts written by the very same model; only the recorded parents and the cryptography differ.

Planted secrets. Before the run, we inserted one extra turn in a seeded quarter of the sessions: 35 canary turns such as “my new apartment door code is 28352, and the building manager is called Thalwyndor”, built from four templates with a random five-digit number and an invented word. The model treated them like any other turn. For example, it wrote the fact “Caroline’s new apartment door code is 28352, and the building manager is called Thalwyndor.” It copied the exact secret into a derived memory for 14 of the 35 canaries, and the topic of the canary (“door code”, “locker”, and so on) into a descendant for 22.

Schemes. We compare logical deletion with a soft-deleting HNSW index, per-object keys, epoch keys, and LinEra with the attributed and the sound rule (§ 7). The baselines erase the forgotten turn only, which is their documented behaviour.

E1–E2: do forgotten secrets survive?

The user asks to forget the 35 canary turns. The attacker then obtains every file (database, index, state) and the current secret state, and tries four channels: (i) records it can read or decrypt that contain the exact number or word; (ii) the exact secret anywhere in the raw bytes of the files, which catches deleted rows left in free pages; (iii) the vectors it can read or decrypt: for each canary it ranks the true sentence against 99 decoys built from the same template with other numbers and words, and wins if the true one has the closest vector, a strong attacker who knows the template, in the spirit of embedding inversion [32]; (iv) a readable descendant of the canary turn (ground truth: the model saw it) that mentions the canary’s topic.

Table 1 gives the results. Logical deletion loses everything: the deleted turns stay in free SQLite pages (35 of 35) and their vectors come back after an undelete of the soft-deleted HNSW points (26 identified). Encryption with per-object or epoch keys removes these storage residues, but not the model’s copies: the summaries and facts written from the canary turns are still readable, and leak the exact secret for 14 canaries, the topic for 22, and enough for the vector attack in 8 cases. In total 22 of the 35 forgotten canaries leak. LinEra with the attributed rule never leaks an exact secret, but still leaks the topic of 3 canaries: the attribution function missed the canary turn when the model folded it into a summary. LinEra with the sound rule leaks nothing through any channel. It erases 526 objects to do so, against 56 for the attributed rule: this is the price we study next.

SchemeExact secret in readable recordsExact secret in raw bytesIdentified from vectors (1 of 100)Topic in a descendantAny channelObjects erased
Logical deletion + soft-deleted HNSW143526223535
Per-object keys (no lineage)1408222235
Epoch keys1408222235
LinEra, attributed rule0003356
LinEra, sound rule00000526

Table 1 (PDF p. 7). Erasure of planted secrets after a real LLM wrote the memory (LoCoMo, 128 sessions, 35 canary turns forgotten). The attacker holds every file and the current secret state. Columns count canaries (out of 35) recovered through each channel.

E5: how far does a forget request reach?

Table 2 describes the lineage graph that the model’s prompts induce. Under the sound rule a derived memory has 24.8 parents on average and, through retrieved summaries, 167.1 source ancestors. Forgetting one turn erases 58.2 derived memories on average. When a random 1% of the turns is forgotten, 74.8% of all derived memories disappear; at 5%, almost all of them. Two structural what-ifs on the same log show where this comes from. Flat derivation (the writer is shown the turns of the retrieved sessions instead of their summaries) removes chains, but each memory still has about a hundred source parents, and the radius at 1% only drops to 59.7%. What matters is the number of source turns in the writer’s context, its fan-in ff: a memory

survives a random forget rate pp with probability about (1−p)f(1 - p)^f (Figure 2). A typical session writer has ff in the hundreds once retrieval is counted.

Plot of derived memories erased versus turns forgotten for session writers with different context sizes

Figure 2. Share of derived memories erased by the sound rule when a random fraction of turns is forgotten, for writers with different context sizes (LoCoMo conversations 0–1, same LLM). Markers: measured (mean of 3 seeds). Lines: the fan-in law 1−(1−p)f1 - (1 - p)^f averaged over the measured fan-in distribution, with no fitted parameter.

The remedy is to keep the writer’s context small. We ran the same model a second time on conversations 0 and 1, now extracting up to three facts from each window of four consecutive turns, with no retrieval of earlier memories (214 short calls instead of 38 long ones). The sound rule is unchanged, but the mean fan-in drops from 126.2 to 3.8 source turns, and the forgetting radius at 1% falls from 64.4% to 3.9% (33.0% at 10%, against 100.0%). The fan-in law predicts these values closely: 3.7% and 67.3% at 1%. Security does not change: on the 11 canaries of these conversations, the windowed writer copied the exact secret into a fact 9 times; logical deletion leaks 11 of them, per-object and epoch keys 10, and LinEra with the sound rule none, while erasing only 40 objects.

E3: what does the guarantee cost in answer quality?

We forget a random 1%, 5% or 10% of the turns (nested sets, three seeds) and score only the questions whose evidence turns all survive: the others are meant to become unanswerable. We use two views of the store: facts-only, where the agent retrieves derived memories only (as mem0 does), and hybrid, where the encrypted raw turns are also retrievable.

Retrieval. Table 3 reports how often a top-10 hit comes from an evidence session, over 760 questions (category 5, adversarial, excluded). Schemes without lineage lose nothing, because they erase almost nothing. The sound rule makes the facts-only store collapse, from 63.2% to 18.9% at 1%: this is the radius of Section 8.3. The hybrid store degrades much less (79.5% to 70.2% at 1%, 68.3% at 10%), because surviving raw turns still carry most of the evidence. The attributed rule keeps utility close to the baseline, but, as Table 1 showed, at the price of leaks.

Answers. Table 4 closes the loop with the same LLM answering 60 sampled questions from the facts-only store of conversations 0 and 1. The small model sets a low ceiling (token F1 12.9 without forgetting, bootstrap standard deviation 2.1) and a floor of 7.1 when the store is empty, which is the case for the sound rule at 10%. At 1% the sound rule keeps 95 of 300 derived memories and F1 drops to 10.5. Re-derivation removes the loss: after re-summarising the 26 affected sessions (14 minutes on CPU), F1 is 17.2 at 1% and 11.7 at 10% (38 sessions, 20 minutes): above the no-forgetting level at 1%, and within one standard deviation of it at 10%. Re-derived memories are written from fewer turns and appear slightly easier to retrieve; we do not read more into this difference, which is within two standard deviations. The guarantee is kept: re-derived memories have only surviving parents.

Lineage ruleMean parentsDescendants of one turn meanDescendants of one turn p95Descendants of one turn maxDerived memories erased 1%Derived memories erased 5%Derived memories erased 10%
Sound (as run, retrieves summaries)24.858.221023474.8%99.0%99.7%
Attributed (top-3 context items)3.02.5316619.4%38.0%59.3%
Flat derivation†–27.48922159.7%98.2%99.7%
Session-local†–7.69918.9%65.7%86.6%

Table 2. Lineage statistics and forgetting radius on the LoCoMo log. Descendants: derived objects erased by forgetting one turn. Radius: share of derived memories erased when a random fraction of turns is forgotten (mean of 3 seeds). †Structural what-if on the same log: the parent sets that the alternative pipeline would record.

ConditionFacts-only 1%Facts-only 5%Facts-only 10%Hybrid 1%Hybrid 5%Hybrid 10%
No forgetting63.2%79.5%
No lineage (logical, per-object, epoch)63.1%63.0%62.9%79.4%79.3%79.5%
LinEra, attributed61.6%59.0%54.1%79.4%78.8%78.5%
LinEra, sound18.9%1.8%0.4%70.2%67.6%68.3%

Table 3. Retrieval utility on LoCoMo after forgetting: share of retained questions for which a top-10 hit comes from an evidence session (mean of 3 seeds). Facts-only: the store keeps derived memories only (mem0-like); hybrid: raw turns are kept too.

Small-context writing. The windowed writer of Section 8.3 changes the picture. On the same 60 questions it answers better than the session writer even without forgetting (F1 24.1 against 12.9): short excerpts give the small model less to summarise away. Under the sound rule, forgetting 1% of the turns leaves F1 at 24.1, and 10% at 21.3 (373 of 557 facts survive). Re-derivation is cheap because only the windows that lost a turn are rewritten: 8 short calls at 1% and 67 at 10% (11 minutes), giving F1 24.2 and 22.7. In short, with a small-context writer the sound rule costs almost nothing in answer quality.

LongMemEval. We repeated phases A and B on a seeded subset of LongMemEval-S [41]: six questions of each of four types (multi-session, temporal reasoning, knowledge update, single-session user), each with its own history made of its evidence sessions and one distractor, user turns only (76 sessions, 405 turns, 514 derived memories). These histories are short, so the sound-rule radius is smaller than on LoCoMo (9.9% of derived memories at 1%, 66.8% at 10%) and retrieval of evidence sessions saturates. The answer-quality trend is the same (right half of Table 4): the sound rule costs little at 1% and much at 10%, and re-derivation recovers it. With 16 questions the standard deviation is about 7.4 points, so we read only the direction of these differences.

ConditionLoCoMo (conv. 0–1) F1unk.re-der.LongMemEval-S subset F1unk.re-der.
No forgetting12.90–20.00–
No lineage, 1%12.90–20.00–
LinERA attributed, 1%12.90–20.00–
LinERA sound, 1%10.50–18.80–
LinERA sound + re-derivation, 1%17.202620.104
No lineage, 10%12.90–20.00–
LinERA attributed, 10%11.60–23.80–
LinERA sound, 10%7.10–12.60–
LinERA sound + re-derivation, 10%11.703824.3053

Table 4. Answer quality from the surviving memory (token F1, %), share of “unknown” answers (%) and number of sessions re-summarised. Same LLM for writing, re-deriving and answering; only questions whose evidence survives are scored.

Size of the writer context. Table 5 and Figure 2 vary the window from 2 to 16 turns on conversations 0 and 1. The fan-in law holds at every size, with no fitted parameter. The radius at 1% grows with the window, from 2.0% (2 turns) to 12.0% (16 turns), against 64.4% for the session writer. Answer quality does not fall when the window shrinks: F1 without forgetting is 23.5 with 2-turn windows and 24.1 with 4, against 20.7 with 8, 18.2 with 16 and 12.9 for whole sessions. In every configuration LinEra leaks no canary, while per-object keys leak most of them. Note the tension for schemes without lineage: small-context writers copy secrets verbatim more often (per-object keys leak 11 of 11 canaries with 2-turn windows, 7 with the session writer), so the configuration that is best for utility is also the one where lineage matters most.

WriterLLM callsDerived memoriesFan-inErased at 1% measuredErased at 1% predictedErased at 10%F1 noneF1 1%F1 1%+rdF1 10%Leaks
Session writer (Qwen2.5-1.5B)38300126.264.4%67.3%100.0%12.910.517.27.17/11 | 0/11
16-turn windows (Qwen2.5-1.5B)7019711.712.0%11.0%66.8%18.216.4–11.36/11 | 0/11
8-turn windows (Qwen2.5-1.5B)1163257.07.0%6.8%51.7%20.721.6–17.88/11 | 0/11
4-turn windows (Qwen2.5-1.5B)2145573.83.9%3.7%33.0%24.124.124.221.310/11 | 0/11
2-turn windows (Qwen2.5-1.5B)4099582.02.0%1.9%18.6%23.523.3–18.611/11 | 0/11
Session writer (Llama-3.2-3B)38342141.963.2%70.7%100.0%28.516.126.91.710/11 | 0/11

Table 5. Writer context size and model family (LoCoMo conversations 0–1, sound rule). Fan-in: mean number of source turns behind a derived memory. Erased: share of derived memories erased when a random 1% or 10% of turns is forgotten (3 seeds); predicted: fan-in law. F1: answers from the facts-only store (60 questions); rd: after re-derivation. Leaks: forgotten canaries recovered by any channel with per-object keys with LinERA.

A second model family. To check that these effects do not depend on one model, we replayed conversations 0 and 1 with Llama-3.2-3B-Instruct as the session writer (same prompts, same canaries). This model copies secrets verbatim far more often: the exact secret reached a derived memory for 10 of 11 canaries. Per-object and epoch keys therefore leak 10 of them, logical deletion 11, the attributed rule 1, and the sound rule none. Its fan-in (141.9 source turns) gives a radius of 63.2% at 1%, close to the law’s 70.7%. The stronger model also makes the utility trade-off clearer: F1 is 28.5 without forgetting, 16.1 under the sound rule at 1%, and 26.9 after re-derivation.

A larger writer on all conversations

The runs above use small models on CPU. We replayed the whole pipeline with Qwen2.5-7B-Instruct on one GPU, on all ten LoCoMo conversations (272 sessions, 5,953 turns, 71 canaries from the same templates and seed), with both the session writer and four-turn windows, and on 100 LongMemEval-S histories (25 questions of each of the four types). Questions are no longer sampled: we score every question whose evidence survives. Table 6 summarises E1–E5 for this writer.

WriterDerived memoriesFan-inLeaksErased at 1%Erased at 10%F1
logicalobj./ep.attr.soundmeas.pred.none1%1%+rd10%10%+rd
LoCoMo, session writer2,229181.5706713073.0%77.2%99.6%27.813.827.92.027.3
LoCoMo, 4-turn windows4,1723.87069003.8%3.8%32.7%31.830.731.826.631.9
LongMemEval-S, session writer2,24711.1––––10.4%–65.5%27.826.928.712.429.7

Table 6. Extended campaign: Qwen2.5-7B-Instruct writes, re-derives and answers (vLLM, one GPU). LoCoMo: all ten conversations; LongMemEval-S: 100 histories. Fan-in: mean number of source turns behind a derived memory (sound rule). Leaks: forgotten canaries recovered by any channel (Section 8.2). Erased: share of derived memories erased by the sound rule when a random 1% or 10% of turns is forgotten (3 seeds); predicted: fan-in law. F1: token F1 (%) from the facts-only store over every eligible question; rd: after re-derivation.

Leaks. The larger model copies the exact secret into a derived memory for 60 of the 71 canaries (68 with four-turn windows). Logical deletion leaks 70 of them through some channel, and per-object and epoch keys 67, entirely through the model’s copies (the exact secret is readable in a derived memory for 60 of them). The attributed rule leaks the topic of 13 canaries with the session writer and none with windows. The sound rule leaks none in either setting.

Radius. The session writer has a mean fan-in of 181.5 source turns, and forgetting 1% of the turns erases 73.0% of the derived memories, against 77.2% predicted by the fan-in law. Four-turn windows bring the fan-in down to 3.8 and the radius to 3.8% (predicted 3.8%), and to 32.7% at 10%. The law thus holds, with no fitted parameter, for another model size, another inference engine and five times more history.

Answers. Over 1,323 LoCoMo questions (bootstrap standard deviation about 0.9 points), the session writer reaches F1 27.8 without forgetting. The sound rule drops it to 13.8 at 1%, where 831 of 2,229 derived memories survive, and to 2.0 at 10%, where none does. Re-derivation restores it: F1 27.9 at 1% (169 sessions, 19 minutes) and 27.3 at 10% (272 sessions, 27 minutes). As with the small model, the windowed writer answers better even without forgetting (31.8), keeps 30.7 at 1% and 26.6 at 10% under the sound rule, and returns to 31.8 and 31.9 after re-deriving 57 and 498 short windows. On LongMemEval-S (77 eligible questions, standard deviation about 3.6 points), the sound rule costs little at 1% (26.9 against 27.8) and much at 10% (12.4), and re-derivation brings F1 to 28.7 and 29.7.

A larger writer answers better but changes none of our conclusions: what leaks after deletion is the model’s own copies, the sound rule leaks nothing, the radius follows the fan-in law, and small windows with re-derivation make the guarantee almost free in answer quality.

Case study: mem0

We ran mem0 2.2.1 end to end, with the same local model as its fact extractor, on six user messages, two of which contain secrets (a door code with the manager’s name, and a vet confirmation number). The extraction prompt of mem0 alone is longer than 8,000 tokens, so this experiment uses a 16k-token context.

Vanilla mem0. With its default on-disk stores (Qdrant and a SQLite history), mem0 wrote 11 memories. We served the erasure request the way mem0 offers it: search the memories about each forgotten topic and call delete on every match. This removed 3 memories, and no live memory mentions a secret any more. Yet all 3 secrets are still in the files, in history.db, qdrant/collection/mem/storage.sqlite: the history database keeps the text of deleted memories by design, and the SQLite file of the vector store still contains them.

mem0 with LinEra. With the adapter of § 5, forgetting the two messages erased 12 objects. An attacker holding every file and the current state finds no secret, neither in decryptable records (0) nor in raw bytes (0). The run also shows the radius at work in a real framework: because mem0 shows its extractor the last ten messages, every memory written after a forgotten message has it as a parent, and only 1 of the 11 memories survives. With mem0’s default context, honouring erasure soundly means re-deriving; a smaller extraction window, as in Section 8.3, makes this cheap.

Longer run, larger extractor. We repeated the case study with Qwen2.5-7B-Instruct as mem0’s extractor and 60 user messages. Vanilla mem0 deleted 20 memories on request, and 6 secrets were still in history.db afterwards. With LinEra, forgetting erased 131 objects, only 3 of the 130 memories survived, and the attacker found no secret, neither in decryptable records (0) nor in raw bytes (0).

E4: system costs

Table 7 measures the library on synthetic workloads shaped like our LLM log (sessions of 22 sources and 9 derived objects with 384-dimensional vectors), up to a million objects, in plain Python. Writing an object, its key derivation and its vector costs 0.28 ms at 10610^6 objects, and reading it with a cold key cache 0.16 ms. A forget request, which includes the closure, the puncture, the atomic state write and the shard rebuilds, takes 9.05 ms (median) at 10610^6 objects. After 100 forgets the PPRF state is 95.4 KiB, and compaction of a million objects takes 59.9 s and brings the state back to a single node. The warm search scan over all shards (326 ms at 10610^6) is the main cost and would use an approximate index per shard in production.

The two regimes confirm Section 8.3 at scale. With flat lineage (sources only as parents) the closure of a forgotten turn stays at 9 objects from 10410^4 to 10610^6 objects. With chained lineage (the writer retrieves earlier derived memories) it grows with the history, to a median of 13,023 objects at 10510^5, and a forget takes 59.6 ms. In our real LLM run, LinEra added about 0.11 ms per written object and 5.7 ms per forget request, negligible next to the 1.5 hours the model spent writing the memory.

Discussion

Choice of lineage rule. The sound rule is the only one with a guarantee, and it costs nothing to implement: the hook sees the prompt. Its price is the forgetting radius, and our measurements give a simple design rule for memory pipelines that must honour erasure requests: keep the writer’s context small. A memory written from ff source turns survives a forget rate pp with probability about (1−p)f(1-p)^f; session summaries that also read older summaries have ff in the hundreds, four-turn windows have f≈4f \approx4. In our runs the small-context writer was also the more useful one, and re-deriving after forgetting was cheap. The attributed rule is useful as a utility knob, but a deployment that uses it should not claim erasure of derived data.

Reading Article 17. The GDPR gives data subjects a right to erasure “without undue delay” [2]. For an agent memory, the hard part is not the deletion of the message the user points at, but of what the system inferred from it. LinEra turns that into a property of the storage layer: once the request is processed, the memory operator can show that no key exists, anywhere, that decrypts the forgotten message or its derivatives, including in backups. This is a stronger statement than a deletion receipt [3], and it holds against the operator itself after the fact. It does not cover the model weights, which is the domain of machine unlearning [19], nor other sources that repeat the same fact.

Deployment. In a hosted memory service the state SS is small (about one kilobyte per forget request before compaction, § 8.7) and can live in a hardware security module or a TPM-sealed file, while the encrypted store stays in ordinary databases and backups. Because forgetting is a key operation, it reaches backups that the operator cannot rewrite, which is the classic argument for cryptographic erasure [16]. Multi-tenant services keep one state per user.

Limitations. Our LLM experiments use open models of at most 7B parameters: Qwen2.5-1.5B on five LoCoMo conversations (two for the main question-answering study, with 60 sampled questions) and a 24-question subset of LongMemEval-S, Llama-3.2-3B on two conversations, and Qwen2.5-7B on all ten conversations and 100 LongMemEval-S histories. Frontier models may copy secrets verbatim more or less often, which changes how much the baselines leak but not the guarantee of LinEra. Exact answers also depend on the inference engine and hardware: rerunning the same quantised model on another CPU changed a few answers, so we compare conditions only within a table computed on one machine. The lineage graph leaks its shape. Lineage capture assumes that the hook sees the whole prompt; tools that read memory outside the framework would bypass it. Finally, the attributed rule we test is deliberately simple; better attribution would raise utility but would still not give a guarantee.

RegimeObjectsWrite (ms)Read (ms)Search (ms)Forget (ms)Descendants (median)State (KiB)Rotate (s)DB (MiB)
Chained10,0130.130.16211140095.70.318
Flat10,0130.130.1327995.80.418
Chained100,0060.161.3630601302395.22.9177
Flat100,0060.190.17287995.95.1178
Flat1,000,0290.280.163269995.459.91775

Table 7. System costs of LinEra (Python, one process on the 2-core Intel Xeon at 2.1 GHz). Write includes the vector index; search is a warm top-10 scan over all shards; forget includes the closure, the puncture, the atomic state write and the shard rebuilds (median of 100 random source turns); state is the PPRF key after these forgets.

Conclusion

Agent memories are mostly made of what the agent wrote itself. Forgetting a user’s input therefore means forgetting its lineage. We defined this property against an adversary that later steals the storage and the current keys, built LinEra from a puncturable PRF and a key graph that follows the lineage, proved it secure, and showed on a real LLM pipeline that the usual deletion methods leave the forgotten information readable while LinEra does not. The price is a larger forgetting radius, which follows a simple fan-in law and which small-context writing and re-derivation bring down sharply. Two questions remain open: hiding the shape of the lineage graph, and connecting storage-level erasure with the unlearning of model weights.

Artifact availability

The implementation of LinEra, the baselines, the canary generator, the logs of every LLM call (prompts, outputs and model file digests) and the scripts that produce every number and table of this paper are publicly available at https://github.com/yulliwasameur/linera and archived on Zenodo [42] (doi:10.5281/zenodo.24166476). The code is released under the MIT licence. The logs contain text derived from LoCoMo and LongMemEval and are released under the terms of those datasets; the datasets themselves are not redistributed, and the scripts download them from their original sources. All runs use seed 20261109.

Data availability

The code, the logs of every LLM call and the scripts that produce every number of this paper are deposited on Zenodo [42] (doi:10.5281/zenodo.24166476) and mirrored at https://github.com/yulliwasameur/linera. LoCoMo and LongMemEval are public datasets and are not redistributed.

CRediT authorship contribution statement

Yullıwas Ameur: Conceptualization, Methodology, Software, Formal analysis, Investigation, Data curation, Visualization, Writing – original draft, Writing – review & editing. Billal Mokhtari: Investigation, Software, Validation, Data curation, Writing – review & editing. Samia Bouzefrane: Supervision, Writing – review & editing.

Declaration of competing interest

The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

Funding

This work was supported by a French government grant managed by the Agence Nationale de la Recherche under the “Investissements d’avenir” program (reference “ANR-21-ESRE-0051”), through the MesONET computing resources used for the GPU experiments. The funding source had no involvement in the study design, in the collection, analysis and interpretation of data, in the writing of the report, or in the decision to submit the article for publication.

Acknowledgements

Centre de Calcul Intensif d’Aix-Marseille is acknowledged for granting access to its high performance computing resources.

Declaration of generative AI and AI-assisted technologies in the manuscript preparation process

During the preparation of this work the authors used Claude (Anthropic) to assist with writing code and experiment scripts, and with drafting, editing and formatting parts of the text. The research questions, the reading and analysis of the literature, and the scientific choices and conclusions are the authors’ own. After using this tool, the authors reviewed and edited the content as needed and take full responsibility for the content of the published article.

Proof of Theorem 1

We write Pr⁡[Hi]\Pr[H_i] for the probability that b′=bb'=b in game HiH_i, so that AdvLinERAlcfs(A)=2∣Pr⁡[H0]−12∣\mathrm{Adv}^{\mathrm{lcfs}}_{\mathrm{LinERA}}(\mathcal{A})=2\lvert\Pr[H_0]-\frac{1}{2}\rvert. All oracles are lazily sampled tables shared by the challenger and A\mathcal{A}; the challenger’s own queries are not visible to A\mathcal{A}.

H0H_0: The real game GLinERAlcfs(A)\mathrm{G}^{\mathrm{lcfs}}_{\mathrm{LinERA}}(\mathcal{A}). A ROTATE call replaces the whole PPRF key by a fresh one; since a discarded key is never given to A\mathcal{A}, we treat it below as a key in which every point is punctured.

H1H_1: punctured leaves become uniform. Call a GGM node hidden if it is a prefix of a punctured tag (root and leaf included) and does not belong to the key returned by CORRUPT. There are at most ∣Φ∣(n+1)\lvert\Phi\rvert(n+1) hidden nodes per key. A hidden node is either the root, which is uniform, or the output Gb(s)G_b(s) of a hidden parent ss. Revealed nodes are children of hidden nodes (the siblings kept by Puncture) or descend from revealed nodes. In H1H_1 the challenger answers every evaluation that passes through a hidden node with fresh uniform values, kept consistent across calls, instead of querying GG. The two games differ only if A\mathcal{A} queries GG on (b∥s)(b\mathbin{\|}s) for a hidden seed ss. Until that event, each hidden seed is uniform in {0,1}λ\{0,1\}^{\lambda} given A\mathcal{A}'s view: the root is sampled uniformly and the value of a hidden non-root node is a random-oracle output on an input that A\mathcal{A} has not queried (by induction from the root). A union bound over the qGq_G queries gives

∣Pr⁡[H0]−Pr⁡[H1]∣≤qG∣Φ∣(n+1)/2λ.\lvert\Pr[H_0]-\Pr[H_1]\rvert\le q_G\lvert\Phi\rvert(n+1)/2^\lambda.

In H1H_1 the leaf value rt=F(S,t)r_t=F(S,t) of every t∈Φt\in\Phi is uniform and independent of A\mathcal{A}'s view.

H2H_2: closure keys become uniform. Order the keys derived during the game by creation time. In H2H_2, every object key kok_o with o∈Cl(Φ)o\in\mathrm{Cl}(\Phi) and every shard key whose shard version contains a member of Cl(Φ)\mathrm{Cl}(\Phi) is replaced by a fresh uniform string, used consistently. We argue by induction that each replaced key is the HKDF output on an input xx that contains a block which is uniform and hidden:

  • a source o∈Cl⁡(Φ)o \in\operatorname{Cl}(\Phi) is in Φ\Phi (sources have no ancestors), and ko=rtok_o = r_{t_o} is uniform by H1H_1;

  • a derived o∈Φo \in\Phi has the block rtor_{t_o} in its HKDF input;

  • a derived o∈Cl⁡(Φ)∖Φo \in\operatorname{Cl}(\Phi) \setminus\Phi has a parent p∈Cl⁡(Φ)p \in\operatorname{Cl}(\Phi) created earlier, whose key is uniform by the induction hypothesis and appears as a block of xx;

  • a shard key mixes the key of a member in Cl⁡(Φ)\operatorname{Cl}(\Phi).

HKDF inputs are pairwise distinct, because the infoinfo field contains the unique tag (objects) or the unique shard identifier and version (shards). Hence each replaced output is a random-oracle answer on a fresh input, and H1H_1 and H2H_2 differ only if A\mathcal{A} queries HKDF on one of these NKN_K inputs, which requires guessing a uniform 256-bit block:

∣Pr⁡[H1]−Pr⁡[H2]∣≤qHNK/2λ.\left| \Pr[H_1] - \Pr[H_2] \right| \le q_H N_K / 2^\lambda.

H3H_3: challenge ciphertexts become independent of bb. In H2H_2 every ciphertext that encrypts challenge content is produced under a key that is uniform, independent of everything else, and used for exactly one encryption: an object key encrypts one object once (a Rotate derives new keys), and a shard key encrypts one shard version once. Validity guarantees that every challenge object is in Cl⁡(Φ)\operatorname{Cl}(\Phi), hence covered. In H3H_3 we replace, one by one, each of the CC such ciphertexts by an encryption of 0∣m∣0^{|m|} under the same key. Each step is bounded by the one-time IND-CPA advantage of an adversary B\mathcal{B} that simulates the rest of the game (it samples all other keys itself), so

∣Pr⁡[H2]−Pr⁡[H3]∣≤C⋅Adv⁡AEADot-ind(B).\left| \Pr[H_2] - \Pr[H_3] \right| \le C \cdot\operatorname{Adv}_{\mathrm{AEAD}}^{\mathrm{ot\text{-}ind}}(\mathcal{B}).

In H3H_3 the view of A\mathcal{A} is independent of bb and Pr⁡[H3]=12\Pr[H_3] = \frac{1}{2}. Summing the three bounds and multiplying by two gives the theorem. ■

On re-derivation. Re-derived objects are ordinary new objects whose parents are surviving objects. They are outside the closure of past forget requests, and the theorem says nothing about them; Lemma 1 says that, under the sound rule, their content does not depend on the forgotten sources.

A Standard-Model Proof

We now remove the random oracles. Two changes are needed. First, the GGM PPRF is only known to be secure when the punctured point is fixed in advance (selective security); we avoid exponential guessing by guessing one forgotten ancestor per challenge object, at a polynomial cost. Second, HKDF must behave as a PRF when it is keyed through one block of its input.

Definition 2 (Block-keyed PRF). For a position jj, let

Hk(j)(x1,…,xm,info)=HKDF(x1∥⋯∥xj−1∥k∥xj∥⋯∥xm;info)H_k^{(j)}(x_1,\ldots,x_m,info) = \mathrm{HKDF}(x_1 \mathbin\Vert\cdots\mathbin\Vert x_{j-1} \mathbin\Vert k \mathbin\Vert x_j \mathbin\Vert\cdots\mathbin\Vert x_m;info)

with k∈{0,1}256k \in\{0,1\}^{256}. HKDF is a block-keyed PRF if, for every jj, Hk(j)H_k^{(j)} is a PRF keyed by kk, with all other blocks and the infoinfo field chosen by the distinguisher. We write Adv⁡Hprf\operatorname{Adv}_H^{\mathrm{prf}} for the best advantage over all positions.

With an empty salt, HKDF-Extract computes HMAC(0256,⋅)(0^{256},\cdot), so the definition asks HMAC to be a PRF when keyed through its message. This is a dual-PRF-style assumption on the underlying compression function, of the kind studied by Bellare [35].

Key separation. In the random-oracle proof, an object key may be used both to encrypt the object and to derive its children’s keys. In the standard model we use the usual separation: the AEAD key of oo is HKDF(ko,"lf-enc")(k_o,\text{"lf-enc"}) and only kok_o enters the children’s derivations. This costs one HKDF call per object; our implementation and measurements use kok_o directly, which the random-oracle theorem covers.

Theorem 3 (LC-FS in the standard model). Let A\mathcal{A} be a valid adversary that creates at most NN objects, of which C′C' are challenge objects, and let ℓ\ell be the length of the longest path in the lineage graph and VV the largest number of shard versions that contain one object. Then there are adversaries B1,B2,B3\mathcal{B}_1,\mathcal{B}_2,\mathcal{B}_3, running in about the time of A\mathcal{A}, such that

Adv⁡LinERAlcfs(A)≤2C′N(n⋅Adv⁡Gprg(B1)+ℓ⋅Adv⁡Gprf(B2)+(1+V)⋅Adv⁡AEADot-ind(B3)).\operatorname{Adv}_{\mathrm{LinER}_{\mathrm{A}}}^{\mathrm{lcfs}}(\mathcal{A}) \le2C'N\left(n\cdot\operatorname{Adv}_{G}^{\mathrm{prg}}(\mathcal{B}_1) + \ell\cdot\operatorname{Adv}_{G}^{\mathrm{prf}}(\mathcal{B}_2) + (1+V)\cdot\operatorname{Adv}_{\mathrm{AEAD}}^{\mathrm{ot\text{-}ind}}(\mathcal{B}_3)\right).

Proof. Step 0: one challenge at a time. A standard hybrid over the C′C' challenge objects, switching their content from m0m_0 to m1m_1 one by one, reduces the game to adversaries with a single challenge object d∗d^*, at a loss of a factor C′C'.

Step 1: guess one forgotten ancestor. Since A\mathcal{A} is valid, d∗∈Cl⁡(Φ)d^* \in\operatorname{Cl}(\Phi), so there is an object a∗∈Φa^* \in\Phi with a∗=d∗a^* = d^* or a∗∈Anc⁡(d∗)a^* \in\operatorname{Anc}(d^*), and a path a∗=u0→u1→⋯→uL=d∗a^* = u_0 \to u_1 \to\cdots\to u_L = d^* in the lineage graph with L≤ℓL \le\ell. The reduction guesses the index of a∗a^* among the NN objects that A\mathcal{A} will create, and aborts if a∗a^* turns out not to be forgotten or not to be an ancestor of d∗d^*. The guess is correct with probability at least 1/N1/N and is independent of A\mathcal{A}’s view, which costs a factor NN.

Step 2: the leaf of a∗a^* is pseudorandom. Tags are drawn by the store, so the reduction picks x∗=ta∗x^* = t_{a^*} itself before any key exists. It obtains from the selective PPRF challenger the key punctured at x∗x^* and a value y∗y^* that is either F(s,x∗)F(s,x^*) or uniform. With the punctured key it evaluates every other tag, uses y∗y^* for x∗x^*, and applies the adversary’s later forget requests to the punctured key. Since a∗∈Φa^* \in\Phi, the key it returns at corruption is exactly the one of the real game. Selective security of GGM reduces to the PRF with a loss of nn, one hybrid per tree level [7, 10, 9].

Step 3: the path keys are pseudorandom. With y∗y^* uniform, ku0k_{u_0} is uniform: it is y∗y^* if u0u_0 is a source, and Hy∗(j)(⋅)H_{y^*}^{(j)}(\cdot) otherwise. For i=1,…,Li=1,\ldots,L, ui−1u_{i-1} is a parent of uiu_i, so every derivation that uses kui−1k_{u_{i-1}} is an evaluation of H(j)H^{(j)} keyed by kui−1k_{u_{i-1}} on distinct inputs (the infoinfo field contains the child’s tag). Replacing these evaluations by a random function, one path step at a time, makes kuik_{u_i} uniform; this costs at most ℓ\ell PRF advantages. The same argument covers the shard keys of the versions that contain d∗d^*, which are keyed through kd∗k_{d^*}.

Step 4: encryption. The AEAD key of d∗d^* and the keys of at most VV shard versions that hold its vector are now uniform and each is used once, so the 1+V1 + V ciphertexts that depend on the challenge bit can be switched by one-time IND-CPA. Collecting the factors C′C', NN and the factor 22 that turns probabilities into advantages gives the bound. □\square

The loss C′NℓC'N\ell is polynomial. For the random 32-bit tags of our implementation, the store must also avoid tag collisions, which it does by rejection; a deployment that expects more than 2202^{20} objects per key should use 64-bit tags, which only lengthens the GGM paths (n=64n = 64).

References

  1. [1]P. Chhikara, D. Khant, S. Aryan, T. Singh, D. Yadav, Memo: Building production-ready AI agents with scalable long-term memory, arXiv:2504.19413 (2025). arXiv:2504.19413.
  2. [2]European Parliament and Council, Regulation (EU) 2016/679 (general data protection regulation), article 17: Right to erasure, Official Journal of the European Union, L 119 (2016).
  3. [3]P. Singhal, ForgetAgent: Verifiable deletion in multi-layer memory architectures for LLM agents, International Journal for Research in Applied Science and Engineering Technology (2026). doi:10.22214/ijraset.2026.78270.DOI
  4. [4]C. Yao, Y. Wei, Z. Huang, J. Qian, C. Chen, S. Lu, C. Wu, L. He, Forgetting without restarting: Execution-state unlearning for stateful LLM agents, arXiv:2609.04875 (2026). arXiv:2609.04875.arxiv.org/abs/2609.04875
  5. [5]Z. Ratliff, W. Goh, A. Wieland, J. Mickens, R. Williams, Holepunch: Fast, secure file deletion with crash consistency, in: Proc. IEEE Symposium on Security and Privacy, 2024. doi:10.1109/SP54263.2024.00237.DOI
  6. [6]C. Chakraborttii, J. García Alvarado, S. Abdulolfizova, S. Dwivedi, Ghost vectors: Soft-deleted embeddings remain reconstructible in HNSW vector databases, arXiv:2606.18497 (2026). arXiv:2606.18497.arxiv.org/abs/2606.18497
  7. [7]D. Boneh, B. Waters, Constrained pseudorandom functions and their applications, in: Advances in Cryptology – ASIACRYPT 2013, Vol. 8270 of LNCS, Springer, 2013, pp. 280–300. doi:10.1007/978–3–642–42045–0_15.
  8. [8]O. Goldreich, S. Goldwasser, S. Micali, How to construct random functions, Journal of the ACM 33 (4) (1986) 792–807. doi:10.1145/6490.6503.DOI
  9. [9]A. Kiayias, S. Papadopoulos, N. Triandopoulos, T. Zacharias, Delegatable pseudorandom functions and applications, in: Proc. ACM CCS, 2013, pp. 669–684. doi:10.1145/2508859.2516668.DOI
  10. [10]E. Boyle, S. Goldwasser, I. Ivan, Functional signatures and pseudorandom functions, in: Public-Key Cryptography – PKC 2014, Vol. 8383 of LNCS, Springer, 2014, pp. 501–519. doi:10.1007/978–3–642–54631–0_29.
  11. [11]G. Fuchsbauer, M. Konstantinov, K. Pietrzak, V. Rao, Adaptive security of constrained PRFs, in: Advances in Cryptology – ASIACRYPT 2014, Vol. 8874 of LNCS, Springer, 2014, pp. 82–101. doi:10.1007/978–3–662–45608–8_5.
  12. [12]M. D. Green, I. Miers, Forward secure asynchronous messaging from puncturable encryption, in: Proc. IEEE Symposium on Security and Privacy, 2015, pp. 305–320. doi:10.1109/SP.2015.26.DOI
  13. [13]D. Derler, K. Gellert, T. Jager, D. Slamanig, C. Striecks, Bloom filter encryption and applications to efficient forward-secret 0-RTT key exchange, Journal of Cryptology 34 (2) (2021). doi:10.1007/s00145-021-09374-3.DOI
  14. [14]N. Aviram, K. Gellert, T. Jager, Session resumption protocols and efficient forward security for TLS 1.3 0-RTT, Journal of Cryptology 34 (3) (2021). doi:10.1007/s00145-021-09385-0.DOI
  15. [15]M. Backendal, F. Günther, K. G. Paterson, Puncturable key wrapping and its applications, in: Advances in Cryptology – ASIACRYPT 2022, Vol. 13792 of LNCS, Springer, 2022, pp. 651–681. doi:10.1007/978–3–031–22966–4_22.DOI
  16. [16]J. Reardon, D. Basin, S. Capkun, SoK: Secure data deletion, in: Proc. IEEE Symposium on Security and Privacy, 2013, pp. 301–315. doi:10.1109/SP.2013.28.DOI
  17. [17]J. Wei, X. Chen, J. Wang, X. Huang, W. Susilo, Securing fine-grained data sharing and erasure in outsourced storage systems, IEEE Transactions on Parallel and Distributed Systems 34 (2) (2023) 552–566. doi:10.1109/TPDS.2022.3225274.DOI
  18. [18]Y. Yang, H. Ma, J. Zhang, Y. Li, B. Li, W. Wang, EPCS: Erasable and portable cloud storage with oblivious key management, IEEE Transactions on Information Forensics and Security (2026). doi:10.1109/TIFS.2026.3737708.DOI
  19. [19]L. Bourtoule, V. Chandrasekaran, C. A. Choquette-Choo, H. Jia, A. Travers, B. Zhang, D. Lie, N. Papernot, Machine unlearning, in: Proc. IEEE Symposium on Security and Privacy, 2021, pp. 141–159. doi:10.1109/SP40001.2021.00019.
  20. [20]J. Lin, G. Xu, Z. Xu, J. Chen, X. Lan, Can agents truly forget? explore machine unlearning for LLM agents, arXiv:2610.17659 (2026). arXiv:2610.17659.
  21. [21]J. Liu, M. Li, Deletion is not forgetting: Behavioral residuals of deleted memories in stateful LLM agents, SSRN preprint (2026). doi:10.2139/ssrn.7428966.DOI
  22. [22]A. Mukkuzhi, N. Uwayisenga, Y. Bizualem, J. Kammerzell, C. Chakraborttii, Ghost echoes: Semantic erasure failure in retrieval-backed applications, arXiv:2608.20352 (2026). arXiv:2608.20352.arxiv.org/abs/2608.20352
  23. [23]C. Ouyang, R. Hou, MemLineage: Lineage-guided enforcement for LLM agent memory, arXiv:2605.14421 (2026). arXiv:2605.14421.arxiv.org/abs/2605.14421
  24. [24]Y. Zhao, C. Dai, M. Kou, Y. Xiu, MemoRepair: Barrier-first cascade repair in agentic memory, arXiv preprint arXiv:2605.07242 (2026). arXiv:2605.07242.arxiv.org/abs/2605.07242
  25. [25]B. Wang, F. Wang, P. Wang, J. Cong, Y. Yu, Y. Yin, Z. Han, B. Wei, Agentic unlearning: When LLM agent meets machine unlearning, arXiv preprint arXiv:2602.17692 (2026). arXiv:2602.17692.arxiv.org/abs/2602.17692
  26. [26]B. Xie, C. Wang, G. Ge, S. Wang, F. Niu, H. Zhang, W. Wang, Can agents forget when asked? A benchmark for memory unlearning in LLM agents, arXiv preprint arXiv:2610.18052 (2026). arXiv:2610.18052.arxiv.org/abs/2610.18052
  27. [27]Y. Ameur, T. Madani, S. Bouzefrane, Recovery budgets for persistent AI-agent memory: Bounding revocation liability, Preprint, Research Square; artifact: Zenodo, doi:10.5281/zenodo.23626873 (2026).
  28. [28]H. Krawczyk, Cryptographic extraction and key derivation: The HKDF scheme, in: Advances in Cryptology – CRYPTO 2010, Vol. 6223 of LNCS, Springer, 2010, pp. 631–648. doi:10.1007/978-3-642-14623-7_34.DOI
  29. [29]H. Krawczyk, P. Eronen, HMAC-based extract-and-expand key derivation function (HKDF), RFC 5869 (2010). doi:10.17487/RFC5869.DOI
  30. [30]Y. Nir, A. Langley, ChaCha20 and Poly1305 for IETF protocols, RFC 8439 (2018). doi:10.17487/RFC8439.DOI
  31. [31]P. Rogaway, Authenticated-encryption with associated-data, in: Proc. ACM CCS, 2002, pp. 98–107. doi:10.1145/586110.586125.DOI
  32. [32]J. Morris, V. Kuleshov, V. Shmatikov, A. Rush, Text embeddings reveal (almost) as much as text, in: Proc. EMNLP, 2023. doi:10.18653/v1/2023.emnlp-main.765.DOI
  33. [33]Y. A. Malkov, D. A. Yashunin, Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs, IEEE Transactions on Pattern Analysis and Machine Intelligence 42 (4) (2020) 824–836. doi:10.1109/TPAMI.2018.2889473.DOI
  34. [34]M. Bellare, P. Rogaway, Random oracles are practical: A paradigm for designing efficient protocols, in: Proc. ACM CCS, 1993, pp. 62–73. doi:10.1145/168588.168596.
  35. [35]M. Bellare, New proofs for NMAC and HMAC: Security without collision resistance, Journal of Cryptology 28 (4) (2015) 844–878. doi:10.1007/s00145-014-9185-x.
  36. [36]Owen Team, Owen2.5 technical report, arXiv:2412.15115 (2024). arXiv:2412.15115.
  37. [37]A. Grattafiori, et al., The Llama 3 herd of models, arXiv:2407.21783 (2024). arXiv:2407.21783.arxiv.org/abs/2407.21783
  38. [38]W. Kwon, Z. Li, S. Zhuang, Y. Sheng, L. Zheng, C. H. Yu, J. E. Gonzalez, H. Zhang, I. Stoica, Efficient memory management for large language model serving with Page-dAttention, in: Proc. ACM SOSP, 2023, pp. 611–626.
  39. [39]S. Xiao, Z. Liu, P. Zhang, N. Muennighoff, D. Lian, J.-Y. Nie, C-Pack: Packed resources for general Chinese embeddings, arXiv:2309.07597 (2023). arXiv:2309.07597.arxiv.org/abs/2309.07597
  40. [40]A. Maharana, D.-H. Lee, S. Tulyakov, M. Bansal, F. Barbieri, Y. Fang, Evaluating very long-term conversational memory of LLM agents, in: Proc. ACL (Volume 1: Long Papers), 2024, pp. 13851–13870. doi:10.18653/v1/2024.acl-long.747.DOI
  41. [41]D. Wu, H. Wang, W. Yu, Y. Zhang, K.-W. Chang, D. Yu, LongMemEval: Benchmarking chat assistants on long-term interactive memory, in: Proc. ICLR, 2025, arXiv:2410.10813.arxiv.org/abs/2410.10813
  42. [42]Y. Ameur, B. Mokhtari, S. Bouzefrane, LinerEra: Lineage-complete, forward-secure erasure for LLM-agent memory (code and LLM logs), version 1.0.0 [software], Zenodo (2026). doi:10.5281/zenodo.24166476.arxiv.org/abs/2611.18133

Paper details

vlnc:W_vxpphm8q
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Claude (Anthropic)

View statement
Looking for related papers…
Contents