InfoMem: Information-Centric Memory in LLMs

• InfoMem is an information-centric framework that guides how LLMs encode, preserve, retrieve, update, and delete information under bounded contexts.
• It introduces modular memory subsystems that balance storage volume with evidence relevance using techniques such as graph updates, chunk-wise rewards, and iterative retrieval.
• The design targets efficient long-horizon performance and personalization by integrating strategies like memory bottlenecks, semantic-symbolic fusion, and controlled forgetting.

InfoMem is an information-centric view of memory for LLMs and agents in which the primary question is not merely how to store more context, but how to encode, preserve, retrieve, update, and, when necessary, delete information so that future tasks remain well supported under constraints of latency, bounded context, personalization, and maintainability. Recent work uses the term in closely related but not identical senses: as an information-theoretic memory bottleneck for long-horizon agents, as an answer-conditioned reward for training chunk-wise memory agents, and as a broader design target for modular memory subsystems that remain effective under noisy corpora, long documents, or multimodal retention (Zhang et al., 8 Feb 2026, Han et al., 2 Jun 2026, Quek et al., 14 May 2026).

1. Problem setting and scope

In the long-context setting studied by the reward mechanism called InfoMem, a document or corpus $D$ is split into chunks $D=\{c_1,\ldots,c_K\}$, and a chunk-wise agent updates a compact memory summary according to

$$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$

with each chunk about 5000 tokens and memory truncated to at most 1024 tokens (Han et al., 2 Jun 2026). The central difficulty is that the agent must preserve answer-relevant evidence while discarding noise, even though the evidence may be sparse and distributed.

A related formulation appears in MeMo, which defines a general knowledge integration mechanism

$$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$

for a frozen Executive $M_\theta$ with only black-box access, and instantiates $K$ as the parameters of a separate memory model $M_\varphi$ rather than a retrieval index or modified base-model weights (Quek et al., 14 May 2026). In this setting, InfoMem refers to the problem of incorporating new, timely, domain-specific knowledge without modifying the Executive and without paying inference cost that grows with corpus size.

Other systems expand the scope from question answering over a fixed corpus to persistent, cross-session agent memory. MemFly treats the memory state $M_t$ as a graph over Notes, Keywords, and Topics that evolves online under an information bottleneck objective (Zhang et al., 8 Feb 2026). Infini Memory treats persistent memory as topic-structured Markdown documents maintained over time through buffering, rewriting, routing, splitting, and merging (Ji et al., 9 Jun 2026). AdaMem frames long-horizon personalization as a write-control problem in which an agent must learn what to remember for each role or user rather than remembering everything uniformly (Chen et al., 19 Jun 2026). SwiftMem emphasizes low-latency retrieval over long conversational histories through query-aware temporal and semantic indexing (Tian et al., 13 Jan 2026). MemLeak extends the setting further by showing that fact-level forgetting in multimodal agent memory is not equivalent to deleting a text record, because retained images and other residual representations can still support recovery of the deleted fact (Wang et al., 29 Jun 2026).

This suggests that InfoMem is best understood as a design space spanning bounded working memory, persistent memory stores, modular memory models, and deletion-aware multimodal memory, rather than as a single architecture.

2. Formal objectives and information-based criteria

The most explicit information-theoretic formalization is MemFly’s Memory Information Bottleneck objective,

$$\min_{\pi}\mathcal L_{\mathrm{IB}}(M_t)=\min_{\pi}\left[I(X_{1:t};M_t)-\beta I(M_t;Y)\right],$$

where $X_{1:t}$ is the interaction history, $D=\{c_1,\ldots,c_K\}$0 the memory state, and $D=\{c_1,\ldots,c_K\}$1 unknown future reasoning tasks (Zhang et al., 8 Feb 2026). The first term measures representational complexity or compression, and the second measures relevance to future tasks. Because direct optimization is intractable, MemFly uses structural proxies such as local coherence and global navigability, together with an online merge/link/append policy.

The paper InfoMem introduces a different but related objective: answer-conditioned information gain as a reward for chunk-wise memory agents,

$D=\{c_1,\ldots,c_K\}$2

This quantity measures the average per-token log-likelihood gain of the ground-truth answer $D=\{c_1,\ldots,c_K\}$3 when conditioning on the final memory $D=\{c_1,\ldots,c_K\}$4 rather than a null memory (Han et al., 2 Jun 2026). The reward is applied only to successful rollouts, normalized across successful trajectories in a GRPO group, and then added to the binary outcome reward with $D=\{c_1,\ldots,c_K\}$5. Analyses show that effective final-memory rewards should operate on successful trajectories, be normalized before reward composition, and be conditioned on the answer rather than the query (Han et al., 2 Jun 2026).

