Comparision
LocusGraph vs Supermemory: Recall Is Not Understanding
What Supermemory Gets Right
Supermemory is fast. It publishes sub-300ms recall latency and sub-400ms in production at 100B+ tokens a month (supermemory.ai, latency budgets). On LongMemEval it reports 95% Recall@15 while adding roughly 720 tokens to the prompt — a 99.4% context reduction. On LoCoMo it publishes P@1 of 59.7% against Mem0's 34.4%. Its SMFS filesystem reports 3.0× fewer tokens on Claude across 110 questions (research).
More importantly, they open-sourced the yardstick. MemoryBench is an MIT-licensed harness running "the same benchmark questions, the same pipeline, and the same judges" against Supermemory, Mem0 and Zep (MemoryBench). In a category where everyone self-reports and then argues about methodology, that is the honest move. We have not matched it.
The memory model is not naive either. Their graph handles temporal truth with an isLatest flag, supports three relationship types — updates, extends, derives — and forgets automatically along three axes: time-based expiry, contradiction supersession, and noise filtering (Graph Memory docs).
Five places Supermemory beats LocusGraph outright, stated plainly because a clean sweep is marketing:
Time to first value. A base-URL swap through the Memory Router versus designing a context schema. They win this before lunch.
Ingestion. Notion, Drive, Gmail, OneDrive, GitHub, S3, Granola and web crawl, plus PDF, image, audio and video extraction. LocusGraph has none of it. If your knowledge lives in documents rather than agent behaviour, this alone decides it.
Published latency. They publish a number. LocusGraph publishes nothing. If recall sits in your product's critical path, that silence should worry you.
Proof at scale. 100B+ tokens monthly, ~29K GitHub stars, a public logo wall including Google and Nissan — versus a pre-launch product with almost no third-party coverage.
Surface area. Company Brain in Slack, a consumer app, SMFS, coding-agent plugins that went free in July. LocusGraph is a developer API.
The Recall Ceiling
Every memory system hits the same wall, and it isn't a storage wall.
Your support agent has answered the same billing question 340 times. Ask it what the right answer is — the one your senior rep worked out in March, the one that stopped the refund escalations — and it hands you the most semantically similar transcript. Not the resolution. The transcript.
Give an agent perfect recall and it doesn't get better at its job. It gets better at finding things. Session 200 retrieves faster than session 2, but it retrieves the same class of object: a fact someone once said. An agent that watched your team debug the same race condition eleven times knows eleven incidents. It does not know the fix.
Call this the recall ceiling. Below it, memory adds value — the agent stops asking what stack you use. Above it, memory adds volume. A preference stated once and a preference confirmed forty times both come back as "a memory." A guess your agent made at 2am and a correction your staff engineer typed by hand both come back as "a memory."
Supermemory's own LongMemEval breakdown shows the shape of it: 100% and 97% recall on assistant state and user facts, 99% on knowledge updates — but 91% on temporal reasoning and 90% on preference (research). Retrieval is close to solved. The categories requiring judgment about which remembered thing should govern behaviour are the ones that lag. That is not a defect. It's the ceiling.
Who Holds the Pen
The most important sentence in this comparison is from Supermemory's own documentation:
"You do not hand-maintain the graph." — Supermemory, Graph Memory docs
Stated as a feature, and for most buyers it is one. Your workflow is three steps: ingest under a container tag, wait for the pipeline, search or load a profile. No schema to design, no ontology meeting, no taxonomy that rots.
The cost is that you cannot express structure the pipeline doesn't already model. Three edge types, fixed. You can read the edges — Search takes include.relatedMemories, the Memories API returns typed memoryRelations, and there's an MCP tool plus a React visualiser. What there isn't is a query language or traversal endpoint: no multi-hop question, no custom relationship, no way to say this source outranks that source. When Dynamic Dreaming reweights your memories, the docs describe no mechanism to review, reject or replay the decision.
LocusGraph inverts every one of those defaults. Every event carries an event_kind (fact, action, decision, observation, feedback) and a source (agent, user, system, validator, executor), and the source changes what the event means. Two events with identical payloads are not the same event: a decision your agent made and the same decision after a human corrected it are stored and retrieved differently, because user carries the highest trust weight.
Links are explicit and arithmetic. reinforces adds +0.05 confidence per link, capped at 1.0. contradicts subtracts 0.10, floored at 0.2. extends, derived_from and related_to carry structure without moving the score. You choose which links to write, so you can read the score back and know exactly why knowledge ranks where it does.
The strongest counterargument, taken seriously. Supermemory is not a black box, and anyone claiming otherwise hasn't read the changelog. Review Inferred Memories lets you approve or decline machine-inferred entries, ranked by how many source memories back each one. Forgetting supports soft-delete and an agentic mass-forget with a dryRun preview. Per-space extraction steering tells the pipeline what to remember. RBAC scopes access by container tag. That is real control.
But notice where it sits. Those tools let you veto and configure what the pipeline produced. None let you define what a relationship means, weight one source above another at retrieval, or express that five successful applications of a fix should permanently outrank the four failures before it. You can prune and tune the graph. You cannot author its semantics.
Knowledge That Earns Its Rank
Here is the capability whose nearest counterpart works the other way round.
LocusGraph promotes knowledge up four stages — Data → Information → Knowledge → Wisdom — or in short, event → pattern → skill. An index-out-of-bounds error enters as an observation in an error: context. The third time it recurs, a fact links back with reinforces and confidence climbs. After five successful applications of the fix, it graduates to skill:pagination_safety, which outranks every event that produced it. The agent stops replaying eleven incidents and fetches one distilled skill.
Supermemory shipped the nearest thing in August 2026: Company Brain skills let a team teach repeatable processes — incident triage, changelog updates, onboarding — which an admin approves org-wide (changelog). Real procedural memory, and it would be dishonest to ignore it. The difference is provenance. A Company Brain skill is written by a human and approved once, so it is exactly as good as its author and goes stale the moment reality diverges. A LocusGraph skill is earned, and carries the evidence chain that justified its promotion. One is documentation with better distribution. The other is a system that notices what works.
Two consequences follow. The first is token economics running backwards from everyone else's: roughly 5× reduction from tight scoping and 10× from retrieving a skill instead of replaying raw events. Retrievals get smaller as knowledge matures, because a mature skill is one node where a young pattern was fifty.
The second is auditability, and it's where the category leaves a shelf empty. Almost nobody in agent memory uses governance vocabulary — provenance, explainable recall, auditable memory — and it's the thing that decides enterprise deals. Supermemory's posture is solid: SOC 2, GDPR, a HIPAA BAA on the $399 Scale tier, air-gapped self-hosting on Enterprise, and RBAC since April 2026. Its provenance is better than critics assume — the Memories API returns version, parentMemoryId, rootMemoryId, documentIds and a full history array.
What you cannot get is a weight. No belief-confidence number to point at, no record of how much each source moved a belief, no published trail of what a dream cycle changed. "Which documents produced this memory" is answerable. "Why does this memory outrank that one, and what would change it" is not.
LocusGraph treats that second question as the product. Every event carries a cryptographically signed audit trail. Contradicted knowledge is demoted, never deleted — the deprecated belief stays queryable beside what replaced it, so "what did the agent think in March, and what changed its mind" is a query rather than an excavation. Knowledge lives outside model weights, so a model migration is a config change, not a re-ingestion project.
Which One You Should Pick
Supermemory | LocusGraph | |
|---|---|---|
Category | Context cloud — memory, RAG, connectors | Structured Agent Knowledge layer |
Unit stored | Extracted memory, auto-typed | Typed event: |
Edge types | 3 fixed: | 5 explicit, incl. |
Custom relationships | Not supported; edges readable, no query language | Yours to design ( |
Confidence | Similarity (0–1) at retrieval; no belief score | Explicit arithmetic: +0.05 / −0.10 |
Source weighting | Not user-controllable |
|
Knowledge promotion | Company Brain skills: human-taught, admin-approved | Graduation Chain: earned by reinforcement |
Contradictions | Superseded; | Demoted, retained, auditable, never deleted |
Provenance |
| Cryptographically signed + confidence arithmetic |
Ingestion | 8 connectors (tier-gated), full extractors | API / SDK / MCP writes only |
Latency published | Sub-300ms recall | Not published |
Entry price | $0 · $19 Pro · $100 Max · $399 Scale | $0 · $49 Pro · $149 Team · $29 founding |
Maturity | 100B+ tokens/mo, ~29K stars | Early stage, free beta, waitlist |
Switch to LocusGraph when your agent keeps re-learning the same fix and nobody has time to write the playbook by hand; when human corrections must permanently outrank the agent's own guesses; when someone will eventually ask why the agent retrieved that and you need an answer with a number in it; when several agents should read one validated knowledge base; or when you're planning a model migration and don't want knowledge locked to a vendor's pipeline.
Stay on Supermemory when latency is your binding constraint, when your value is ingesting documents rather than compounding agent experience, or when you need memory across your whole company this quarter.
Is LocusGraph a Supermemory alternative?
For the memory and knowledge layer, yes. It does not replace Supermemory's connectors, document extraction, or RAG over files.
Does Supermemory have a knowledge graph?
Yes — built automatically, three fixed edge types, temporal truth, automatic forgetting. No custom relationships and no traversal query language.
Can I use Supermemory and LocusGraph together?
Yes. Supermemory ingests and retrieves your documents; LocusGraph stores what your agents learn from acting on them.
Which is cheaper, LocusGraph or Supermemory?
Different models. Supermemory meters usage from $0.005 per 1K tokens. LocusGraph charges flat per event volume, $0 to $1,950.
How does LocusGraph confidence scoring work?
reinforces adds +0.05 per link, capped at 1.0. contradicts subtracts 0.10, floored at 0.2. Demoted knowledge stays queryable.
Can I self-host either one?
Both. Supermemory ships a single binary for macOS and Linux, plus air-gapped Enterprise. LocusGraph offers dedicated Enterprise instances.
Not just longer-context. Not just better-prompted.