Short-term memory: the context window and the session
Anthropic’s documentation calls the context window the model’s “working memory”: all the text the model can see when it writes an answer. That includes your instructions, the conversation so far, files the agent opened and the results of its tool calls. According to that documentation, current Claude models such as Opus 5.5 and Sonnet 5.5 have a window of 1 million tokens, older ones 200,000 (as of November 2026).
Two limits apply. First, the window is not a perfect memory: the more tokens are in it, the lower the accuracy and recall, which Anthropic calls context rot. Second, it is rebuilt on every call. Frameworks such as LangChain treat short-term memory as the state of one conversation thread, which can be saved in checkpoints and loaded again. What is not saved or reloaded, or what a chat interface drops to make room, the model no longer sees. Everything else on this page exists to work around those two limits.
Long-term memory by content: events, facts, procedures
The common split comes from cognitive science and says what is stored. LangChain’s documentation uses the same three kinds:
- Episodic memory: what happened. “Last Tuesday the client asked for the quote in two parts.”
- Semantic memory: facts that keep holding. “This client wants updates by email, not by phone.”
- Procedural memory: how to do something. “A quote opens with the summary and names the price after that.”
For a team, procedural memory is the most valuable and the easiest to lose: it lives in corrections someone gives once.
Long-term memory by storage form: four ways
Long-term memory lives outside the model. The model reads it back into the context window when it needs it. Each of the three content kinds above can sit in any of these forms; they differ in who decides what goes in.
| Storage form | What is stored | Who writes it | Examples |
|---|---|---|---|
| Instruction files | Rules, conventions, project facts in plain text | People, sometimes the agent | CLAUDE.md in Claude Code, project instructions |
| Agent-written notes | Files the agent creates and updates itself | The agent | Claude API memory tool (a /memories directory), Claude Code auto memory |
| Retrieval over documents (RAG) | An index of existing documents, searched per question | An indexing pipeline | A vector store over your docs or wiki |
| Managed memory service | Extracted facts, entities and relations, often as a graph | The memory service, based on conversations | Mem0, Zep, Supermemory, Letta |
Two details from the documentation show how different these are:
- Claude API memory tool. Claude creates, reads, edits and deletes files in a /memories directory. It is client-side: Claude asks for the file operation, your application performs it and decides where the data lives.
- Zep. Stores facts as relations between entities in a Context Graph. Through its Context MCP server and plugin, Claude, ChatGPT, Claude Code, Codex and Cursor can use the same graph, and administrators decide which user can reach which shared graph.
How the memory services differ in price and approach is in Mem0 vs Zep vs Supermemory vs Letta.
The type people overlook: scope
Most explanations stop at “short-term versus long-term”. For a team, the more important question is whose memory it is.
- Per user. Claude’s chat memory belongs to one person’s account.
- Per project. Each Claude project has its own memory, separate from other projects.
- Per repository. Claude Code’s auto memory is stored per repository and shared across worktrees on that machine.
- Per agent or per application. A memory service scopes by user, agent or run; you decide in code.
- Shared. A memory service can also be shared between people and tools, such as Zep’s shared graphs over MCP. You have to set that up yourself: the built-in memory of the chat tools shares nothing with each other.
The common misunderstanding
Many people think an agent with memory is learning. It is not, at least not in the sense of the model changing. The weights stay the same. What changes is what gets loaded into the window next time. That is good news: memory you control is memory you can read, correct and delete. It also means memory is only as good as what is written down and how well the right piece is found again.
What this means for a team
Without a shared layer, each tool your team uses keeps its own memory with its own scope. What Claude learned from your colleague does not reach your Cursor session. What your ChatGPT knows about a client does not reach your coworker’s Claude. Switching tools means starting over, and when someone leaves, the context they built in their personal account leaves too. For the fuller picture, see How can a team share one AI memory? and Is RAG the same as AI memory?.
Where Bombos fits
Bombos is the long-term memory layer with team scope across tools. It is a plugin that gives Claude, Claude Code, ChatGPT, Copilot, Grok, Codex, Cursor and your own agents one shared memory: team knowledge, rules the team has learned, and what already exists in mail, documents and repositories. It combines retrieval and a context graph, shows what each answer is based on, and runs in our cloud or on your own server. One person can try it first for their own agents.
Related questions
Does the model itself learn from my conversations?
No. The model's weights do not change while you work with it. Everything an agent remembers between sessions is stored outside the model and loaded back into the context window when it is relevant.
Do episodic, semantic and procedural memory come from AI research?
No, they are terms from cognitive science for memory of events, of facts and of how to do things. Agent frameworks such as LangChain use them to decide what to store; how it is stored differs per product.
Is a bigger context window the same as better memory?
No. Anthropic's documentation notes that accuracy and recall drop as the number of tokens grows, which it calls context rot. A large window holds more, but what is not saved is not there in the next session.
Which type should a team start with?
Written instructions that everyone's tools load, such as a shared CLAUDE.md for a code base, are the cheapest start. Once knowledge lives in many tools and people, you need a long-term store with a shared scope.
