Comparision
LocusGraph vs Neo4j: Storing Knowledge Versus Trusting It
The gap is not storage — and Neo4j is not idle
Your agent shipped a fix at 2:14am: retry with exponential backoff, three-second base, because linear retry had tripped the vendor's rate limiter the week before.
Six weeks later a different agent, same codebase, hits the same endpoint. It writes linear retry. It trips the rate limiter. Somebody pages somebody.
The knowledge wasn't lost. It's in your graph, as a node, exactly where you put it. It was never promoted above the four hundred other nodes written that month, because nothing had a standing opinion about which had earned the right to be recalled. That is not a storage gap.
Vague criticism is worthless, so here are the specifics — including the ones that make this comparison harder for us. Neo4j has built native property graphs since 2007. Cypher, introduced in 2011, seeded openCypher and ultimately the ISO GQL standard; Neo4j didn't just win the category, it wrote the grammar. It reported $200M+ ARR as of late 2024, serves 84% of the Fortune 100, and claims 250,000+ developers. Native vector search entered public beta in 5.11 (August 2023) and went GA in 5.13. Infinigraph — announced September 2025, now generally available — unifies OLTP and OLAP on one graph past 100TB.
The agent story is not a slide deck either. Aura Agent reached general availability on February 3, 2026 across Free, Professional and Business Critical tiers. In July 2026 Neo4j shipped MCP for Aura, a hosted MCP server built into every Aura instance at no extra cost. In June 2026 it acquired GraphAware, launching Hume as an intelligence-analysis alternative to Palantir Gotham. And NAMS, the Neo4j Agent Memory Service, is a hosted memory layer combining short-term, long-term and reasoning memory in one graph, with automatic entity extraction, a resolution cascade running exact match → fuzzy (Levenshtein, Jaro-Winkler, token-sort) → semantic, background compression of messages into observations and observations into a single active reflection, and a hosted MCP surface of 47 tools.
If you read a comparison post claiming Neo4j has no agent memory story, close it. The real question isn't whether Neo4j can store agent knowledge. It's what happens to a claim after it's stored — specifically, when it stops being true.
The modeling tax: you design the ontology before the agent learns anything
Neo4j's power rests on a premise: you know the shape of your domain. Define nodes and relationships, write the Cypher, and the engine rewards you with traversals nothing else matches. For a fraud graph or a supply chain, that holds. Domains have shapes, and someone models them once.
Agent experience has no shape in advance. You can't know on Monday that the interesting relationship will be "this deploy script fails only when the config was edited after the migration ran." That edge type isn't in your ontology because the failure hadn't happened yet.
Neo4j's tooling softens this considerably. NAMS extracts entities automatically under a POLE+O ontology — Person, Organization, Location, Event, plus Object. The heritage is intelligence analysis, and since the GraphAware acquisition that's a deliberate strategic asset rather than an accident. For "who, where, which org, what event," it's excellent and covers a great deal of conversational memory.
But notice what POLE+O recognizes: entities. It has no native slot for what a working agent accumulates — a decision and its reasoning, a correction from a human, a constraint that fired at runtime, a failure that recurs. Those aren't people, places or objects. They're claims about how work goes.
LocusGraph starts from that end. There's no ontology to author. Every event arrives typed by what it is to an agent — fact, action, decision, observation, feedback — and tagged by who produced it: agent, user, system, validator, executor. Two events can carry identical payloads and still mean different things, because a conclusion the agent reached and the same conclusion a human corrected it into are not the same claim. The user source carries the highest trust weighting by default, as a standing property rather than a review step.
Neo4j can refuse a write, too — NAMS ontologies have a strict mode where "writes that violate the schema are rejected." But that's schema admission: is this shape legal? LocusGraph's pipeline validates, classifies, extracts, and can return "status": "filtered" — epistemic admission: is this claim worth keeping at all? Different gates, and only one of them is about knowledge.
Distillation is a build step. Graduation is a control loop.
This is the strongest part of Neo4j's case, so take it seriously. On August 6, 2026, Neo4j Labs published grounded skill distillation in NAMS. Point it at a scope — a workspace, an entity, an ontology class — and it snapshots the relevant memory, synthesizes a procedure, runs quality gates and packages the result in the agentskills.io format: a SKILL.md, a typed step graph, provenance.json, reference docs. Every claim and step is GROUNDED_IN specific source node ids. The gates are published numbers — grounding ≥0.9, coverage ≥0.6, plus coherence, spec validation and PII checks. Published skills are signed with a detached JWS you can verify offline.
That provenance model is excellent — better auditing than most memory products ship. If verifiable, signed grounding is your hard requirement, Neo4j has the stronger answer today. We'd rather say so than have you find out later.
Now ask precisely what it does and doesn't do. Distillation is enabled by default but always initiated — you call it over a scope; there's no scheduler. It produces a snapshot with a human gate: skills move draft → in_review → published, and the docs are explicit that "A human approves or rejects a distilled skill before it is published…" Low-grounding runs are withheld. Whole-workspace distills "tend to be withheld once a workspace holds more than one distinct procedure." Composition is off by default; execution is dry-run only.
Everything before that snapshot is compression — background workers summarizing messages into observations, then into one active reflection. Real engineering on a real problem. But summarizing is lossy in a specific direction: it preserves what was recent and frequent, not what was validated. A confidently wrong claim repeated six times compresses beautifully.
LocusGraph's Graduation Chain runs continuously, on different evidence. Data becomes information when typed and scoped. Information becomes knowledge when repeated evidence forms a pattern with rising confidence. Knowledge becomes wisdom when a validated pattern is promoted to a skill — a node labelled skill:<name> carrying higher confidence and prioritized in retrieval. The recipe is concrete: log the error observation, and after the same error appears 3+ times, create a fact that reinforces it; after 5+ successful applications, promote it with extends.
In one line: Neo4j distils a skill when you ask and a human signs off. LocusGraph graduates one when the evidence says it earned the promotion. One is a build step you trigger; the other runs whether you're watching or not.
Drifted procedures versus stale facts
Every memory product will demo an agent remembering something. The demo that matters is the agent remembering something that has since become false. Your API rate limit was 1,000 requests per minute. In March it changed to 600. The old fact is in the graph, well-connected, retrieved dozens of times, and about to take down a production job.
Here Neo4j has more than most comparison posts credit it with — and less than it needs. NAMS ships a skill-drift check: it compares a step's recorded expectStatus against the current status of the :ToolCall nodes it is grounded in, and flags a step as contradicted when a tool that used to succeed now fails. There's a GET /v1/skills/{id}/drift endpoint, a step repair that cuts a superseding patch version, a governance endpoint, and a skill_drift MCP tool. Memory consolidation also documents preference superseding.
That is genuine contradiction handling, well built. But look at where it lives: at the skill layer, over tool-call outcomes. It catches a procedure that stopped working. Nothing in it compares "rate limit is 1,000/min" against "rate limit is 600/min" and demotes the older claim, because no tool call failed — the agent simply believes something outdated. And there's no decay, only ttl_days conversation archival.
Underneath, the picture is thinner. The community mcp-neo4j-memory server exposes exactly what a CRUD memory should: create_entities, delete_entities, create_relations, delete_relations, add_observations, delete_observations, read_graph, search_nodes, find_nodes. Nine tools, no scoring, no decay. The hosted NAMS surface is far richer, but its confidence scores are entity-resolution confidence — "are these two nodes the same thing?" — not "is this claim still true?"
LocusGraph puts fact-level contradiction in the substrate, with published arithmetic. A reinforces link adds +0.05, capped at 1.0. A contradicts link subtracts 0.10, floor 0.2. Contradicted knowledge is demoted, never deleted — it stops surfacing in retrieval but stays in the audit trail, so you can answer "what did the agent believe in March, and why did that change?" Retrieval filters by scope, ranks by semantic similarity, then adjusts by confidence, so the corrected fact wins and the stale one fades without anyone writing a cleanup job. Deletion is not correction; deletion destroys the evidence that you were ever wrong, which is the exact record an auditor asks for.
The bill, the honest scorecard, and how to test this yourself
What you actually operate. Neo4j is a database you run. The free path caps at 200,000 nodes and 400,000 relationships, and free instances are deleted after 30 days of inactivity. AuraDB Professional starts at $65/GB/month (1GB minimum), Business Critical at $146/GB/month (2GB minimum). Aura Agent is free for internal agents and bills $0.35 per agent hour only for agents on a public endpoint. Self-hosted Community Edition is GPLv3, with clustering and RBAC behind the Enterprise license — though Neo4j has been loosening this, adding free Graph Analytics to AuraDB Free and shipping ABAC in August 2026. One bright line: NAMS and the neo4j-agent-memory SDK are Neo4j Labs projects, marked "Status: Experimental" and community supported, with Neo4j stating it doesn't "provide any SLAs or guarantees around backwards compatibility and deprecation." The database underneath is enterprise-grade; the memory service on top is not yet sold as such. LocusGraph is an API you call: Free $0, Pro $49/month, Team $149/month, Enterprise from $1,950/month. No cluster to size, no ontology to author, no Cypher to write — five operations across TypeScript, Python and Rust SDKs, an OAuth-protected MCP endpoint, and LangChain adapters.
Neo4j | LocusGraph | |
|---|---|---|
What it is | Graph database + agent tooling (NAMS, Aura Agent) | Structured Agent Knowledge layer |
Schema | You model the domain; NAMS extracts to POLE+O | No ontology; events typed by kind and source |
Query surface | Cypher (ISO GQL lineage) | Semantic retrieval with scope + confidence filters |
Confidence | Entity-resolution confidence (same node?) | Knowledge confidence (still true?) — |
Contradiction | Skill-drift detection + step repair, procedure layer | Fact-level |
Decay | None ( | Confidence-driven; stale knowledge fades from retrieval |
Skills | Distilled on request, snapshot, human-approved, JWS-signed | Graduated continuously from reinforcement evidence |
Source trust | Human signal enters at review gates |
|
Admission | Ontology strict mode rejects schema violations | Pipeline can classify, extract, or filter an event |
Agent memory maturity | Labs — experimental, no SLA | Core product, but early-stage company |
Entry price | Free: 200k nodes / 400k rels; Pro $65/GB/mo | Free $0; Pro $49/mo |
Ecosystem | 250,000+ developers, GraphAcademy, 19 years of docs | Small, new, growing |
Where Neo4j still wins, plainly. General graph workloads — fraud rings, supply chains, entity resolution at scale, 65+ GDS algorithms, now free on AuraDB Free up to 2GB — are not a contest, and LocusGraph shouldn't be evaluated there. Verifiable provenance is theirs today: GROUNDED_IN node ids plus offline-verifiable signed bundles beats most of this category. Cypher lets you ask a question nobody anticipated, which semantic retrieval does not replace. And maturity may simply disqualify us: nineteen years, $200M+ ARR, Fortune 100 references, formal SLAs, now GraphAware. LocusGraph is early-stage. If procurement requires vendor longevity, that decision is already made.
Who should switch. Count how many are true: your agents re-learn the same lesson across sessions; you've written Cypher whose only job was deciding which memory to trust; your stale problem is wrong facts, not broken tool calls; human corrections carry no more standing weight than the agent's own guesses; you can't answer what the agent believed last quarter and why that changed; your memory nodes only grow and nothing is ever demoted. Three or more and you don't have a database problem — you have a restart tax, paying twice for the same understanding every session.
What does each cost to start?
Neo4j: free 200k nodes, Professional from $65/GB/month, Aura Agent $0.35 per public agent hour. LocusGraph: Free $0, Pro $49/month.
We already run Neo4j. Is adding LocusGraph worth it?
Only if your agents keep re-learning. Domain data humans model? Neo4j alone. Knowledge agents produce and must retire? Different job.
Do I need Cypher for LocusGraph, and can it handle 100TB?
No, and no. Five operations across TypeScript, Python and Rust SDKs, plus MCP. Infinigraph exists for petabyte graphs.
What's the difference between skill distillation and the Graduation Chain?
Distillation is a snapshot you trigger and a human approves. Graduation is continuous: reinforcement raises confidence, and validated patterns become skill nodes.
Does Neo4j handle contradictory knowledge?
Partly. Skill-drift flags a step when its tool starts failing. It won't demote a fact that quietly stopped being true.
Not just longer-context. Not just better-prompted.