GENOME

Most agent-memory tools (like Mem0) call an LLM onevery messageto decide what to remember. That's the slow, expensive part - and GENOME's bet is that you don't need it. GENOME just embeds each message locally: no LLM, no API, no network in the write path.

Benchmarked honestly on public datasets (LoCoMo, LongMemEval), GENOMEanswers just as accurately as Mem0- while storing memories for a tiny fraction of the cost and running completely offline.

Honest up front:on answer accuracy, GENOMEtiesMem0 - we donotclaim to beat it there (six independent benchmark configurations confirm parity, none significant in either direction). The advantage is cost, speed, offline operation, and a temporal/auditable record Mem0 can't produce.

The interesting part is step 3. The same question gets three different correct answers depending onwhenyou ask about, because the store keeps when each fact became true rather than overwriting it:

The "thinking about maybe moving to Denver, nothing decided" turn is stored but never becomes an answer: it is a plan, not a durable fact.

The write path is deliberately dumb and cheap. All the intelligence happens at read time, when there is a query to focus it.

Add persistent memory to your agent in one line (MCP)

GENOME ships afully-local MCP server- cross-session memory for Claude Desktop, Claude Code, or Cursor withno API key and no data leaving your machine:

Why it's ~1,000× cheaper: it never calls an LLM to remember

Storing one message costsone LLM call in Mem0, zero in GENOME(just a local embedding). That's not a benchmark you can argue with - it's arithmetic, and it holds no matter which LLM you price it against. At 10,000 users × 50 messages/day (15M messages/month):

The gap survives the cheapest model andgrowsin production (Mem0 re-sends stored memories to the LLM as the store fills). Reproduce:python benchmarks/tco_project.py(no API key).

GENOME's default embedder is local. We proved the write path is genuinely offline byblocking all network during writes- they still succeed:

- ~10 ms/message, 0 network calls, 0 LLM calls(python benchmarks/local_writepath.py)
- Mem0 can't do this - it needs an LLM API call to ingest.

That makes GENOME usable on-prem, in regulated environments, or fully offline. It's a yes/no capability, not a price point.

- Write:embed the message locally and store it. No LLM, no network. (~10 ms)
- Read:vector search over your memories, with an optional local cross-encoder reranker for harder queries.
- Optional bi-temporal layer:track how facts change over time and answer "what was true at time T" - see below.

Because nothing on the write path interprets your content, GENOME can do things an LLM-ingest memory system cannot do in principle:

-

Memory firewall(genome.firewall): tag every write with where it came from (user,agent,tool,web), quarantine low-trust origins from recall, and enforce origin-bound authority - web content can never UPDATE or DELETE what your user said, even when a prompt-injected conflict resolver asks for it. There is also no extraction step for injected content to attack: the write path has no LLM.

from genome import Memory from genome.firewall import TrustPolicy m = Memory(trust_policy=TrustPolicy(recall_min_trust=1)) m.add("I live in Anchorage", user_id="u1", provenance="user") m.add(scraped_page_text, user_id="u1", provenance="web") # quarantined

Explainable recall(genome.explain):explain_search()reports every candidate's dense score, BM25 rank, fused score, and - when it was not returned - the exact reason (parent-filtered, quarantined, beyond the limit). Two runs agree, so a recall bug can be committed as a regression test instead of a shrug.

Journal + replay(genome.journal): record every mutation and provably reproduce the store -verify_journal()replays the history and compares canonical hashes. Replay a prefix to roll back; replay into different storage to branch a memory for a what-if run. The journal sits after extraction, so replay is deterministic even if you configured an LLM extractor. Each line chains to its predecessor, so a removed or edited line is detected even when the change cancels out in the final state.

from genome import Memory mem = Memory(storage="genome.db") # local embedder by default; ":memory:" for ephemeral # Store a message -- embedded locally, no LLM call, no network mem.add("Ada met Lin at the robotics summit in Berlin.", user_id="u1") mem.add("They are collaborating on an open-source planning library.", user_id="u1") # Retrieve the most relevant memories for hit in mem.search("Where did Ada meet Lin?", user_id="u1", limit=5): print(f"{hit.score:.3f} {hit.content}")

