Comparision
LocusGraph vs Mem0: Your Agent Remembers, Never Learns
The fourth time your agent shipped the same bug
09:14. Your coding agent opens a PR. Off-by-one on an empty result set — the same pagination bug it introduced in March, in May, and again in July. Each time a human caught it in review and explained the fix in the thread.
Your memory layer worked perfectly through all of it. Ask it and it will tell you, correctly, that the user prefers TypeScript, that the repo uses pnpm, and that someone once said "watch the pagination edges."
What it cannot do is stop the fourth PR.
That is not a retrieval failure. The facts were stored and they came back ranked. The failure is that four identical incidents never became one lesson. Nothing in a flat store is built to notice that the same thing happened four times, raise its confidence, and promote it into a rule the agent consults before it writes the loop. Call it the recall ceiling: an agent can have perfect memory and zero accumulated competence, and from the outside those look identical right up until they don't.
Now the credit, because vague criticism is worthless and Mem0's case is strong. 62.8k stars and 7.3k forks on GitHub under a real Apache 2.0 licence, not a source-available lookalike. 150,000+ developers per Mem0's homepage. Three lines to integrate. Twenty-plus framework integrations, a first-party memory tool in AWS's Strands Agents SDK, SOC 2 Type 1, HIPAA and GDPR, and $24M behind it from Basis Set, Peak XV and YC.
The 2026 algorithm is real engineering. Mem0 threw out its own original design — the LLM-mediated ADD/UPDATE/DELETE reconciliation loop from its ECAI paper — and replaced it with single-pass ADD-only extraction: one LLM call, no UPDATE, no DELETE. Retrieval became multi-signal: dense semantic, BM25 keyword, and entity matching scored in parallel. April shipped at LoCoMo 91.6 and LongMemEval 93.4; the current published figures are 92.5 and 94.4, plus BEAM at 64.1 (1M) and 48.6 (10M). They open-sourced the eval harness — "anyone can run, audit, or extend" — which is more than most of this category does. Since then: temporal reasoning, memory decay, expiration dates, reranking, and Dream.
If your job is remembering the user across sessions, apps and models, Mem0 is the best tool that exists for it. But most agents in production have a different job: getting better at a task they perform repeatedly. That is not a memory problem.
Storing a fact is not learning a lesson
Mem0's unit of storage is an extracted fact. Read the conversation, have an LLM pull salient statements, embed them, store them, rank them at query time.
Give them credit for not leaving that raw. Custom instructions let you write project-level rules for what to include and exclude, "acting as smart filters so your AI application only remembers what matters." Custom categories let you define your own labels with descriptions, applied by a classifier at ingestion. Mem0 does not blindly append everything.
The difference is where the structure lives. In Mem0 it is configuration you author in prose and a classifier applies. In LocusGraph it is the shape of the write itself, and it carries a dimension Mem0 has no equivalent for.
Every LocusGraph event has four required parts:
event_kind—fact,action,decision,observation,feedback. A decision is not an observation. A decision has a rationale, and future agents should inherit the reasoning rather than re-derive it.source—agent,user,system,validator,executor. This is the one with no counterpart. A user correction outranks an agent's own guess by default, and avalidatorevent auto-creates aderived_fromlink for traceability. Two events with identical payloads mean different things depending on who produced them.context_id— atype:namescope likeerror:null_pointerorskill:pagination_safety.links— explicit typed edges to other knowledge.
The event then passes an admission pipeline — validation, classification, extraction, locus creation — which is allowed to return filtered, meaning it judged the event not worth admitting.
In one line: Mem0 asks "is this worth remembering?" LocusGraph asks "who said it, how many times, and does it contradict what we already believed?"
Entities are not relationships
This is where Mem0's own documentation does the arguing:
Graph Memory captures which entities your memories are about and how they connect through shared context. It does not assign typed, labeled relationships between entities (it won't, for example, record a "manages" edge from one person to another); connections are inferred from co-occurrence rather than declared. This is what makes it schema-free and zero-configuration.
That last sentence is a fair trade and worth stating plainly: schema-free means zero setup, it runs automatically on every plan including free, and there is nothing to provision. In April 2026 Mem0 removed external graph stores like Neo4j entirely in favour of this built-in version. For a lot of teams that trade is correct.
It also means an edge in Mem0 has no direction and no meaning. Two memories that mention "Postgres" are linked because they both say "Postgres." The link cannot express confirms, contradicts, or was derived from.
LocusGraph's edges are declared, typed, and they change what the system believes:
Link | Effect |
|---|---|
| +0.05 confidence, capped at 1.0 |
| −0.10 confidence, floored at 0.2 |
| Adds detail; the extending node surfaces in retrieval |
| Provenance — this exists because of that |
| Plain association |
When the pagination bug recurs, reinforces fires and confidence climbs. When a fix stops working, contradicts fires and the old belief is demoted, not deleted — retained in the graph, auditable, ranked below the thing that replaced it.
Mem0 is candid about the missing half here too. Their August 2026 post on confidence scores states that Mem0 does not store a queryable numeric confidence field on a memory, then shows how to build one from metadata, custom_instructions and update() calls. You can absolutely do that. But confidence maintained in application code is not confidence the ranker enforces on the write path, and the difference shows up the first time two contradicting memories come back with equal standing.
Consolidation cleans up, graduation levels up
Take Mem0's strongest counterargument seriously, because it is better than most people realise.
Dream is Mem0's consolidation system. Merge: a newer memory subsumes an older one, which is marked merged and points at its replacement. Supersede: a newer fact replaces an older one, which is marked superseded. Both run immediately on every add, on every plan including free. Synthesize: when several independent observations support one summary, Dream writes it — weekly on Pro, daily on Enterprise, off the request path. Per Mem0: "Nothing is deleted in any of these operations. Every change is recorded as a state change with a pointer to the newer memory."
There is also agent_custom_instructions, shipped two weeks ago, which is Mem0 walking straight into this territory. Their own framing: an agent's useful memories are "which tools fail, which retry strategies work, and how a given environment behaves, not personal preferences." We agree with every word of that. It is the thesis of this article.
So be precise about what remains different. Dream is hygiene — fewer duplicates, fewer expired truths, tighter summaries. Mem0 describes synthesis as "deliberately conservative": single observations, one-off events, and repeated questions about a topic do not produce summaries. Consolidation reduces N memories to fewer, better memories. It does not change what kind of thing they are. A merged fact is still a fact.
LocusGraph's Graduation Chain changes the kind: Data → Information → Knowledge → Wisdom, or compressed, event → pattern → skill.
The mechanics are deliberately unmagical and you set the thresholds. Record the failure as an observation in an error: context. When the same error appears a third time, write a fact that reinforces the original — now you have a pattern with rising confidence. After five successful applications of the fix, promote it with extends into skill:pagination_safety, queryable as its own context. The agent stops retrieving four incident reports and inferring a lesson at inference time, and starts retrieving one skill node: pre-validated, high-confidence, with provenance back to every incident behind it.
A note on vocabulary, because it will come up: Mem0 uses "skill" for its installable agent-skill packages — Skill Graph, the Cursor and Claude Code skills. Those are documentation bundles for coding agents. A LocusGraph skill is a graduated knowledge node your agent earned. Same word, different objects.
Mem0 has named the gap themselves. Their State of AI Agent Memory 2026 report lists procedural memory — "learned workflows, coding patterns, tool-use habits, review conventions" — as the third memory type, then concedes: "this is an area where Mem0's architecture supports the concept, but the tooling for managing procedural memory specifically is still early-stage."
It also changes the retrieval bill. Every prompt that replays chat history pays rent on understanding you already bought — rented context. LocusGraph's published figures for its own system: roughly 5x smaller retrievals from tight scoping, and roughly 10x from fetching a graduated skill instead of replaying raw events. As knowledge matures, retrievals get smaller, because a skill is denser than the fifty events behind it. Those are our numbers on our system — hold us to them in the test below.
Where Mem0 wins, who should switch, and how to test it
A clean sweep is marketing, not analysis. Five things Mem0 does better today:
Adoption and ecosystem. 62.8k stars, 150k+ developers, 20+ frameworks, first-party plugins for Claude Code, Cursor, Codex and OpenCode, plus n8n and Zapier. When something breaks at 2am there is a Discord full of people who have hit it. LocusGraph has none of that yet.
Published, reproducible benchmarks. Mem0 posts LoCoMo, LongMemEval and BEAM numbers and open-sourced the harness. LocusGraph has not published comparable third-party evals. That is a real gap and we will not dress it up.
Apache 2.0 and self-hosting.
docker compose upand it is yours, forever, no vendor. If licence risk is a board-level concern that outweighs any architecture argument.Compliance and enterprise proof. SOC 2 Type 1, HIPAA, GDPR, on-prem deployment, named customers. We are earlier on all of it.
Consumer-grade personalization. Cross-app user memory, the Chrome extension, OpenMemory MCP, the "memory passport" thesis. If your product needs to remember the person, Mem0 is aimed directly at that and we are not.
And one that disqualifies us outright: if your agent performs a different task every time — a general assistant, a one-shot support bot, a companion app — there is no repetition for knowledge to graduate from. The Graduation Chain has nothing to chain. Use Mem0. Do not buy an accumulation layer for work that does not accumulate.
Switch if three or more are true: your agent makes the same class of mistake more than once a month; you can name a lesson your team learned that your agent still does not know; multiple agents need to share validated knowledge rather than chat transcripts; you need to answer "why did the agent decide that?" with an audit trail; a fix that stopped working must demote the old belief; you are paying for the same context in every prompt and the bill grows with tenure.
Mem0 | LocusGraph | |
|---|---|---|
Built for | Remembering the user across sessions and apps | Agents getting better at a repeated task |
Unit of storage | Extracted fact | Typed event (kind + source + payload + context + links) |
Write path | Single-pass ADD-only extraction, one LLM call | Admission pipeline: validate → classify → extract → locus (can filter) |
Classification | Custom categories + prose custom instructions you author |
|
Who said it | Not a first-class dimension |
|
Graph | Entity linking, automatic on all plans; "does not assign typed, labeled relationships" | Declared typed edges: reinforces, contradicts, extends, derived_from, related_to |
Confidence | No queryable numeric field; build it on metadata | Native; |
Contradictions | Supersede via Dream, free, on every add | Demoted and retained, auditable, never deleted |
Promotion | Dream synthesis into summaries (conservative; Pro weekly / Enterprise daily) | Graduation Chain: event → pattern → skill, thresholds you set |
Reasoning | Multi-signal retrieval + temporal ranking |
|
Pricing | Hobby free / $19 Starter / $249 Pro / Enterprise custom | Free / $49 Pro / $149 Team / from $1,950 Enterprise |
Licence & hosting | Apache 2.0, self-hostable | Managed; export on Enterprise |
Compliance | SOC 2 Type 1, HIPAA, GDPR | AES-256, TLS 1.3+, signed audit trails |
Benchmarks | LoCoMo 92.5, LongMemEval 94.4, BEAM 64.1/48.6 (open harness) | None published — evaluate it yourself |
Is LocusGraph a Mem0 alternative?
For agent knowledge — recurring errors, decisions with rationale, validated skills — yes. For cross-app personalization of an end user, Mem0 is purpose-built and we are not.
Doesn't Mem0's graph memory already do this?
Mem0 links memories that share entities and boosts ranking accordingly, automatically, on every plan. Its own docs state it "does not assign typed, labeled relationships between entities" and that connections are inferred from co-occurrence rather than declared. That is a deliberate trade for zero configuration, and it means an edge cannot express confirms or contradicts.
Doesn't Dream already handle consolidation?
Yes, and it is good. Merge and supersede run free on every add; synthesis writes summaries weekly on Pro. It makes the fact store cleaner. It does not promote a fact into a reusable skill with its own confidence and provenance — and Mem0's own 2026 report calls their procedural-memory tooling "still early-stage."
Does Mem0 have confidence scores?
Not as a queryable field on a memory — Mem0's August 2026 post says so and shows how to approximate one with metadata. LocusGraph scores confidence natively on the write path: +0.05 per reinforces to a cap of 1.0, −0.10 per contradicts to a floor of 0.2.
How do multiple agents share knowledge?
One graph, role-scoped contexts — agent:planner, agent:coder, agent:reviewer — reading and writing shared contexts like project:api. Agents communicate through validated knowledge instead of injected transcripts.
Can I use both together?
Yes. Mem0 for who the user is; LocusGraph for what the agent has learned. Different layers of the same stack, and LocusGraph is LLM-agnostic, so switching model providers does not cost you your graph.
What does LocusGraph cost, and is my data private?
Free ($0, 1 agent, 1,000 events/month), Pro $49/mo, Team $149/mo, Enterprise from $1,950/mo, with a founding-member rate of $29/mo currently available. You retain full ownership of all memory data; it is never used to train models or shared with third parties. AES-256 at rest, TLS 1.3+ in transit, signed audit trails on every event.
Not just longer-context. Not just better-prompted.