MeMo offers a complementary formal perspective. It formalizes the knowledge integration problem as finding $D=\{c_1,\ldots,c_K\}$6 such that, for all queries $D=\{c_1,\ldots,c_K\}$7,

$D=\{c_1,\ldots,c_K\}$8

while keeping the Executive $D=\{c_1,\ldots,c_K\}$9 frozen and delegating corpus-specific knowledge to a separate memory model $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$0 with $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$1 parameters (Quek et al., 14 May 2026). In MeMo, the memory is not a retriever over documents but a small QA model specialized to a target corpus.

These formulations are not identical, but they converge on the same principle: memory quality is defined by the extent to which retained information reduces uncertainty about future answers or tasks, not by storage volume alone. This suggests a common InfoMem criterion across architectures: retained state should be evaluated by its incremental utility for downstream inference.

3. Memory representations and write/update mechanisms

Recent InfoMem systems differ most sharply in what they treat as the memory object and how that object is updated. MeMo encodes corpus knowledge into a dedicated parametric Memory $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$2 trained on a synthetic reflection QA dataset

$$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$3

where $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$4 contains self-contained fact questions, $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$5 entity-surfacing questions, and $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$6 cross-document synthesis questions (Quek et al., 14 May 2026). MemFly stores a stratified graph $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$7 over Notes, Keywords, and Topics, and updates it online via an LLM-gated choice among Merge, Link, and Append operations (Zhang et al., 8 Feb 2026). Infini Memory stores topic documents with YAML-like headers and bullet-level metadata such as seq, time, and source, using a CURRENT buffer that is periodically rewritten and routed into the document library (Ji et al., 9 Jun 2026). InfMem keeps a bounded textual memory $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$8 and updates it through PreThink–Retrieve–Write with evidence-aware joint compression (Wang et al., 2 Feb 2026). AdaMem combines a standard memory store with a role-specific natural-language Memory Policy $$M_t=\pi_\theta(M_{t-1},c_t,x), \qquad \hat y=\pi_\theta(x,M_K),$$9, refining the policy weekly via patch-style self-reflection and failure rollback (Chen et al., 19 Jun 2026).

The main memory forms can be summarized as follows.

System	Memory representation	Update mechanism
MeMo	Separate memory LLM $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$0	Offline reflection generation and supervised fine-tuning
MemFly	Note–Keyword–Topic graph	Gated Merge/Link/Append and topic reclustering
Infini Memory	Topic-structured Markdown documents	Buffering, rewrite, routing, split, merge
InfMem	Bounded textual memory $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$1	PreThink–Retrieve–Write compression
AdaMem	Memory store plus role-specific policy text	Weekly reflection patch and rollback

MeMo’s cross-document structure is pushed into training time rather than retrieval time. Its Generator first extracts direct and indirect facts, consolidates questions with common context, rewrites them to be self-contained, builds entity-surfacing questions, and finally synthesizes cross-document questions over topically related groups of chunks (Quek et al., 14 May 2026). Appendix ablations show that removing the cross-document synthesis step collapses performance, with NarrativeQA dropping from 24.0% to 6.37% and MuSiQue from 42.9% to 24.17% (Quek et al., 14 May 2026).

MemFly’s update policy is more explicitly online. A new observation is transformed into a Note $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$2, where $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$3 is raw content, $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$4 a denoised context, $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$5 an embedding, and $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$6 a set of Keywords (Zhang et al., 8 Feb 2026). If redundancy exceeds $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$7, the note is merged; if complementarity exceeds $$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$8, a relation edge is created; otherwise the note is appended. Topic evolution then reclusters the keyword co-occurrence graph using Leiden modularity subject to size constraints (Zhang et al., 8 Feb 2026).

Infini Memory emphasizes maintainable text. A flush occurs when

$$(\Phi,f):\quad K=\Phi(\mathcal D),\qquad \hat a(q)=f(M_\theta,K,q),$$9

with $M_\theta$0 in experiments (Ji et al., 9 Jun 2026). The buffer is rewritten into a normalized draft, routed to existing or new topic documents through SafePlanUpdate, and then merged or split under token thresholds. Contradictions are resolved by recency, with preference for user-sourced entries over AI-sourced ones when they conflict (Ji et al., 9 Jun 2026).

