u/desexmachina

Just curious if there’s a coffee shop or co-work where the self-proclaimed cool devs congregate

If you've been playing with Claude Desktop + MCP servers, you've probably noticed something. Claude can call tools. Those tools can fetch data. But none of them remember anything between sessions.

The MCP protocol defines how agents talk to resources. It doesn't define how those resources persist state. So every time you restart Claude Desktop, your custom MCP tools are starting fresh. The agent learned your repo structure? Gone. It figured out your naming conventions? Gone.

HeurChain is basically the missing persistence layer. It's an MCP-native memory service. Any agent that speaks MCP gets structured memory for free, no SDK, no proprietary format.

How it works: agents read and write memory through standard MCP tool calls. The memory itself is tiered. Hot stuff in Redis, warm stuff searchable by vector similarity, cold stuff archived. The router decides what lives where.

50K+ writes so far. Multi-agent clusters can even share the same memory graph.

https://www.npmjs.com/package/heurchain it is a free tool

What are you using for state persistence right now? Or are you just accepting the amnesia?

Every time I restarted my agent or spun up a new session, the context was gone. No recall of previous conversations, no learned preferences, no project state. Just... blank.

So I built HeurChain — a memory broker that sits between your agents and long-term storage.

What it does:

Agent-isolated memory — each agent gets its own namespace. Agent A can't see Agent B's memory.,

Survives restarts — memory persists to disk/DB. Kill the process, restart, memory is still there.,

LLM-agnostic — works with Claude, GPT, local models. The broker handles the storage layer.,

Structured + semantic — stores both key-value facts and vector embeddings. Query by key or by meaning.,

The architecture is pretty simple: agents write to the broker via a thin client library. The broker handles deduplication, compression, and persistence. On restart, agents request their memory back.

What I learned:

Most memory systems are either per-session (context window) or global (shared RAG). The middle ground — agent-specific persistence — is underserved.,

Deduplication is tricky when agents rephrase the same fact differently. I use both hash-based matching and semantic similarity.,

Local model users want local-only. The broker can run entirely on-prem.,

Would love feedback from anyone who's built agent memory systems. What tradeoffs did you hit?

The issue: Most memory implementations are agent-specific and don't survive agent recreation or handle sub-agent sessions.

Heurchain gives you:
✓ Universal integration (Hermes + Openclaw + any other agent framework)
✓ Persistent memory across agent lifecycle
✓ Automatic sub-agent session isolation
✓ Drop-in installation

npm i heurchain | Docs: https://www.npmjs.com/package/heurchain

Open to PRs and feature requests.

So I built heurchain—a memory layer that:
- Works seamlessly with Hermes and any other agents in your stack
- Persists across agent creation/destruction (no more memory amnesia)
- Gives each sub-agent its own session tracking automatically
- Integrates in ~5 lines of code

npm i heurchain
https://www.npmjs.com/package/heurchain

Would love feedback from anyone working with multi-agent systems.

The issue: Most memory implementations are agent-specific and don't survive agent recreation or handle sub-agent sessions.

Heurchain gives you:
✓ Universal integration (Openclaw + any other agent framework)
✓ Persistent memory across agent lifecycle
✓ Automatic sub-agent session isolation
✓ Drop-in installation

npm i heurchain | Docs: https://www.npmjs.com/package/heurchain

Open to PRs and feature requests.

I built a memory system that integrates well with Openclaw and all your other agent instances in your system at the same time. It will persist even if you create new agents and gives sub-agents their own session tracking.

https://www.npmjs.com/package/heurchain

npm i heurchain

https://preview.redd.it/viz01j5gcmyg1.png?width=374&format=png&auto=webp&s=e6b23372a181440ac0056228fdfa0d2bfae1f8bd

I built a memory system that integrates well with Hermes and all other agents in your system at the same time. It will persist even if you create new agents and gives sub-agents their own session tracking.

https://www.npmjs.com/package/heurchain

npm i heurchain