genome

GENOME is an open memory layer designed for AI agents, with the core claim being: storing memories does not require calling an LLM. Most agent memory tools (such as Mem0) call an LLM on every message to decide what to remember, which is both slow and expensive; GENOME's write path simply embeds and stores messages locally, without calling an LLM, accessing the network, or requiring an API key. According to the project's public benchmarks (LoCoMo, LongMemEval), GENOME's answer accuracy is comparable to Mem0 (the project explicitly states it does not surpass it; all six independent benchmark configurations are on par, with no significant difference), and its advantages lie in cost, speed, offline operation, and auditable temporal records.

Purpose and positioning: aimed at scenarios that need to provide persistent memory for AI agents locally, offline, or in regulated environments. The write path is deliberately kept "dumb and cheap," and the intelligence happens at read time—retrieval and reranking occur when a query needs focus.

Main capabilities:

• Local writes: messages are embedded locally and then stored, at about 10ms per message, with zero LLM calls and zero network calls; embeddings are deterministic, so the same text always yields the same vector, meaning replaying logs can exactly reproduce storage (IDs and timestamps are generated per write; two independent writes of the same conversation are consistent in content and vectors, though record IDs may not be consistent).
• Reads: exact cosine search within a tenant scope (no need to build or update an ANN index), with an optional local cross-encoder reranker.
• Dual temporal layer (optional): records the "domain time" of each fact, that is, the moment it became true in the world, rather than the moment it was written, so point-in-time questions can be answered even if facts arrive out of order. The project claims that on the TempBelief benchmark it answers as-of queries at 0.870 versus Mem0's 0.676, with knowledge graph precision 0.97 and recall 0.96; it also notes that TempBelief is synthetic text with explicit dates, and the gap narrows on natural spoken language.
• Memory firewall (genome.firewall): tags the source of each write (user, agent, tool, web), isolates low-trust sources so they are not recalled, and enforces source-bound permissions—web content can never UPDATE or DELETE what the user has said, even if a prompt-injected conflict resolver requests it; the write path has no LLM, so there is no extraction step for injected content to attack.
• Explainable recall (genome.explain): explain_search() reports each candidate's dense score, BM25 ranking, fusion score, and the exact reason when it is not returned (filtered by parent, quarantined, over the limit). Two runs produce consistent results, and recall bugs can be written as regression tests.
• Journaling and replay (genome.journal): records every change and provably reproduces storage—verify_journal() replays history and compares canonical hashes. A replayable prefix enables rollback, and replaying to a different store derives a "what-if" branch. Each line chains to the previous line, so even if a line is deleted or modified and the final state looks the same, it can be detected. Tamper-evident by default; passing a key (kept outside the journal directory) makes it tamper-proof (a chain without a key can be recomputed by anyone with write access, an HMAC chain cannot).
• Multi-agent belief attribution (record_fact(..., believed_by="agent-a")): agents sharing storage each keep their own belief timeline, and agent B's disagreement does not overwrite A's fact; belief_conflicts() surfaces disagreements so they can be resolved deliberately, rather than silently picking a winner.
• Neutral benchmarking framework (benchmarks/neutral/): runs GENOME, Mem0, and a full-context baseline through the same responder, judge, and embedder, with a paired McNemar matrix and a full disclosure block.

Usage:

• The MCP installation command given in the docs: pip install 'genome-memory[mcp]', or the zero-install uv approach: { "command": "uvx", "args": ["--from", "genome-memory[mcp]", "genome-mcp"] }. The tools available to the agent: remember, recall, forget, reset_memories. Memories persist in ~/.genome/memories.db.
• HTTP API: comes with a FastAPI server that mirrors the library's add/search/get/update/delete/reset/synthesize interfaces, and automatically generates an OpenAPI spec at /docs. Secure by default: refuses unauthenticated serving unless explicitly opted in; without a key it will not bind to a non-loopback interface. The API Key is sent as X-API-KeyRequired when sending and binding outside localhost. For multi-tenant deployments, GENOME_REQUIRE_SCOPE=1 can be set to require user_id/agent_id on every call and disable global reset. Docker: docker-compose up (requires GENOME_API_KEY and POSTGRES_PASSWORD; Postgres is published only on loopback).
• TypeScript/JavaScript client: @northtek/genome-memory corresponds to this server and mirrors the Python Memory API shape (ESM, Node 20+ or browser).
• The Python library API mirrors Mem0's add/search/get/delete/reset and is close to a drop-in replacement; optional OpenAI embeddings (set OPENAI_API_KEY).

Use cases: compliance/regulated environments, local or fully offline deployments, scenarios requiring auditable records and point-in-time reconstruction, scenarios where multiple agents share memory but need to retain their own beliefs, and scenarios where you want budget control over memory write costs.

Limitations and honest disclosure: accuracy is on par with Mem0, and the project does not claim to surpass it; the accuracy gain from reranking depends on the embedder (it reliably improves retrieval hit rate, but its impact on final answer accuracy varies by embedder); hybrid retrieval (BM25 + dense) is lower than pure dense on LoCoMo; graph retrieval is unverified here; synthesis/consolidation is neutral for accuracy under an equal token budget (p=0.86). The default embedder is local sentence-transformers/all-MiniLM-L6-v2, which downloads about 90MB of model on first run; the core dependencies are numpy, sentence-transformers, scikit-learn, and rank-bm25, and local embedding runs on PyTorch, so the installation size is not small; this is a deliberate tradeoff for offline zero-cost embedding. The project also offers a commercial edition, GENOME Enterprise (self-hosted, licensed per deployment, no hosted version), aimed at regulated and on-premises buyers, providing tamper-evident hash-chain audit records, point-in-time reconstruction, compliance reports, retention policies with erasure proof, RBAC, and SSO, but more details such as its price are not provided in the user profile.