Agent memory should not be your product’s weakest link.

xmemory turns messy agent interactions into structured, validated, observable memory, taking care of the reliability work that usually gets scattered across prompts, tools, cleanup jobs, and application code.

Radar chart comparing xmemory with knowledge graph, pure vector, and file-based memory across latency, cost efficiency, accuracy, consistency, observability, inspectability, governance, scalability, maintenance, and cross-agent use

Why xmemory is different

Without structure, ambiguity is not an edge case — it is the default.
With structure, facts become addressable, updatable, queryable, and auditable.

Text-based memory

Stores notes, summaries, and recalled context.

xmemory

Stores facts, normalised and clean for complex requests

Thematic recall — "What did we discuss?"

Every read is another act of interpretation

State is reconstructed from prose each time

No deduplication — facts accumulate and conflict

No provenance — changes are untraceable

Ambiguity is the default, not the edge case

Exact lookup — "What timeout did we set?"

Latest state — "What is the current status?"

Relational queries — "Which users affected after release X?"

Explicit unknowns — "What facts are missing?"

Aggregation — "How many incidents since Monday?"

Constraints reject ambiguity instead of guessing

Why not markdown files?

Markdown files are excellent for prototyping,
but they make long-term memory depend on prose, prompts, and luck.

Structure is local

The model creates file structure in the moment. It can follow today’s prompt, but it is not a durable contract across runs, agents, or versions.

Reads get wider

A simple question can require reading current notes, old summaries, related files, and compacted history before the agent can answer.

Updates rewrite prose

Changing one fact means finding the right sentence, preserving context, avoiding duplication, and hoping nearby meaning stays intact.

Entities hide in text

The same account, person, incident, or task can appear across many files. Unless the agent reads everything, connections disappear.

File memory over time
Read more files, infer more meaning, spend more tokens.
Targeted memory call
What timeout did we set for Acme?
customer: Acmesetting: timeoutsource: incident #184
timeout = 30s
Read the smallest reliable slice of state.

Why not graph memory?

Graphs are powerful for connecting knowledge,
but agent memory also needs reliable writes, current state, and explicit semantics.

Edges are not truth

A graph can connect related entities, but the workflow still needs to know which fact is current, validated, and safe to use.

Writes need contracts

Memory writes need required fields, allowed values, uniqueness rules, and conflict handling, not only extracted nodes and relations.

Updates are ambiguous

“Amy is no longer Kevin’s manager” should update current state, preserve history, and avoid leaving stale edges as live facts.

Retrieval is not lifecycle

Real workflows need deletion, provenance, permissions, schema evolution, and observability around every memory operation.

Graph memory
Graph memory with conflicting manager edgesAmyPriyaKevinTeam AIncidentmanages?new manager?Two plausible edges, no explicit current-state contract
Related edges are retrieved, but current truth is still inferred.
Validated state update
Amy is no longer Kevin’s manager. Priya is.
UPDATE employment_relation SET valid_to = now() WHERE employee = 'Kevin' AND manager = 'Amy';INSERT INTO employment_relation (employee, manager, valid_from, source) VALUES ('Kevin', 'Priya', now(), trace_id);SELECT manager FROM current_employment WHERE employee = 'Kevin';
manager = Priya
Relations become explicit state with history and constraints.

Why not MCP over Database?

MCP is a great way to expose tools and data,
but it does not turn messy agent memory into reliable state by itself.

Tools are not semantics

MCP can expose database operations, but the agent still has to decide what the user meant and which state should change.

Schema is not mapping

Tables define storage. They do not extract facts from language, map them safely, or explain missing and ambiguous fields.

Writes need mediation

Real memory writes need validation, deduplication, conflict handling, provenance, retries, and observable decisions.

Reliability gets scattered

Without a memory layer, reliability work spreads across prompts, wrappers, app code, cleanup jobs, and eval scripts.

MCP over Database
The database is reachable, but the memory harness still has to be designed and maintained inside your custom tooling.
xmemory over Database
xmemory is the engine between natural-language agents and reliable structured storage.

Measurements

Structure improves memory quality.
xmemory extracts structured data better than one-shot structured output.

Measured against real memory failure modes

We evaluate whether systems can store, update, deduplicate, and retrieve facts and relationships reliably, not just whether they can recall similar text.*

xmemory97.10%
Mem0 (no graph)87.24%
Cognee86.18%
Mem0 (graph)86.07%
Supermemory80.49%
Zep80.16%

* Read more about measurement methodology and open benchmarks in our white paper.

Token consumption

Lower token use than text-based memory by optimising reads.

2x+ fewer tokens

Assuming 10 reads per write,
10 write tokens per 5 read tokens for xmemory,
and 5 write tokens per 12 read tokens for typical text-based storage architecture.