AIの共有メモリはなぜ腐るのか — Veripsaが『保存』ではなく『再導出』を選ぶ理由Veripsa explains why storing shared AI memory leads to stale, unreliable…

As AI copilots move from single-session assistants to persistent collaborators that work alongside teams over days or weeks, the question of how they remember becomes central to whether they can be trusted. In a recent write-up, Veripsa argues that the conventional approach of simply storing shared memory is flawed, and it explains why its system re-derives memory on demand rather than persisting it as a fixed record.

The core problem Veripsa describes is memory staleness. When a copilot saves a summary, a conclusion, or a piece of shared context to durable storage, that stored artifact reflects the state of the world at the moment it was written. As the underlying project changes — code is refactored, decisions are reversed, documents are edited — the saved memory does not automatically update. Over time, the gap between what the copilot "remembers" and what is actually true widens. Because the model treats stored memory as authoritative, it can reason confidently from premises that are no longer valid, producing plausible but incorrect conclusions. In a collaborative setting, where multiple people and agents share the same memory pool, these errors can propagate and compound.

Veripsa's proposed alternative is re-derivation. Instead of trusting a cached summary, the copilot reconstructs the relevant context from primary sources each time it is needed. The memory, in this framing, is not a stored value but a computation that runs against the current state of the ground truth. If the underlying facts have changed, the re-derived memory reflects those changes automatically, which is intended to keep the copilot's reasoning aligned with reality. The company frames this as a trade of upfront storage convenience for ongoing correctness, prioritizing trustworthiness in scenarios where stale context is more dangerous than slower responses.

This design sits within a broader industry conversation about how AI systems should handle state. Many current products lean on retrieval-augmented generation, or RAG, where relevant documents are fetched from a vector database and injected into the prompt at query time. RAG already embodies a version of the re-derivation idea, since it pulls context on demand rather than baking it into the model. However, RAG pipelines often store intermediate summaries, embeddings, or extracted facts that can themselves drift out of date, so the same staleness problem can reappear one layer down. Veripsa's argument appears to push the principle further, treating derived conclusions as things that should be recomputed rather than persisted.

The distinction matters because persistent memory has become a prominent feature across major assistants. Products from several large vendors now offer long-term memory that carries user preferences and facts across conversations, and agent frameworks increasingly maintain scratchpads, task histories, and shared state between multiple cooperating agents. These features improve continuity and personalization, but they also raise the risk that an agent acts on an outdated belief. The tension Veripsa highlights is a real engineering trade-off: stored memory is fast and cheap to read but can silently decay, while re-derived memory is more likely to be current but costs more computation and depends on reliable access to authoritative sources.

Re-derivation is not without its own challenges, and the approach is likely to work best when the primary sources are well defined and cheaply queryable. Reconstructing context on every request can increase latency and token consumption, and it assumes there is always a canonical source of truth to derive from. For subjective or historical information that has no live source — such as why a decision was originally made — pure re-derivation may be insufficient, and some hybrid of caching with validation could be necessary. The details of how Veripsa bounds these costs, and how it decides what to recompute versus what to trust, would determine how well the idea holds up in practice.

Still, the underlying observation is a useful contribution to how teams think about copilot reliability. Framing memory as something to be earned freshly rather than assumed from a cache reframes accuracy as a property of the system's process rather than its storage. As shared, multi-agent workflows become more common, approaches that treat context as a live derivation rather than a static record appear increasingly relevant, and Veripsa's write-up offers one concrete articulation of why that shift may be worth the added cost.