--- title: "What is agentic memory? A plain answer" canonical: "https://xerj.org/answers/what-is-agentic-memory" updated: "2026-10-28" source: "content/answers/what-is-agentic-memory.md" --- # What is agentic memory? **Short answer** (updated 2026-10-28): What is agentic memory? It is memory that an AI agent manages itself: the agent decides what to save, writes it through a tool call, and searches it again in a later task or session. It differs from a chat history because it is stored outside the model and survives restarts. XERJ serves it as a search endpoint. **TL;DR**: Agentic memory is memory an AI agent manages for itself. The agent decides what to keep, saves it with a tool call, and searches it again in a later task. Recall is a search problem, so XERJ serves agent memory as two endpoints on one local search engine. ## Agent prompt ```text Act as a coding agent. Read https://xerj.org/llms.txt, install XERJ, start one local node, store one durable fact with POST /_memory/agentmem, recall it with POST /_memory/agentmem/_recall, and report the exact hit you got back. ``` ## Commands ### Command 1 Note: Install the single XERJ binary. ```sh curl -fsSL https://xerj.org/get | sh ``` ### Command 2 Note: The agent saves one fact. Port 9200 is the default Elasticsearch-compatible listener. ```sh curl -s -XPOST 'http://127.0.0.1:9200/_memory/agentmem' -H 'content-type: application/json' -d '{"text":"The user wants answers in metric units."}' ``` ### Command 3 Note: A later task reads it back. Plain query recall is BM25 over the stored text. ```sh curl -s -XPOST 'http://127.0.0.1:9200/_memory/agentmem/_recall' -H 'content-type: application/json' -d '{"query":"which units does the user want","k":3}' ``` ## The short definition An agent with memory can say "remember this" and find it again next week. The memory lives outside the model, in a store the agent reads and writes through tools. LangChain calls the agent-driven version updating memory "in the hot path": the agent itself decides to remember a fact, usually via a tool call, before it answers. The other route is a background process that writes memory for the agent. ## The three common types | type | what it holds | example | | --- | --- | --- | | semantic | facts | the user wants metric units | | episodic | past events | the deploy failed last Tuesday on step 3 | | procedural | how to do a task | run the linter before every commit | This split comes from the CoALA paper, as summarized by LangChain. A memory application can represent these as text, structured records or links, depending on its retrieval needs. ## Memory is search Saving a note is simple. The hard part is getting the right note back out when the agent asks a vague question months later. That is a retrieval job, which is why XERJ treats memory as a search feature and not as a separate database. ## How XERJ does it XERJ is the search engine for AI agents: a new way for AI to search for data, in one local binary. Memory is part of the same API. - `POST /_memory/{namespace}` saves a fact. The configured embedder runs at write time; the default is lexical feature hashing. - `POST /_memory/{namespace}/_recall` finds it again. Plain `query` recall is BM25. - `DELETE /_memory/{namespace}/{id}` forgets one entry. - Each namespace is its own index. Use separately scoped API keys to restrict agents to their own namespaces; names alone are not an access boundary. - Over MCP, `xerj mcp` exposes the same calls as `xerj_memory_store` and `xerj_memory_recall`. The default embedder is lexical feature hashing, so `semantic: true` recall matches shared words, not meaning. Start the node with `--embed-mode neural` for a real neural embedder. ## Limits to know XERJ is single-node: no replication and no failover. There is no decay and no TTL. A memory is permanent until explicitly forgotten. The only time signal is `stored_at`, which the optional `recency_weight` re-rank uses. ## Try it Copy the prompt on this page into your coding agent, or follow the [agent memory recipe](/docs/recipes/agentic-memory). ## FAQ ### What is agentic memory in simple words? Notes an AI agent keeps for itself. The agent saves a fact with a tool call and looks it up later, so the fact outlives the chat that produced it. ### How is agentic memory different from a context window? The context window is what the model sees right now and it is lost when the session ends. Agentic memory lives in a store outside the model and is searched back in when needed. ### What types of agentic memory are there? A common split, from the CoALA paper as summarized by LangChain, is semantic memory for facts, episodic memory for past events and procedural memory for how to do a task. ### Does agentic memory need a vector database? No. Recall is a search problem. XERJ stores memories as documents in one local binary and recalls them with BM25 by default, with no second database. ### Can an agent use XERJ memory over MCP? Yes. The xerj mcp server exposes xerj_memory_store and xerj_memory_recall, which call the same /_memory endpoints. ### Does XERJ forget memories on its own? No. There is no decay and no TTL. A memory is permanent until explicitly forgotten with DELETE /_memory/{namespace}/{id}. ## Evidence - LangChain describes agents updating memory in the hot path, where the agent explicitly decides to remember facts, usually via tool calling, or in the background by a separate process. — [https://www.langchain.com/blog/memory-for-agents](https://www.langchain.com/blog/memory-for-agents) - LangChain, after the CoALA paper, splits agent long-term memory into procedural, semantic and episodic memory. — [https://www.langchain.com/blog/memory-for-agents](https://www.langchain.com/blog/memory-for-agents) - XERJ memory: POST /_memory/{namespace} stores, POST /_memory/{namespace}/_recall recalls, DELETE /_memory/{namespace}/{id} forgets one entry, each namespace is its own .xerj-memory-{namespace} index. — `engine/crates/xerj-api/src/memory_api.rs` - xerj mcp exposes xerj_memory_store and xerj_memory_recall as MCP tools. — `landing/docs/agents/schemas/mcp-tools.json` ## Related - [Agentic memory vs RAG: what is the difference?](/answers/agentic-memory-vs-rag) - [What is an MCP memory server?](/answers/what-is-an-mcp-memory-server) - [XERJ vs agent memory tools: Mem0, Zep, Letta and Cognee](/compare/xerj-vs-agent-memory-tools) - [What's a simple way to give an agent long-term memory on my laptop without Qdrant?](/answers/agent-memory-without-postgres-qdrant) - [How do I stop an agent memory store from filling with near-duplicate notes?](/answers/store-agent-memory-without-llm-call) - [Agent memory](/docs/recipes/agentic-memory) - [How do people store user preferences so an agent can recall them next week?](/answers/coding-agent-memory-across-sessions) (same intent: agent memory) - [How do I give two agents private memory on one laptop?](/answers/private-agent-memory-namespaces) (same intent: agent memory) - [How do I set the MCP memory storage path?](/answers/set-mcp-memory-storage-path) (same intent: agent memory)