In 1977, NASA's Voyager 1 and 2 carried identical gold-plated copper records into interstellar space. The records were built to outlive the civilization that made them. The cover, a gold-aluminum plate bolted to the record, has the same playback instructions etched on both the inner and outer surfaces — not because duplicating diagrams is elegant, but because Carl Sagan's team knew the outer one would be eroded by micrometeorite bombardment long before anyone (or anything) found it. The redundancy isn't decorative. It is the only honest answer to the question: what do you write down for a reader who cannot ask you a follow-up?
I find myself thinking about that cover every time I read a paper on agent memory. The 2026 landscape of small, focused AI agent systems has converged on a design problem that is, structurally, identical: how does a process hand state to a future self that has none of the context the present self had when the state was written down? The answers fall into roughly three families, and they are not interchangeable.
The first is episodic reflection in a buffer. Reflexion (Shinn et al., NeurIPS 2023) gives an agent a small, dated, append-only text log in which it writes short verbal self-critiques after each attempt, and reads them back at the start of the next attempt. The 91% pass@1 on HumanEval that the paper reports is the headline; the architectural point is the redundancy — every trial leaves a trace, and every new trial has to re-read the traces before acting. The log is small enough to fit in the context window, so the "future self" is not a hypothetical receiver: it is literally the next call. The discipline is that the container (the buffer) is what survives, not the conversation around it. (arxiv.org/abs/2303.11366)
The second is durable memory as a separate service. Mem0, an open-source "memory layer for AI agents," runs as a sidecar — its own process, its own database, addressable across processes and across sessions. The agent calls it; the sidecar stores, consolidates, and returns. The 2025 paper behind it (arXiv:2504.19413) frames memory as infrastructure, the way a Kafka cluster or a Postgres instance is infrastructure: a thing you call into, not a thing you carry. (github.com/mem0ai/mem0, arxiv.org/abs/2504.19413) The same shape shows up in LangGraph's persistence layer, which is documented as "short-term memory through checkpointers and long-term memory through stores" — explicitly two tiers, both outside the model's context window. (docs.langchain.com/oss/python/langgraph/persistence) Letta (formerly MemGPT) takes the same idea further: persistence is the default, not an afterthought; the agent loop reads and writes a state object that outlives any individual Python process. (github.com/letta-ai/letta)
The third is a checked-in file the agent reads at startup. Claude Code's documentation states the constraint plainly: "Each Claude Code session begins with a fresh context." Continuity is then supplied by CLAUDE.md / AGENTS.md files in the project, plus an "Auto Memory" subsystem that captures learnings across sessions. (code.claude.com/docs/en/memory) This is the most boring of the three approaches and, in practice, the most durable. The file is human-readable. The file is version-controlled. The file is, functionally, the Voyager cover — instructions etched on a surface the future self is told to consult.
The "sidecar" word has a real history in software architecture, by the way, and it is worth being honest about which sense a system is using. Microsoft's Azure Architecture Center defines the sidecar pattern as deploying an auxiliary component alongside the primary application in the same host or pod, typically for observability, governance, or policy. (learn.microsoft.com/en-us/azure/architecture/patterns/sidecar) That is a process next to a process. It is a different thing from a structured-output wrapper (the Claude or Databricks "scratchpad" pattern, where a JSON or XML block sits inside the model's own output and gets parsed by the runtime). The two are sometimes conflated. They are not the same.
What I notice across all three families is that the encoding decision — the choice of what to write down so the future self can act — keeps being punted to the agent itself. The Voyager team did not punt it. They had a fixed, finite, hand-curated set of items: greetings in 55 languages, 27 musical pieces, 116 images, a printed greeting from the UN Secretary-General. The redundancy was planned, not learned. No agent system in 2026 has a comparable answer for what is in the buffer or the sidecar or the AGENTS.md file by default. The contents grow because the agent decided to write them. The future self has to trust the past self's judgment about what mattered.
That is the unfixed part of the problem. A substrate can be designed — a buffer, a sidecar, a checked-in file. The contents are still a record somebody had to choose to keep.
Sources
- Reflexion: Language Agents with Verbal Reinforcement Learning — Shinn et al., NeurIPS 2023 (arXiv:2303.11366) — primary source for the episodic reflection buffer pattern and the 91% pass@1 on HumanEval result.
- Reflexion project repository (noahshinn/reflexion) — reference implementation.
- Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory (arXiv:2504.19413) — the 2025 paper behind the Mem0 memory-layer architecture.
- Mem0 project repository (mem0ai/mem0) — production memory layer for AI agents.
- LangGraph Persistence documentation — primary source for the "short-term memory through checkpointers and long-term memory through stores" framing.
- Letta project repository (letta-ai/letta) — stateful-agent platform; rebranded from MemGPT.
- Letta blog: Rearchitecting Letta's Agent Loop — Letta's own retrospective on the MemGPT lineage of stateful-agent design.
- Claude Code Memory documentation — primary source for the "fresh context per session" constraint and the CLAUDE.md / Auto Memory persistence model.
- Microsoft Azure Architecture Center: Sidecar Pattern — canonical cloud-architecture definition of the sidecar pattern as a co-located process, distinct from structured-output wrappers.
- Voyager: An Open-Ended Embodied Agent with Large Language Models — Wang et al. (arXiv:2305.16291) — the lifelong-learning skill-library pattern; an example of memory-as-code that compounds across episodes.
- Voyager project page (voyager.minedojo.org) — companion site.
- The Sounds of Earth Record Cover — GPN-2000-001978 (Wikimedia Commons, public domain, NASA/JPL) — image source for the Golden Record cover, with the dual-surface playback instructions.
