Most agent memory products you will meet (Mem0, Zep, Letta and the rest in Agent memory layers compared) are built as products first. The four here started as papers, and each one bets on a different idea of what memory is:
\nPapers report results on their own benchmarks; the code you can install is a separate question. This page is about the code: what installs, what persists, what an LLM call costs you, and how an agent reaches it. If you just need memory working in an agent this week, start with Give an agent long-term memory instead.
\nOn 2026-10-30 we installed three of the four and ran them offline: the LLM was replaced by a stub that counts calls and returns an empty or neutral answer, and embeddings were a real local model (A-MEM, MemoryOS) or a hashing stand-in (LightRAG). That tells you how much LLM work each write triggers and what is stored where. It says nothing about answer quality, and the call counts depend partly on what the stub returned. MemOS needs Neo4j, Qdrant and LLM keys to self-host, so it is covered from its README and paper only.
\n| Installed | Version run | Result | |
|---|---|---|---|
| A-MEM | from source on Python 3.13 | commit ceffb86 (2025-12-12) | worked; nothing persisted |
| MemoryOS | memoryos-pro 0.1.0 | failed on Python 3.13, worked on 3.10 | worked; JSON files persisted |
| LightRAG | lightrag-hku 1.5.7 on Python 3.13 | 1.5.7 | worked; files persisted; delete worked |
| MemOS | not installed |
The paper (NeurIPS 2025) writes each memory as a structured note and links it to similar notes, Zettelkasten-style. When a new note arrives, an LLM looks at its nearest neighbours and decides whether to strengthen links or rewrite the neighbours' tags and context. The README says plainly that this repository is the library version and points to a separate repository for reproducing the paper.
\nWhat the code does today:
\nadd_note() calls made two LLM calls.AgenticMemorySystem keeps notes in a Python dict and uses an in-memory Chroma client, and its constructor resets that client. A second instance saw 0 notes. Worse, creating the second instance broke the first one in the same process: its next search raised NotFoundError: Collection ... does not exist. The repo has a PersistentChromaRetriever class, but the main class does not use it.pip install agentic-memory installs an unrelated project ("A Graph-Theoretic Memory Kernel", from a different author). Clone the repo and run pip install .. It pulls in sentence-transformers and therefore PyTorch.Use it to study the evolution idea, or fork it and wire in the persistent retriever. Don't put it behind a long-running agent as is.
\nMemoryOS (EMNLP 2025) is built for one assistant talking to one user over a long time. New turns go into short-term memory. When that fills, they are grouped into mid-term topic sessions. Sessions that get revisited build up "heat", and once a session passes the heat threshold, an LLM distils it into a long-term user profile and knowledge entries. Retrieval pulls from all three levels.
\nWhat we saw with short_term_capacity=3:
add_memory() made five or six: a continuity check, a meta-summary, a multi-topic summary and keyword extraction.get_response() made nine LLM calls in our run. That included a profile analysis and knowledge extraction, because the session had just crossed the heat threshold, as well as the answer itself.short_term.json, mid_term.json, long_term_user.json), and a new instance loaded them back.Install friction is the main catch. The PyPI package memoryos-pro 0.1.0 dates from July 2025, pins numpy==1.24.* and faiss-gpu, and failed to build on Python 3.13; it installed on 3.10. Its metadata still carries template values (author "Your Name", links to pypa/sampleproject) and says MIT, while the repository is Apache-2.0. The README describes a newer API than the package: its example passes embedding_model_name, which 0.1.0's Memoryos() does not accept. Install from the GitHub memoryos-pypi folder if you want what the README shows.
For agents, the repo's MemoryOS-MCP server exposes add_memory, retrieve_memory and get_user_profile, and all model calls go through an OpenAI-compatible endpoint, and the README lists vLLM for local models. Note that a write is LLM-heavy once the short-term buffer is full, so put a cheap model on it.
MemOS (arXiv 2507.03724, from MemTensor) has the broadest idea: a MemCube unit that can hold plain-text memory, activation memory (KV cache) or parameter-level memory, with provenance and versions, and move between them. The code you can deploy today is mostly the plain-text part, packaged four ways:
\nmpg- keys, add/message and search/memory endpoints),docker compose up (the MemOS API plus Neo4j and Qdrant) or uvicorn,The plugins recall memories before each agent turn and save the new messages after it, so the agent does not need to call a tool. That is the main practical difference from the other three.
\nIt is the most actively maintained of the four (GitHub release v2.0.34 on 2026-09-23 and commits this week). The README's benchmark table (LoCoMo 88.83, LongMemEval 89.20, and results on OmniMemEval, MemTensor's own evaluation) is the project's claim and was not reproduced here.
\nOne naming trap: MemOS's PyPI package is called MemoryOS (2.0.33). That is not BAI-LAB's MemoryOS above, whose package is memoryos-pro. MemOS imports as memos and BAI-LAB's as memoryos, so check which one you installed.
LightRAG is a retrieval framework rather than a conversation memory. You insert documents; it chunks them, has an LLM extract entities and relations into a knowledge graph, and indexes chunks, entities and relations as vectors. Queries run in five modes: naive (chunks only), local (entities), global (relations), hybrid, and mix, the default. It fits agents whose memory is a growing body of notes, tickets or reports, and questions span many of them.
What we saw on 1.5.7:
\nentity_extract_max_gleaning defaults to 1). Two short documents made four calls.naive query with only_need_context=True returned the right chunk without calling the LLM. After adelete_by_doc_id(), the same query no longer found it, and the deletion made no LLM calls in our run.lightrag-server (the [api] extra or Docker) adds a REST API, an Ollama-compatible chat API and a web UI. It binds to 0.0.0.0 with no authentication by default. Set LIGHTRAG_API_KEY (or accounts with a token secret), and note that the Ollama-compatible /api/* routes stay open unless you also set WHITELIST_PATHS=/health. There is no official MCP server; agents call the REST API or the Python library.
These are the scripts behind the numbers above. They need no API keys. Each replaces the LLM with a stub, so they measure plumbing, not quality.
\nLightRAG (pip install lightrag-hku==1.5.7):
import asyncio, hashlib, os, shutil, numpy as np\nfrom lightrag import LightRAG, QueryParam\nfrom lightrag.utils import EmbeddingFunc\n\nWD = "./lr_probe"; shutil.rmtree(WD, ignore_errors=True)\ncalls = []\n\nasync def stub_llm(prompt, system_prompt=None, history_messages=[], **kw):\n calls.append(prompt[:60]); return "" # extract nothing\n\nasync def hash_embed(texts): # stand-in for a real embedder\n out = []\n for t in texts:\n v = np.zeros(256)\n for w in t.lower().split():\n v[int(hashlib.md5(w.encode()).hexdigest(), 16) % 256] += 1\n out.append(v / (np.linalg.norm(v) or 1))\n return np.array(out)\n\nasync def main():\n rag = LightRAG(working_dir=WD, llm_model_func=stub_llm,\n embedding_func=EmbeddingFunc(embedding_dim=256, func=hash_embed))\n await rag.initialize_storages()\n await rag.ainsert(["Niko prefers window seats on long flights.",\n "The staging database is Postgres 16 on port 5433."], ids=["pref-1", "infra-1"])\n print("LLM calls during insert:", len(calls)) # 4\n print("files:", sorted(os.listdir(WD)))\n q = QueryParam(mode="naive", only_need_context=True, chunk_top_k=1)\n print("found:", "5433" in str(await rag.aquery("staging database port", param=q))) # True\n await rag.adelete_by_doc_id("infra-1")\n print("after delete:", "5433" in str(await rag.aquery("staging database port", param=q))) # False\n await rag.finalize_storages()\n\nasyncio.run(main())A-MEM (clone agiresearch/A-mem, pip install .):
import json, os\nos.environ.setdefault("OPENAI_API_KEY", "sk-offline-stub") # the constructor builds an OpenAI client\nfrom agentic_memory.memory_system import AgenticMemorySystem\n\ncalls = []\ndef stub(prompt, response_format=None, temperature=0.7):\n calls.append(prompt[:80])\n return json.dumps({"should_evolve": False, "actions": [], "suggested_connections": [],\n "tags_to_update": [], "new_context_neighborhood": [], "new_tags_neighborhood": []})\n\nm = AgenticMemorySystem(model_name="all-MiniLM-L6-v2", llm_backend="openai")\nm.llm_controller.llm.get_completion = stub\nfor t in ["Niko prefers window seats on long flights.",\n "The staging database is Postgres 16 on port 5433.",\n "Niko's flight to Berlin leaves on Friday."]:\n m.add_note(t)\nprint("LLM calls:", len(calls)) # 2\nprint(m.search("staging db port", k=1)[0]["content"]) # the Postgres note\nm2 = AgenticMemorySystem(model_name="all-MiniLM-L6-v2", llm_backend="openai")\nprint("second instance sees:", len(m2.memories)) # 0\nm.search("staging db port", k=1) # raises NotFoundErrorMemoryOS (pip install memoryos-pro==0.1.0 on Python 3.10):
import os, shutil\nimport memoryos.utils as u\ncalls = []\ndef stub(self, model, messages, temperature=0.7, max_tokens=2000):\n calls.append(messages[-1]["content"][:60]); return "stub"\nu.OpenAIClient.chat_completion = stub\nfrom memoryos import Memoryos\n\nD = "./mo_probe"; shutil.rmtree(D, ignore_errors=True)\nmk = lambda: Memoryos(user_id="niko", openai_api_key="sk-offline-stub",\n data_storage_path=D, short_term_capacity=3)\nm = mk()\nfor q, a in [("I prefer window seats on long flights.", "Noted."),\n ("Our staging database is Postgres 16 on port 5433.", "Got it."),\n ("My flight to Berlin leaves Friday.", "Have a good trip."),\n ("I'm vegetarian.", "Noted."),\n ("Remind me the staging port later.", "Will do.")]:\n m.add_memory(user_input=q, agent_response=a)\n print("LLM calls so far:", len(calls)) # 0, 0, 6, 11, 16\nn = len(calls); m.get_response(query="Which port is staging on?")\nprint("get_response calls:", len(calls) - n) # 9\nprint(sorted(os.path.relpath(os.path.join(r, f), D) for r, _, fs in os.walk(D) for f in fs))\nprint("reloaded short-term items:", len(mk().short_term_memory.get_all())) # 2