What makes memory trajectories topologically stable under persistent reuse?
This explores how memory can be reused over and over without degrading — what keeps the 'paths' a system retraces stable, instead of collapsing or drifting, the more they get used.
This explores how memory can be reused over and over without degrading — what keeps the paths a system retraces stable, instead of collapsing or drifting, the more they get used. The phrase 'topologically stable' is academic, but the underlying question is concrete and the corpus has surprisingly varied takes on it. The most direct framing comes from Memory-Amortized Inference, which argues that intelligence works by reusing prior inference paths over a structured memory rather than recomputing from scratch — and that the shape of that memory (its topology) is what lets the same trajectory be replayed cheaply and reliably Can cognition work by reusing memory instead of recomputing?. Stability there isn't a property you add; it falls out of treating memory as a constrained space you navigate, where reuse reinforces the same routes.
But the corpus suggests stability under reuse comes from structure that resists two opposite failure modes: collapse (everything compresses into mush) and drift (each update quietly corrupts the last). The clearest answers are architectural. VOYAGER keeps skills as discrete, externally stored, composable units — so reusing and building on old skills doesn't overwrite them, sidestepping the catastrophic forgetting that weight-update methods suffer Can agents learn new skills without forgetting old ones?. SoftCoT makes the same bet from the other direction: freeze the backbone entirely and delegate new reasoning to a small helper, so the stable core is never touched Can continuous reasoning avoid forgetting in instruction-tuned models?. The shared lesson — what stays stable under reuse is whatever you protect from in-place overwriting.
The consolidation papers add a quieter mechanism: stability isn't free, it's paid for in compute. One argument reframes the long-context bottleneck as the work required to fold evicted context into fast weights during offline 'sleep' passes — more consolidation passes, more durable the memory Is long-context bottleneck really about memory or compute?. DeepAgent's memory folding and the ACE framework both show the flip side: consolidation done carelessly destroys what it's meant to preserve. ACE specifically warns against full rewrites, using incremental generation-reflection-curation loops to avoid 'brevity bias' and detail erosion — the slow death of a memory that gets re-summarized one too many times Can agents compress their own memory without losing critical details? Can context playbooks prevent knowledge loss during iteration?.
The genuinely surprising thread is that some systems achieve stability by carrying almost no history at all. Atom of Thoughts uses Markov-style contraction where each reasoning state depends only on the current problem, not the accumulated past — so there's no trajectory to corrupt because nothing accumulates Can reasoning systems forget history without losing coherence?. That's the opposite philosophy to memory-amortized reuse, and the tension between them is the real payoff here: is durable reuse about reinforcing the same path, or about making each step so self-contained that drift has nothing to grab onto? RAISE's finding that memory should be split across components and time scales hints the answer is 'different layers want different policies' — fast scratch memory wants to forget, slow skill memory wants to persist How should agent memory split across time scales?.
If you want to go deeper, ComoRAG is worth a look as the case where stability is actively defended: a persistent memory workspace that detects and resolves its own contradictions across retrieval cycles, rather than letting them compound Can reasoning systems maintain memory across retrieval cycles?. Read together, the corpus says topological stability under reuse isn't one trick — it's the result of separating what must persist from what must decay, and paying compute to consolidate the boundary between them.
Sources 9 notes
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.
VOYAGER demonstrates that storing executable skills in an embedding-indexed library and composing complex skills from simpler ones allows agents to learn continuously while avoiding the forgetting that occurs with weight-update-based methods. Environmental feedback refines skills while an automatic curriculum drives continual exploration.
SoftCoT avoids catastrophic forgetting by keeping the main LLM frozen while delegating soft thought generation to a small auxiliary model. This architectural separation maintains pre-trained knowledge while enabling continuous reasoning.
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.
DeepAgent's autonomous memory folding consolidates interaction history into episodic, working, and tool memory schemas. This reduces token overhead while letting agents pause to reconsider strategies—the autonomy and structure together avoid degradation that plagues poorly designed consolidation.
The ACE framework treats contexts as evolving playbooks using generation-reflection-curation loops rather than full rewrites. This prevents knowledge loss from compression and detail erosion, achieving +10.6% on agentic tasks and +8.6% on finance without labeled supervision.
Atom of Thoughts decomposes problems into DAGs and contracts them iteratively, ensuring each state depends only on the current problem—not prior steps. This memoryless approach eliminates historical baggage that bloats reasoning while maintaining answer equivalence.
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.
ComoRAG demonstrates that iterative evidence acquisition with a persistent memory workspace outperforms stateless multi-step retrieval by detecting and resolving contradictions through deeper exploration, achieving up to 11% gains on complex queries.