GENOME

GENOME

Open memory for AI agents. Same answer accuracy as Mem0 — but ~1,000× cheaper to store, runs fully offline, and keeps an auditable record.

Most agent-memory tools (like Mem0) call an LLM on every message to decide what toremember. 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), GENOME answers just asaccurately as Mem0 — while storing memories for a tiny fraction of the cost and runningcompletely offline.

Honest up front: on answer accuracy, GENOME ties Mem0 — we do not claim to beatit there (two independent benchmark runs confirm parity). The advantage is cost, speed,offline operation, and a temporal/auditable record Mem0 can't produce.

GENOME vs Mem0 at a glance

Every number is measured within one harness — same responder, judge, embedder, and top-k;only the memory layer changes — with paired significance tests. Full detail and per-numberprovenance: benchmarks/RESULTS.md. Formatted report:benchmarks/GENOME-LoCoMo-Report.pdf.

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

Storing one message costs one 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 whichLLM you price it against. At 10,000 users × 50 messages/day (15M messages/month):

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

It runs air-gapped

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/nocapability, not a price point.

How it works

• 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 rerankerfor harder queries.
• Optional bi-temporal layer: track how facts change over time and answer "what was trueat time T" — see below.

Install

Until the PyPI release lands, install from source:

pip install "git+https://github.com/NORTHTEKDevs/genome.git"

(pip install genome-memory is coming.) The default embedder is local(sentence-transformers/all-MiniLM-L6-v2) — no API key, works offline; the first rundownloads the ~90 MB model once. OpenAI embeddings are optional for higher-dimensional retrieval.

Quickstart (fully local, no API key)

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}")

Memory mirrors Mem0's API (add / search / get / delete / reset) — a neardrop-in swap. To use OpenAI embeddings instead (set OPENAI_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, …) getspersistent cross-session memory that runs entirely on the local machine — no LLM calls,no API keys, no data leaves the box. Most memory MCPs can't say that.

Install with the mcp extra, then add it to your client's config:

pip install "genome-memory[mcp] @ git+https://github.com/NORTHTEKDevs/genome.git"

{
  "mcpServers": {
    "genome": { "command": "genome-mcp" }
  }
}

Tools the agent gets: remember (store a fact/preference, local + 0 LLM), recall(semantic search), forget (delete the memory matching a query), reset_memories(clear a user's memories). Memories persist in ~/.genome/memories.db (override with theGENOME_MCP_DB env var). Run standalone with genome-mcp or python -m genome.mcp.server.

The honest results

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

What we tested that didn't help (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 improves retrievalhit-rate, but its effect on final answer accuracy depends on the embedder — treat it as aretrieval-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 — somethingoverwrite-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 at 0.870 vs Mem0's 0.676, with theknowledge graph audited at 0.97 precision / 0.96 recall. Caveat: TempBelief is synthetictext with explicit dates; the edge shrinks on natural speech. Real capability, bounded proof.

Optional features

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"

Reranking (local, free, no API):

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

Reproduce the benchmarks

The LoCoMo and LongMemEval datasets are not bundled (they carry their own licenses —LoCoMo is CC BY-NC 4.0). See benchmarks/data/README.md todownload them. The first two lines need no dataset and no API keys:

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

License

Apache License 2.0 — see LICENSE and NOTICE.

GENOME is free and open source: read it, modify it, self-host it, and embed it in your ownapplications — commercial use included — under the terms of Apache 2.0. Questions:[email protected].

Copyright 2026 Northtek (FrostByte Digital LLC).