Memorymirrors Mem0's API (add/search/get/delete/reset) - a near drop-in swap. To use OpenAI embeddings instead (setOPENAI_API_KEY):

from genome import Memory, EmbeddingProvider mem = Memory(storage="genome.db", embedding_provider=EmbeddingProvider(model_name="openai:text-embedding-3-small"))

Use it as an MCP server (fully-local memory for any agent)

GENOME ships an MCP server, so any MCP client (Claude Desktop, Claude Code, Cursor, ...) gets persistent cross-session memory that runsentirely on the local machine- no LLM calls, no API keys, no data leaves the box. Most memory MCPs can't say that.

Install with themcpextra, then add it to your client's config:

import { Memory } from "@northtek/genome-memory"; const mem = new Memory({ baseUrl: "http://localhost:8080" }); await mem.add({ text: "Ada met Lin in Berlin.", userId: "u1" }); const hits = await mem.search({ query: "Where did Ada meet Lin?", userId: "u1" });

Same responder + judge + embedder for every system; only the memory layer changes.

What we tested thatdidn'thelp (so you don't have to)

We publish our nulls - it's how you know the wins are real:

- Synthesis / consolidation:accuracy-neutral at equal token budget (p = 0.86).
- Hybrid (BM25 + dense) and graph retrieval:hybrid underperformed plain dense on LoCoMo; graph was not validated here.
- Reranking's accuracy gain is embedder-dependent:it reliably improvesretrieval hit-rate, but its effect on finalanswer accuracydepends on the embedder - treat it as a retrieval-quality tool, not a guaranteed accuracy win.

Bi-temporal memory: "what was true at time T"

GENOME can track how facts change over time and answer point-in-time questions - something overwrite-based memory structurally can't do (it only keeps the latest value):

from genome.memory.belief import ingest_belief_turn, answer_belief_context mem = Memory(storage="genome.db", llm_call=my_llm_fn) # facts land at their DOMAIN time (parsed from the text), not wall-clock ingest time ingest_belief_turn(mem, "In March 2024, Jordan moved to Seattle.", session_time=t0, user_id="u") ingest_belief_turn(mem, "Jordan just moved to Austin.", session_time=t2, user_id="u") answer_belief_context(mem, "Where does Jordan live now?", user_id="u") # -> Austin answer_belief_context(mem, "Where did Jordan live in early 2024?", user_id="u") # -> Seattle answer_belief_context(mem, "List every city Jordan has lived in.", user_id="u") # -> Seattle; Austin

On the TempBelief benchmark it answers as-of queries at0.870vs Mem0's 0.676, with the knowledge graph audited at 0.97 precision / 0.96 recall.Caveat:TempBelief is synthetic text with explicit dates; the edge shrinks on natural speech. Real capability, bounded proof.

Opt-in; the default path stays LLM-free and local at ingest.

mem = Memory( storage="genome.db", llm_call=my_llm_fn, # LLM-based fact extraction on add() resolve_conflicts=True, # ADD/UPDATE/DELETE vs existing memories auto_extract_entities=True, # entity graph for graph retrieval auto_consolidate_threshold=200, # summarize-or-prune when a scope grows past N ) mem.search("...", user_id="u1", mode="hybrid") # modes: "dense" (default), "hybrid", "graph"

from genome.memory.rerank import CrossEncoderReranker mem = Memory(storage="genome.db", reranker=CrossEncoderReranker()) # lazy-loaded mem.search("Where did the user go on vacation?", user_id="u1", limit=5) # reranked

python benchmarks/local_writepath.py # local write path: ~10ms/msg, 0 network python benchmarks/tco_project.py # deployment cost projection python benchmarks/verdict.py # in-window accuracy + McNemar python benchmarks/haystack_report.py # overflow / context-window crossover python benchmarks/ingest_cost.py --n 80 # measured ingestion cost vs Mem0 python benchmarks/lme_qa.py --n 90 # LongMemEval head-to-head vs Mem0 python benchmarks/tempbelief_run.py --convs 6 # bi-temporal point-in-time vs baselines