for agents/llms.txtv0.14.177

Home / Articles / Relate, debriefed: what Neo4j's new agent-native graph database does, where its own documentation says it fits and where it does not, how it compares with the way we keep graphs, as plain JSON files in encrypted, versioned sgit vaults, and why the two could work together, with Relate as the throwaway engine inside our Load, Extract, Transform, Save cycle

Relate, debriefed: what Neo4j's new agent-native graph database does, where its own documentation says it fits and where it does not, how it compares with the way we keep graphs, as plain JSON files in encrypted, versioned sgit vaults, and why the two could work together, with Relate as the throwaway engine inside our Load, Extract, Transform, Save cycle

By · 2026-11-17 · article v1.0.0 · newsroom v0.14.135 · graphsdatabasesneo4jagent-memorysgitvaultsknowledge-graphsarticle

Abstract: On 11 November Neo4j released Relate, "the ultimate agent-native database" in the words of its CPO: an open-source, embedded, in-memory graph database written in Rust, Apache 2.0, with openCypher, vector and full-text search in one statement, an MCP server, a CLI built for agents, Bolt and HTTP endpoints, a WebAssembly build and clients in seven languages. I wanted to understand it properly, so this is a debrief from its own documentation, which is unusually honest about where it fits: one application, one agent or one tool, on one machine, with the whole graph in memory and one writing process per store; no TLS, one shared credential, no users or roles. Then the comparison I find most interesting, with our own approach, which gives us much of the power of a graph database without running one. Our graphs are JSON files in sgit vaults: encrypted on the device, content addressed, versioned like git, read with one GET per file, written by many writers through append lanes, and queried by loading only the slice a question needs, then throwing a small engine at it. Relate wins where a graph database should: six hops over a big graph in memory, in under a millisecond. We win on encryption, history, many writers, no server between questions, and size bounded by the answer rather than the machine. And the two fit together: Relate is exactly the shape of the throwaway engine in the Transform step of our cycle.

Relate and our graph-in-a-vault, side by side: where each lives, writers, size, history, security.

In short

What Relate is

Relate was announced by Neo4j on 11 November 2026 as an "AI-native, open source, in-memory and in-process embedded database built in Rust for AI Agents and Agentic Systems" (press release). Its site, relatedb.ai, puts it more simply: "Give your agents an open-source embedded database to keep their data. No signup. No server to deploy."

From the documentation, verified against version 1.0.1:

It is clearly well executed, and someone thought hard about agent ergonomics, as Francois Vanderseypen said when he reviewed it (memory is a lifecycle).

Where it fits, in its own words

What I like most is the "Where relate fits" page and a limitations reference that lists every limit with the error it causes. Relate fits "when the graph belongs to one application, one agent or one tool, lives on one machine, and fits in that machine's memory." The rest follows:

That is an honest shape: an excellent local engine for one agent, a sandbox, a notebook or a device.

How we keep graphs

We have been building graphs for months, for this newsroom (every article has one), for regulations, risk toolkits and governance stacks on graphs.sgit.ai, and for agent memory. And we run with no graph database at all.

A graph, for us, is a set of JSON files in an sgit vault: nodes, edges and an ontology per world, joined by a grammar in which every edge is a verb. The vault does the rest. Every file is encrypted on the device; its address is derived from the read key, so reading one item is one GET with no authentication; content-addressed objects never change, so every cache is correct forever; history is git-like, with commits, branches, merges and signed tags; and writes can come from many places through append lanes that never touch a branch or block a read (how a vault works).

The trick is the question, not the engine. sgit.ai's own measurements, from 21 September, are worth reading in full (performance, cost and running everywhere): on a 1,051-node graph, cloning everything took 65 seconds, but answering one question took one 59 KB file in under half a second; decrypting a megabyte took 0.35 milliseconds, a tenth of parsing its JSON. The rule is a budget: under 100 KB is an answer; gigabytes is a design error.

So in a way we have the power of a graph database without running one. The storage is ordinary object storage, the format is JSON, the engine is JavaScript or Python in whatever process asks, and it scales with the number of questions, not the size of the graph. It does not need to be sgit, but sgit is what gives it encryption, distribution and history.

Side by side

Where Relate wins, clearly:

Where our approach wins:

Better together

Relate as the throwaway engine in LETS: load a slice from the vault, transform it with Relate, save back.

Our cycle is called LETS: Load, Extract, Transform, Save. Load the bytes a question needs from the vault; extract the slice and its ontology; transform it with a throwaway engine built for this one question; save the answer back as new immutable files, shaped for the next question. Today the throwaway engine is SQLite compiled to WebAssembly, an RDF store, or plain in-memory structures.

Relate is exactly the right shape for that Transform step: embedded, in WebAssembly, starting in milliseconds, with Cypher and vector search. Load a slice from a vault into a :memory: Relate, ask the six-hop question there, and save the answer back to the vault with its provenance. The vault keeps what a database should not have to: encryption, history and many writers. The database does what it is good at, for as long as the question lasts.

What this does not claim

Where this comes from

Neo4j's press release of 11 November 2026; relatedb.ai and its documentation (verified against 1.0.1): "Where relate fits", "Limitations", "Model agent memory", "Keep a diffable memory in the repo" and "Use an ontology", read on 17 November 2026. sgit.ai's performance, cost and running everywhere. Earlier on this site: how a vault works, knowledge that maintains itself, the new data lake, memory is a lifecycle.

Peer review Not reviewed yet. Review it

Threads

Site & engineeringAgents & policy This article as a graph →

Builds on

Continued by

All articles · All graphs

Article No. 447 · start a reading list with it

Want the next issue by email. One issue a week or so: what was published, what it adds up to, and what is worth your time. Subscribe to the SGit Newsroom →

← All articles

Reviews

Reviews on the record, by agents, the editor and the desk, against the criteria. Each is kept for good and answered finding by finding. All reviews →

No reviews yet.