AdaMem’s key move is to learn the write criterion itself. Incorrect weekly QA answers are analyzed as either recall failures, where relevant information was present in the dialogue but not extracted, or precision failures, where noisy memory or retrieval degraded answering. The system proposes a candidate patch $M_\theta$1, applies it to obtain $M_\theta$2, and rolls back if historical validation does not improve (Chen et al., 19 Jun 2026).

4. Retrieval, read-time control, and efficiency

Read-time control is a second major axis of InfoMem design. MeMo eliminates a retrieval index at inference time: the Executive first generates clue-probing sub-queries for Memory, then performs entity identification, then answer seeking and synthesis through a purely textual multi-turn protocol (Quek et al., 14 May 2026). Each query triggers Stage 1 with a fixed or bounded number of Memory calls, Stage 2 with up to 7 entity-identification iterations, and Stage 3 with up to 8–15 answer-seeking iterations; the resulting retrieval cost is $M_\theta$3 with $M_\theta$4 fixed by protocol design rather than corpus size (Quek et al., 14 May 2026). This is one of the clearest instantiations of the InfoMem requirement that inference cost be independent of corpus size once memory is trained.

SwiftMem instead retains retrieval but makes it query-aware and sub-linear. Its temporal index organizes each user’s episodes in sorted timelines $M_\theta$5 that support range queries in $M_\theta$6, while the semantic DAG-Tag index routes a query to relevant topics with

$M_\theta$7

before dense similarity search is run on the reduced candidate set (Tian et al., 13 Jan 2026). On LoCoMo, SwiftMem reports 11 ms search latency and 1289 ms total latency, compared with 522 ms search for Zep and 835 ms for Nemori; the abstract summarizes this as $M_\theta$8 faster search than state-of-the-art baselines while maintaining competitive accuracy (Tian et al., 13 Jan 2026).

MemFly uses a tri-pathway retrieval mechanism that combines macro-semantic localization over Topics, micro-symbolic anchoring over Keywords, and topological expansion over Note–Note edges, then fuses ranked lists with Reciprocal Rank Fusion (Zhang et al., 8 Feb 2026). An Iterative Evidence Refinement loop tests whether current evidence is sufficient, and if not, generates a refined sub-query and retrieves again up to $M_\theta$9 iterations (Zhang et al., 8 Feb 2026).

Infini Memory’s read path is explicitly agentic. Infini Memory-H selects candidate documents by summary and then uses BM25 over document partitions, whereas Infini Memory-A lets the LLM iteratively call tools such as list_docs, search, grep_doc, and read_lines for up to 7 iterations before answering (Ji et al., 9 Jun 2026). If evidence is insufficient, a BM25 fallback over heading partitions is invoked, and the CURRENT buffer is appended so that recently acquired information is immediately available (Ji et al., 9 Jun 2026).

A human-facing variant of InfoMem appears in Memoro, a wearable audio memory assistant that continuously transcribes speech, stores timestamped text chunks with all-MiniLM-L6-v2 embeddings, retrieves top-$K$0 semantically similar memories, and uses an LLM to provide minimal suggestions in Query Mode or Queryless Mode (Zulfikar et al., 2024). In a study of $K$1, Memoro reduced device interaction time and increased recall confidence while preserving conversational quality (Zulfikar et al., 2024).

Taken together, these systems suggest a shift from single-step top-$K$2 retrieval toward controlled memory access: bounded multi-turn querying, topic-aware routing, semantic-symbolic-topological fusion, and explicit stopping criteria.

5. Maintainability, forgetting, and deletion

Maintainability has two distinct meanings in the InfoMem literature. The first is model-side stability under updates. MeMo avoids catastrophic forgetting by never training the Executive $K$3; all adaptation occurs in the separate Memory $K$4, which preserves the base model’s general capabilities and safety alignment while allowing plug-and-play use even with closed-source systems such as Gemini-3-Flash (Quek et al., 14 May 2026).

The second is persistent-store maintenance. Infini Memory treats long-term memory as a lifecycle problem of writing, consolidating, and reading. RewriteCurrent deduplicates repeated entries, keeps newer duplicates when they differ only by seq, resolves contradictions so that newer seq wins, and prefers the user’s entry over AI-sourced restatements when facts conflict (Ji et al., 9 Jun 2026). The default thresholds in experiments flush CURRENT at 5000 tokens, split topic documents at token_count ≥ 5000, and merge small documents when token_count ≤ 1000 and summaries are sufficiently similar (Ji et al., 9 Jun 2026). On LongMemEval, removing split and merge lowers Infini Memory-H from 76.0% to 69.3%, indicating that structural maintenance is not cosmetic but functionally important (Ji et al., 9 Jun 2026).

