Agent memory grew a write path: why memory became a subsystem

An agent that can't remember is a chatbot. An agent that remembers everything it's ever been told is a liability. Getting from one to the other means designing memory as a real subsystem. A survey posted to arXiv in early 2026 shows the field finally treating it that way.

"Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers" (arXiv:2603.07670) covers agent-memory work from 2022 through early 2026. Its frame is clean: memory is a write, manage, read loop that runs alongside perception and action. In our experience, most teams build only the read side, which is retrieval. They treat the write and manage sides as afterthoughts. The survey's argument, and ours, is that the write and manage sides are where systems succeed or quietly rot.

The write problem nobody scopes

Every memory write is a decision: what deserves to persist, in what form, and who or what decided that. Left implicit, the write path inherits whatever the chat log happens to contain. That means half-corrections, stale facts, and other people's assumptions. The survey lists write-path filtering as one of its engineering realities. Our reason to care is simple: if you add filtering later, you have to audit everything you already stored.

This maps directly onto how we work in Presence, our human-in-the-loop (HITL) living lab for LLM Ops research. HITL means a person approves before anything goes out. In Presence, a human approves everything that goes public. No outbound event moves without a Board sign-off. Our aim is to treat the durable record the same way, with a person choosing what stays. That's not because automation can't do the write. It's because an unreviewed write that turns out wrong is unforgivable.

Learned control is the interesting part

The survey sorts memory along three axes: time scope, storage substrate, and control policy. It groups the mechanisms into five families: context-resident compression, retrieval-augmented stores (what RAG, or retrieval-augmented generation, formalizes), reflective self-improvement, hierarchical virtual context, and policy-learned management.

That last family is the one to watch. Work like Agentic Memory (Yu et al., 2026, arXiv:2601.01885) trains store, retrieve, update, summarize, and discard as tools the model calls. The model picks among them through reinforcement learning, meaning it's trained on rewards for good outcomes. Memory operations become policy actions instead of hardcoded scripts. The model learns *when* to remember. That's the judgment call every hand-built memory system pretends it doesn't have to make.

Two things follow. First, learned forgetting is now an open research problem, not a nice-to-have. A system that can't forget piles up contradictions. The survey names contradiction handling as an engineering reality, and it lists learned forgetting among its open challenges, next to continual consolidation and causally grounded retrieval. Second, learned control doesn't remove the human. It moves the human's job from writing rules to auditing policies. That's a governance question, not a prompting question.

Evaluation moved too

Static recall benchmarks ask whether the model can repeat a fact from ten sessions ago. They're giving way to multi-session agentic tests that mix memory with decision-making. The survey analyzes four recent benchmarks, and they expose stubborn gaps: systems that recall well still stumble when memory has to drive the next action. If you're evaluating any memory-flavored product, ask which benchmark family the numbers come from. "Great at recall" and "great at remembering the thing that should have changed your action" are different claims. Only the second one pays.

What we'd take from it

  • Scope the write path like a product surface: what gets stored, by whom, with an audit trail. In Presence that means approval gates on everything that goes public. Nothing in this post implies Presence publishes or replies on its own. It doesn't.
  • Treat memory as a first-class subsystem with its own benchmarks, not a bolt-on to the prompt.
  • Budget for contradiction handling before you scale the store. Our take: a small, curated, reviewed memory beats a large, polluted one.
  • If you adopt learned memory policies, add policy audits to your review loop. A model that chooses its own writes still answers to someone.

MeltingFace is an LLM Ops research consultancy. We set up agents to do a company's repeatable work while its people keep the goals, the brand, and the spend. Presence is where we run these ideas on ourselves, as a HITL living lab. It isn't a chatbot SaaS. If treating memory as a subsystem changes how you'd run your own stack, see how we run Presence on ourselves.

MeltingFace