The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →An agent’s memory can preserve useful preferences and lessons, but it should not quietly become the authority for facts an entire team relies on. Put reviewed, stable guidance in maintained documentation; use scoped memory to carry continuity between runs. The practical goal is not to eliminate memory, but to make sure an agent can find current, trustworthy information and people can inspect where it came from.
What “context,” “memory,” and “documentation” mean
These terms are related, but they describe different roles. Here, current context means the prompt, available conversation history, task files, and observations the agent can use now. It is a working definition, not a term the sources use uniformly.
As an Amazon Associate I earn from qualifying purchases.
- Session memory is conversation history retained across turns or runs within a particular session implementation. The OpenAI Agents SDK documentation treats session history separately from sandbox memory.
- Persistent agent memory is information retained for future runs, often in files or a service-backed store. It may include summaries, preferences, or lessons from prior work.
- Documentation is maintained material—such as decisions, commands, conventions, or procedures—that people can review and agents can consult. Microsoft’s VS Code guidance recommends source-controlled documents or custom instructions for stable shared guidance.
- Procedural instructions explain how to do a particular kind of task. They can be stored as reusable skills and loaded when relevant, rather than treated as general facts or loaded into every task.
As the OpenAI cookbook puts it: “The main design choice is separation of responsibility: context helps the agent work, memory helps future agents work better, and reviewed artifacts hold the facts that people will rely on.”
Where should each kind of information live?
Ask who needs the information, how stable it is, and whether someone must be able to review or audit it. If contributors should rely on it as a team rule, put it in a maintained, reviewable source. If it helps an agent personalize or continue work across runs, scoped memory may be a better fit.
| Approach | Best suited to | Trade-offs to consider |
|---|---|---|
| Source-controlled documentation and custom instructions | Team-reviewed architecture decisions, commands, conventions, workflows, and task instructions | Supports review and version history, but needs an understandable structure and ongoing maintenance. VS Code guidance describes this role. |
| File-based or sandbox memory | Useful lessons, preferences, summaries, and details from prior runs | Can be flexible and inspectable, but needs retrieval, stale-information handling, access controls, and a persistence plan. OpenAI’s Agents SDK describes sandbox memory and its sandbox guide covers memory artifacts. |
| Hosted memory store | Persistent text files or profiles attached to sessions or recalled across executions | Convenience comes with questions about permissions, isolation, persistence, data handling, and the provider’s lifecycle. Anthropic and Cloudflare document examples. |
| On-demand skills or procedural files | Reusable methods for a specific task that do not need to be loaded at startup | Can keep the active prompt lean, but depends on clear descriptions and reliable retrieval. LangChain’s Deep Agents documentation describes skills as procedural memory. |
These are different patterns, not a single standardized product category. The sources describe approaches and use cases; they do not establish a controlled overall winner.
Why documentation should own shared, durable facts
A memory can be useful and still be wrong, incomplete, or out of date. If a remembered command or architecture decision conflicts with the current project, a contributor needs a dependable place to check which version is authoritative. Reviewed documentation makes the intended rule visible, maintainable, and available to people as well as agents.
Use the repository or another maintained documentation location for guidance the team expects to stay valid until it is deliberately changed. Apply the normal review process to updates. Before promoting something found in memory into a team rule, verify it against the current code and configuration. VS Code’s guidance specifically distinguishes stable shared project guidance from information suited to memory.
How agents can find documentation without loading everything
Documentation is not useful if the agent cannot locate the relevant part. Yet pasting a whole knowledge base into every prompt can waste context and make the useful details harder to distinguish. Many systems address this with summaries, indexes, manifests, and on-demand file reads: the agent starts with a map, then retrieves the material needed for the task.
- Keep stable guidance in clearly named files. Group project rules, workflows, and decisions so people and agents can identify the likely source.
- Provide a short index or manifest. Explain what each file covers and when it should be read. OpenAI’s sandbox guide describes summaries and indexes as ways to navigate memory artifacts.
- Load task-specific detail on demand. Use a skill or procedural file for a particular workflow instead of inserting every procedure at startup. LangChain’s documentation describes on-demand skill loading.
- Keep a path back to evidence. Generated summaries should point to stable source identifiers or the underlying files so an agent or reviewer can verify them. OpenAI’s Agents SDK documentation describes summaries, indexes, and rollout summaries.
A 2026 paper, “Filesystem-Based Memory for LLM Agents: Organization, Evolution, and Sustainability,” reports in its abstract that organized stores roughly halved retrieval cost in its experiments. That is a result for the paper’s evaluated workloads and setup, not a universal performance guarantee.
Memory needs a lifecycle, not just a place to write
A persistent store raises questions that ordinary session context may not: what survives, for whom, and for how long? Persistence is also implementation-dependent. The OpenAI Agents SDK documentation explains that memory artifacts need to be preserved across runs through a live session, resumed state or snapshot, or mounted persistent storage; a fresh empty sandbox does not contain the old memory.
- Set scope: distinguish personal preferences, project-specific facts, and information that should be available across a team. Avoid letting one user’s memory become another user’s assumed context.
- Set permissions: decide whether the agent can read, edit, or delete each store. For reference material that should not change, read-only access may be appropriate.
- Plan for staleness: review remembered claims against current files and configuration before relying on them. Update or remove conflicting copies instead of allowing two competing authorities to persist.
- Make persistence explicit: decide what survives a reset, session boundary, or change of workspace, and how obsolete information is retired.
- Keep provenance: generated notes and summaries should be treated as guidance to verify, not proof. Preserve identifiers or links to the underlying evidence.
Write access deserves particular care. Anthropic’s memory guidance warns that a successful prompt injection into a writable store could leave malicious content for later sessions. This makes store isolation and write permissions part of the design, not an afterthought.
What the principle does—and does not—claim
“Agents don’t need memory, they need documentation” is useful as a warning against treating an opaque or unreviewed memory as the source of truth. It is not a literal argument for removing memory. Official documentation describes legitimate roles for persistent memory, including carrying lessons and context between runs, while recommending reviewed documentation for stable shared guidance. The right choice is about authority and workflow: documents own facts people rely on; memory helps agents maintain continuity.
Quick Recap
Best Value
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
