Should agent memory live inside the model backbone?
Can foundation models improve memory by internalizing persistent memory states and procedures, rather than relying on external modules? This explores whether the asymmetry between internalized perception and external memory represents a real architectural limitation.
The Metis paper starts from an asymmetry: agent capabilities such as multimodal perception and reasoning have been "internalized" into foundation models, yet "agent memory is still primarily implemented through external modules." It proposes memory foundation models to close that gap and defines native memory in two parts. The first is "a persistent and dynamically evolving memory state within the backbone." The second is "native memory procedures that autonomously store and utilize information through model computation." The paper says this offers advantages in architecture, end-to-end optimization, and efficiency, and presents Metis as "the first prototype."
The reasoning in the introduction is a decoupling argument. External memory is "decoupled from backbones with separated targets and processing stages": the memory system builds an informative context, and the backbone then performs conditional language modeling over whatever it was handed. Two failures follow. The memory may not supply what the backbone needs, and the backbone may not use the memory optimally, because neither side is trained against the other's behavior. Metis answers with a different architecture. "Metis blocks" combine local memory blocks and hyper memory blocks, keeping "compact dense memory states across interaction steps" and updating them from the current input and the generated response. History is compressed into the model and read through memory attention. The store-and-use procedures are acquired in mid-training, using a memory-specific dataset built from public benchmarks and three kinds of objective (memory reconstruction, memory operation, regularization).
This sits close to Can neural memory modules scale language models beyond attention limits?, which also puts a compressed, persistent memory inside the network and reads it alongside attention. The difference in emphasis is that Metis treats memory as a capability class the model acquires through training, comparable to reasoning, and not only as an architectural component for long context. It also reframes what How should we actually evaluate agent memory systems? describes. In an external system those four stages are separable modules that can be inspected. In a native design they fold into model computation, so the decomposition that note recommends has no obvious place to attach. The failure modes in Do memory systems actually help language models learn continuously? and Does agent memory degrade when continuously consolidated? belong to external, text-consolidating memory. Native memory is a candidate response to them, but only in the sense that it removes the hand-off the introduction criticizes.
The excerpt does not establish the payoff. It says experiments "verify the effectiveness of Metis" and analyze its behavior, but it gives no benchmarks, baselines, model sizes, memory capacity, or numbers. It also says nothing about how a compressed memory state handles stale or wrong content, and it calls Metis "an early step." The introduction passage shows only the first of the "several limitations" of external memory that its Figure 1 lists. What the paper supports at this strength is a formulation and a prototype design: the decoupling between memory and backbone is a specific, nameable cost of external memory, and end-to-end training is the proposed remedy. Whether that remedy beats external memory on the tasks where external memory fails is left to the full paper and to later work.
Inquiring lines that read this note 15
This note is a source for these research framings, grouped by the broader line of inquiry each explores. Scan the bold lines of inquiry; follow any specific question forward.
How should agents manage memory granularity to improve long-term performance?- Why do analysts prefer visible structured interfaces over hidden agent memory systems?
- Does recoverable content elision in context management match externalized memory benefits?
- How should we evaluate agent memory if it folds into model computation instead of separate stages?
- Does memory granularity need to match the task domain or the model size?
- What shapes of memory help frozen agents improve without retraining?
- When does persistent harmful memory create performance error floors?
- How does textual memory structure affect frozen model improvement?
- Should memory type shape what kind of agent responses work best?
- What makes execution and memory proxies more useful than dynamics prediction alone?
Related concepts in this collection 6
This note in its neighbourhood — explore the map, then jump to a related concept in the list below.
Click a node to walk · click center to open · click Open in graph to see this note in the full knowledge graph
-
Can neural memory modules scale language models beyond attention limits?
Can separating short-term attention from adaptive long-term memory allow models to efficiently handle context windows exceeding 2M tokens while maintaining competitive performance?
closest architectural neighbor: persistent compressed memory read alongside attention; Metis adds the framing of native memory procedures learned in mid-training
-
How should we actually evaluate agent memory systems?
Current benchmarks score agent memory by task success alone, hiding critical design questions about cost, trade-offs, and robustness. What would evaluation reveal if we decomposed memory into its core data-management stages?
external memory decomposes into inspectable stages; native memory folds them into model computation
-
Do memory systems actually help language models learn continuously?
When you subtract what a model already knows, do dedicated memory architectures genuinely enable continual learning, or do they mainly inherit base capability? CL-BENCH isolates learning from prior skill to test this.
documents the external-memory failures that native memory is positioned against, without testing it
-
Does agent memory degrade when continuously consolidated?
Can consolidating agent experiences into summaries actually harm long-term performance? Research on ARC-AGI tasks suggests continuous memory updates may reduce capability below the no-memory baseline.
fragility of consolidated state is the open question a native memory state would also face
-
Has memory architecture replaced parameter count as the scaling frontier?
Late-2025 research suggests the field's next major efficiency gains come from restructuring how models store and use experience rather than simply making them larger. Three convergent signals point to this shift.
Metis is another signal that memory is being restructured at the architecture level
-
Why do retrieval systems fail on queries that never mention needed facts?
Memory retrieval assumes needed information will resemble the query text, but world knowledge often connects facts indirectly. This explores when that assumption breaks and what happens when it does.
Evidence for: retrieval-based external memory systems reach at most 14.4% on indirect queries that a backbone answers 84.0% of the time with the memory in context
Related papers in this collection 8
Papers most semantically related to this note, ranked by cosine similarity in the embedding space.
- Metis: Memory Foundation Model
- Are We Ready For An Agent-Native Memory System?
- Know It, Act on It: Investigating Memory Utilization in LLM Personalization
- Agent Memory Distillation: Empowering Small LLM Agents with Hierarchical Teacher Memory
- Useful Memories Become Faulty When Continuously Updated by LLMs
- Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering
- GateMem: Benchmarking Memory Governance in Multi-Principal Shared-Memory Agents
- The Landscape of Agentic Reinforcement Learning for LLMs: A Survey
Original note title
memory foundation models put a native memory state and native memory procedures inside the backbone instead of leaving agent memory to external modules