Show HN: Hmem v2 – Persistent hierarchical memory for AI agents (MCP) (github.com)

Some core features worth calling out:

  5-level lazy loading instead of flat RAG. On spawn, agents receive only L1 — one-line summaries of every memory entry.
   When something looks relevant, they drill into L2, L3, etc. on demand. This keeps startup context small (~2k tokens
  for 200 entries) while still having full verbatim detail available at L5.

  Tab indentation maps directly to tree levels. No schema to think about — just write:

  write_memory(prefix="L", content="Always restart MCP server after recompiling TS
      Running process holds old dist — tool calls return stale results
      Fix: kill $(pgrep -f mcp-server)")

  Indented lines become children. Siblings at the same depth are siblings in the tree. append_memory adds children to
  any existing node without overwriting.

  Smart bulk-read selection. Not all L1 entries are shown equally. The V2 selection expands (shows children) for: newest
   N entries per prefix, most-accessed M entries (time-weighted score), and all favorites. Everything else shows as a
  compact title with a [+7 →] hint. This mirrors how human working memory works — recent and frequently-used things are
  immediately accessible.

  Obsolete, not deleted. When a lesson turns out wrong or a decision gets reversed, you mark it obsolete with a
  correction reference ([E0076]). The old entry gets hidden from bulk reads but stays searchable. Past mistakes still
  teach — you just don't pay tokens for them every session.

  Per-agent isolation + optional shared store. Each agent has its own .hmem SQLite file. There's also a company.hmem
  with role-based access control (worker/al/pl/ceo) for knowledge that should be shared across agents.

  The whole thing is a single MCP server, ~3k lines of TypeScript, backed by SQLite with WAL mode. No vector embeddings,
   no external services. Works offline.

OpenClaw users: you can integrate hmem directly by pointing your Claw at the GitHub repo — it'll figure out the rest. npx hmem-mcp init gets you running in under a minute.

hit this building agent systems - context gone on restart. Built a dedicated memory layer for agent workloads, in-process, survives restarts via WAL recovery. Happy to share: https://github.com/RYJOX-Technologies/Synrix-Memory-Engine

Nice work on the hierarchy approach. The 5-level lazy loading is clever for keeping context small.

We took a different path with Remembra - hybrid search (vector + BM25 keyword) instead of hierarchical summaries. The tradeoff: you lose the explicit levels but gain better fuzzy matching when agents don't remember exact terms.

Entity extraction has been the bigger win for us - automatically linking "Mr. Kim" to "David Kim" without the agent needing to know they're the same person. Hit 100% on the LoCoMo benchmark with that.

Curious about the no-vector-embeddings choice. Does full-text search miss anything in practice when agents use different phrasing across sessions?

Self-host: docker run -d -p 8787:8787 remembra/remembra if anyone wants to compare: remembra.dev

Interesting approach with the hierarchy. I went the opposite direction with engram-mcp — flat structure, 5 tools, semantic search via Ollama (nomic-embed-text) with keyword fallback when Ollama isn't running. SQLite-backed. The bet is that most agents don't need tiered recall, they just need "find the thing I said about X." npx -y @cartisien/engram-mcp if you want to try it.

Curious how the L0/L1 hierarchy plays out in practice - do agents actually use the deeper levels?