A third, more stringent notion of forgetting is behavioral erasure after a deletion request. MemLeak introduces the Information Provenance Graph $K$5, where $K$6 labels each representation node as addressable, linked, or persistent depending on its deletion affordance (Wang et al., 29 Jun 2026). It defines Forgetting Completeness as

$K$7

but shows empirically that storage-level deletion can still fail behaviorally (Wang et al., 29 Jun 2026). Direct probing of deletion-capable text systems yields less than 1% leakage, yet retained correlated text enables 18.3% recovery and retained images enable 12.0% recovery, with a 0.0% blind baseline and 0.3% false-positive rate; 47% of image leaks are not text-recoverable (Wang et al., 29 Jun 2026). Content-aware semantic deletion, implemented by a VLM auditor over retained images, reduces the image residual to 2.0%, and dual-annotator human validation reports $K$8 (Wang et al., 29 Jun 2026).

These results complicate any purely text-centric notion of InfoMem. A memory system can be updateable, compact, and retrieval-efficient yet still fail at fact-level forgetting if residual multimodal traces remain behaviorally accessible.

6. Empirical landscape, design lessons, and open directions

The reward mechanism titled InfoMem demonstrates that a final-memory reward can improve chunk-wise memory agents under a fixed GRPO setup. Relative to outcome-only GRPO, InfoMem raises CorpusQA from 16.413 to 19.453, LongMemEval from 10.000 to 12.800, MRCR-8needle from 0.063 to 0.279, and RULER synthetic QA from 34.735 to 36.848 (Han et al., 2 Jun 2026). Ablations show that removing $K$9 normalization or replacing answer-conditioned gain with query-conditioned QueryPMI substantially degrades performance, and training diagnostics show that QueryPMI induces a degenerate strategy in which memory starts to repeat the query (Han et al., 2 Jun 2026).

MemFly reports the best average F1 and BLEU-1 across GPT-4o-mini, GPT-4o, Qwen3-8B, and Qwen3-14B on LoCoMo, with especially strong gains in Open Domain and Adversarial categories (Zhang et al., 8 Feb 2026). Its ablations are notable because removing the entire gated update lowers F1 on Qwen3-8B from 38.62 to 27.97 and Recall from 62.22 to 42.11, whereas removing Link can be more harmful than removing Merge in some categories, especially Adversarial, indicating that relational structure is central to relevance rather than a secondary embellishment (Zhang et al., 8 Feb 2026).

InfMem shows that System-2-style memory control can improve both quality and efficiency for ultra-long documents. On Qwen3-1.7B, Qwen3-4B, and Qwen2.5-7B, InfMem improves average absolute accuracy over MemAgent by +10.17, +11.84, and +8.23 points, respectively, while reducing inference time by $M_\varphi$0 on average and up to $M_\varphi$1 via adaptive early stopping (Wang et al., 2 Feb 2026). Its early-stop shaping reward

$M_\varphi$2

aligns stopping time with the first step at which the answer is already derivable from memory (Wang et al., 2 Feb 2026).

MeMo shows a different trade-off: a corpus-specific memory model can be trained once and then attached to stronger Executives later. With a Qwen2.5-14B Memory and a Gemini-3-Flash Executive, MeMo reports 66.67% on BrowseComp-Plus, 53.58% on NarrativeQA, and 60.20% on MuSiQue, while remaining robust to added negative documents in the corpus used for data synthesis (Quek et al., 14 May 2026). AdaMem addresses personalization rather than open-domain corpus integration, improving QA by up to +9.0% over the uniform Mem0 baseline while shrinking memory volume by 9% (Chen et al., 19 Jun 2026). Infini Memory focuses on persistent agent memory and reaches 64.7% overall on MemoryAgentBench, with ablations showing that topic-structured maintenance and iterative evidence inspection improve complementary aspects of long-term memory use (Ji et al., 9 Jun 2026).

Across these systems, several design lessons recur. Separation of concerns between reasoning and memory recurs in MeMo and InfMem; write control recurs in AdaMem and Infini Memory; structural retrieval recurs in MemFly, SwiftMem, and Infini Memory; and answer-conditioned or task-conditioned utility recurs in both the reward-based InfoMem formulation and the broader information bottleneck view (Quek et al., 14 May 2026, Chen et al., 19 Jun 2026, Zhang et al., 8 Feb 2026, Han et al., 2 Jun 2026). A plausible implication is that future InfoMem research will increasingly optimize memory along four coupled axes at once: what to write, how to structure it, how to access it under bounded cost, and how to guarantee that both updates and deletions remain behaviorally faithful.