What makes a memory reachable in the right context?
This explores what determines whether a stored memory actually surfaces when it's needed — and the corpus's striking answer is that reachability is a property of structure and indexing, not of storage.
This explores what makes a memory *reachable* when it matters — not whether it was saved, but whether the system can find it at decision time. The most direct answer in the corpus is that this is a connectivity problem, not a storage one. Is agent memory a storage problem or a connectivity problem? argues that storage is necessary but inert: what determines usefulness is the topology of links between co-activated units. A memory is reachable only if it sits in an accessible subgraph that lights up together with whatever you're currently doing. Stuff that's saved but disconnected is, functionally, lost.
If connectivity is the substrate, *indexing* is the mechanism. Does state-indexed memory outperform high-level workflow memory for web agents? shows that *how* you key a memory decides whether it fires in the right moment: indexing procedures by the specific environment state and local action consistently beats higher-level workflow abstractions, because those abstractions throw away the click-by-click specifics that tell you 'this situation is the one where that memory applies.' Reachability, on this view, is about matching the granularity of the index to the granularity of the decision. How should agent memory split across time scales? pushes the same intuition further, splitting memory across time scales — dialogue-level versus turn-level — so that different kinds of memory are retrievable under the conditions each is meant for.
There's also a deeper, almost cognitive framing. Can cognition work by reusing memory instead of recomputing? treats thinking itself as *navigation* over a topological memory — reusing prior inference paths rather than recomputing from scratch. Here 'reachable' means: is there a trajectory through the memory structure that leads from your current state back to the useful prior? That inverts the usual storage-and-lookup picture into one where the shape of the memory space is what makes recall possible at all.
What's quietly powerful is the corpus's split on *who* makes a memory reachable. How should agents decide what memories to keep? distinguishes the agent explicitly deciding to recall (hot-path tool calls) from background, programmatically triggered retrieval — two different bets on context-sensitivity versus reliability. And Can governance rules embedded in runtime memory actually protect autonomous agents? offers a vivid real-world case: governance rules only worked when they lived *in the memory layer the agent actually consulted during operation*, not in an external policy document. The lesson generalizes — a memory is reachable not because it exists somewhere, but because it sits on the path the system actually traverses when deciding.
The thing you might not have expected to want to know: reachability and raw context capacity are different problems. Is long-context bottleneck really about memory or compute? finds the long-context bottleneck isn't memory size but the *compute* to consolidate evicted context into fast weights — making a memory reachable later costs work now. So 'reachable in the right context' is less about hoarding more and more about the connectivity, indexing, and consolidation that put the right thing on the path at the right moment.
Sources 7 notes
FluxMem shows that memory usefulness is determined by links between co-activated units forming an accessible subgraph, not by what is stored. Storage is necessary but inert; topology determines whether useful memories are reachable at decision time.
PRAXIS shows that indexing procedures by environment state and local action pairs yields consistent accuracy and reliability gains across VLM backbones on the REAL benchmark, compared to higher-level workflow abstractions that lose click-by-click specifics.
RAISE shows that agent memory consists of four components organized by two design axes: dialogue-level (conversation history, scratchpad) versus turn-level (examples, task trajectory). This granularity distinction predicts different failure modes and update policies for each component.
Memory-Amortized Inference proposes intelligence arises from structured reuse of prior inference paths over topological memory, inverting RL's reward-forward logic into cause-backward reconstruction. This duality explains energy efficiency and suggests memory trajectories form the substrate of adaptive thought.
Memory management decomposes into explicit hot-path (agent decides via tool calling) and implicit background (programmatically triggered) paths. Each approach trades context-sensitivity for reliability differently across generation, storage, retrieval, and deletion.
A persistent agent recorded 889 governance events across 96 active days, with safeguards encoded directly into the memory layer the agent consulted during operation. Runtime-resident governance proved more effective than external policies because the agent actually accessed it during decision-making.
Research shows the bottleneck is not memory capacity but the compute required to consolidate evicted context into fast weights during offline sleep phases. Performance improves with more consolidation passes, following a test-time scaling pattern on harder reasoning tasks.