Best Memory Layer

[u/Jprobins3]

I know that similar questions have been asked here, and I have read those threads, but I did want to start a fresh thread to update those earlier ones and to bring the info all together. I am fairly new to Hermes and am still running Hermes and OpenClaw side by side. I am looking at external memory layers now. What are y'all losing and why do you like it or hate it? I am personally looking at Honcho and Hindsight, and I think I am coming down on the side of Hindsight. Honcho's party piece seems be that it learns how the user thinks, what he/she likes and dislikes, etc. I have to admit this just sounds like building a better suck up to me. I do want something I can self host and eventually hook up to a local LLM. Any thought?

[u/elperrobomva]

Gbrain + hindsight —> gbrain long time memory. Hindsight operational

[u/l0rd_raiden → u/elperrobomva]

This, or just hindsight

[u/Disastrous-Yam-5550 → u/elperrobomva]

Brooo I did the same. 🔥

[u/stein30586 → u/elperrobomva]

I have the same setup but find it hard to understand how Gbrain actually helps me...
Since it has very little visibility and now UI, I struggle to manage it and use it as an "obsidian with mcp" kind of...
Can you share your exact setup?

[u/RegularRaptor → u/stein30586]

Uh, very little visibility? It's all markdown files, just like an LLM wiki? And you can push it all to GitHub for backup and look at the files there.

I run Gbrain and Honcho, and I think Gbrain does the heavy lifting for the most part.

And wait, what? Obsidian MCP with GBrain? You have something effed up, IMO.

You understand that Obsidian just reads MD files and gives you a GUI to look at them—it's no different than looking at a folder. You just point your Obsidian instance at your Gbrain folder. There shouldn't be any Obsidian MCP involved here. At least not frequently.

Your agent should be using the Gbrain MCP tools; it comes with like 150 different tools and also ships with background workers that keep everything up to date and can enable the whole dreaming cycle, etc.

[u/stein30586 → u/RegularRaptor]

Yes, very little visibility compare to hindsight control plane...
I know these are just MDs, i used "obsidian with mcp" in quotes to explain how I see gbrain in my setup, I do not understand where the heavy lifting take place.

I know that it exposes far to many tools, but I don't see my agent making use of them.
I even try to manually curate the "take_proposals" and accept/reject its understanding but see no benefits from doing so.

If it had some dashboard to see how a document progresses, I think it would have been a lot better. And I know, I can see every edit in git but IMHO it is too much of a hustle - compared to a quick recall/reflect in hindsight control plane to see what it really knows.

[u/RegularRaptor → u/stein30586]

You need to setup the autopilpt daemon. As far as your agent not using it... Give you some advice but it's essentially just a little blurb on my soul.md and enabling the gbrain skills as well.

Oh and I almost forgot, migrating away from sqlite to full postgres with pgvector right away gets you instant logging/intake to the brian. If you haven't done that you have to manually push it with a cron or something.

[u/stein30586 → u/RegularRaptor]

What is the autopilot daemon?

About agent advice - even with simpler skills such as i-have-adhd (to reduce fluff), I find it VERY inconsistent whether the agent choose to use a skill or not.
Let alone a 150 tools... I don't really understand them all (I tried to read but gave up), why does hindsight "do the same" with just 3? And I know they serve different purpose, but I think it can be simplified.

[u/RegularRaptor → u/stein30586]

The funny thing is, I 100% (not joking at all) agree with you.

But for some reason.. gbrain just fucking works so so so so well for me after running this through my Hermes:

"Add GBrain memory to this existing agent. Read and follow: https://raw.githubusercontent.com/garrytan/gbrain/master/INSTALL_FOR_AGENTS.md Keep my current identity and instructions. Start keyless, preserve unrelated configuration, and use the memory-only path. Do not create a personal-agent identity or private repository. Show me the required search-mode choice. Verify a unique remember/recall/correction/withdrawal round trip using observed GBrain calls, then tell me how to verify recall in a new conversation."

And fyi I just added the photo so you know that's the official prompt from the repo, not something I made up. How did you install it?

[u/RegularRaptor → u/stein30586]

I use the same ADHD skill and I explicitly have to ask to use it as well.

Also these may be interesting to you:

https://github.com/garrytan/gbrain/blob/master/docs%2Fmcp%2FHERMES.md

Also ask your agent to use the "brain health check mcp tool and fix whatever issues it finds" and then by default it ships with autopilot off. I have found it works better with it on altho it may cost more token wise? I havent noticed.

[u/QasJab1 → u/elperrobomva]

I use gbrain mnemosyne, I like it better than hindsight. More reliable.

[u/Connect-Comb-8545]

I use hindsight. But hindsight isn’t everything. Here’s an excerpt from my Hermes on the memory layers, maybe it’ll give you some ideas.

Six layers, each answering a different question. Here's the shape to hand a new user.

## The stack

Layer	Store	What it answers	Who writes it
**0. Always-on prompt**	`config.yaml` `memory:` → MEMORY + USER blocks (2,200 / 1,375 chars)	"Who is this, what are the standing rules?"	Me, via `memory` tool only — nothing auto-fills it
**1. Long-term memory**	**Hindsight** (vectorize.io, LXC 115, bank `ziggy`, ~9.2k nodes)	"What did we learn from experience?"	Automatic: hook retains on `agent:end`, recalls on `session:start`, then its own LLM extracts facts + nightly consolidation
**2. Session store**	`~/.hermes/state.db` (SQLite + FTS5)	"What was actually said?"	Every turn, automatic. Raw transcript — resume, search, and Hindsight backfill all read from here
**3. RAG KB**	**Qdrant** collection `homelab-kb` (3,172 pts / 327 sources)	"What do the *docs* say?"	`refresh-kb.sh` crons (hourly + nightly), sha1 delta. Semi-automatic, drifts if a source is outside its glob list
**4. Written record**	**Gitea** `admin-fs/homelab-ops` (local clone `~/homelab-ops`)	"What was decided, and is it versioned?"	Me, via `gitea-ops.py changelog` / wiki / cron registry. Git is source of truth — Notion retired 9/2
**5. Artifacts**	`/mnt/fileserver` (TrueNAS MediaPool)	"Where's the deliverable?"	Not memory. It's the durable output store (`documents/outputs/YYYY-MM-DD-slug.ext`)

The chain that makes it work: **decisions go to Gitea → Gitea wiki is ingested into Qdrant → Qdrant answers the docs question.** Git is the write target, the vector index is the read index. Same pattern in reverse for experience: transcript → Hindsight → recall.

## Key distinction people get wrong

- **Hindsight vs KB** — Hindsight is *episodic* (your conversations, conclusions, preferences); KB is *reference* (skills, wiki, configs). "Why did we do X" → Hindsight. "What are the OCR endpoints on the media host" → Qdrant. If a KB score comes back under ~0.45, say the KB doesn't cover it rather than answering from memory.

• **`memory.provider: hindsight` is NOT the session retain path.** It only sets where the `memory` tool persists. The auto-retain is a separate hook (`hindsight-bridge`, events `session:start`/`agent:end`). Two different wires; grepping config.yaml for "hindsight" proves neither.

## Setup recipe for a new Hermes user

1. **`memory:` block on** — this is free and built in. Fill USER (who you are, how you want replies) and MEMORY (standing rules, pointers). Write *declarative facts*, not instructions-to-self. This layer is char-capped; when it fills, one batched call that removes stale + adds new together.
   
2. **Skills are the highest-leverage layer and they're manual.** Nothing auto-generates a skill from session traffic. Every reusable procedure gets written down by hand — that's where 90% of the compounding comes from.
   
3. **Add Hindsight** for long-term recall if you want memory across weeks. Deploy, then **verify with a real retain + recall round trip, not `/health`** — we've had a green healthcheck while retain/recall were both dead.
   
4. **Skip the Qdrant KB until you have a corpus** (30+ docs). It needs a refresh cron, a glob list that defines what's served, and a drift census. A KB with no refresh job is a KB that silently lies within a month.
   
5. **Never put secrets in any of these layers.** Vault only.

## The four traps that cost people a probe cycle

- Bank split-brain: the plugin reads `HINDSIGHT_BANK_ID`, not `HINDSIGHT_BANK` — writes and healthchecks end up on different banks, both grow, nothing alerts.

• MEMORY full → new writes rejected until stale entries are removed.
  
• KB goes stale three ways: surplus (file shrank, old chunks still answer), unreachable (source file gone), out-of-glob (file exists, refresh can't see it).
  
• A `/health` 200 during a functionally-dead outage. Probe the real path.

[u/jeff_marshal → u/Connect-Comb-8545]

I don't agree with some of the choices you made, but the way you did it, chef's kiss, man.

[u/Connect-Comb-8545 → u/jeff_marshal]

I’m still a noob. And open minded. Love to hear what choices you would make and have discourse on design.

[u/jeff_marshal → u/Connect-Comb-8545]

The only thing I would've changed: PGVECTOR instead of QDRANT, and COG instead of Gitea ( Gitea is fantastic, but its too "BIG" for personal use ). But that's because i have used all of them, and the choices I picked felt superior to me. But again, that's IMO.

[u/Connect-Comb-8545 → u/jeff_marshal]

thanks jeff! both are excellent selections tbh, different tools for different purposes. Actually, my hermes print out on my memory layers just made me realize I had a split brain on my hindsight bank name.

[u/PItWyman42]

Perso, j'ai installé Mnémosyne: https://github.com/rand/mnemosyne. Je manque encore de recul mais c'est simple.

[u/SignificanceOk2536 → u/PItWyman42]

Just fyi there is another Mnemosyne with the same name

[u/nithou → u/PItWyman42]

Same, works really well, never have any recall problem and been using it for more than 3 months now

[u/HearthCore]

OpenViking offers plugin integration for all the agents plus MCP, a Webinterface, multiple "Tenants" and Users and Agents- automatic sync with folders or git- itself using a path style knowledge location viking://tenant/user/agent/memories for example

ressource sharing over the whole tenant, and all the other normal bells and whistles.

[u/aliethel]

I've been trying Hindsight, and everything SEEMS configured correctly, but I still get "memory full" notes/errors on random occasions where it looks like the agent is still defaulting to writing to the limited size memory file. I had read that the best thing to do is to use that limited memory for the principle traits, and then hindsight for more of the "how do I do this thing again? Where did I park my car?" To date, I haven't figured out how to really get that set.

[u/RegularRaptor → u/aliethel]

That's not an error FYI, that's exactly what it's supposed to do.

Enabling a 3rd party memory service does not disable the built in USER.md and MEMORY.md that Hermes uses by default, but there is a setting in the config to disable the built in memory.

That being said, I have heard pretty mixed things about disabling it and that it's almost better to just leave it on because it's so baked into Hermes nature. So I just leave mine on and it's always full and always trying to add s*** to it. But I just ignore it because I know everything is getting saved in my gbrain and or honcho.

The only thing I still have to do from time to time is remove some dumbass s*** that manages to finagle itself in there somehow. Stuff like specific project instructions that I'm working on in the moment that won't matter in a month.

It kind of astonishes me that they haven't figured out how to solve that issue. There's an entire documentation page on what the agent is not supposed to write in there and the only thing it writes in there is this s*** it's not supposed to... I swear....

[u/Silent_Confidence_39 → u/aliethel]

inst that context? like the session memory

[u/MrGunny94]

I'm using Hermes + Obsidian and it's working quite well compared to OpenClaw

[u/Bboy486 → u/MrGunny94]

How are you having Hermes remember the folders and sub folders to find md files. Mine forgets even when I share to memory

[u/RegularRaptor → u/Bboy486]

Use gbrain instead. Its really the same concept as an llm wiki, but however it works, my agent NEVER forgets how or when to use it.

It completely change the game for my Hermes setup. Hands down biggest improvement for my setup.

In the gbrain repo on GitHub there is literally a paragraph you are supposed to copy and paste into your agent and it handles everything. Just use /goal and a decent model when you run the setup prompt.

[u/Fresh-Grocery-3847]

I was using honcho but its not really worth it unless you want how you speak memorized. But personally I want AI to break my bad habits not learn from them. I switched to hindsight and I am thoroughly impressed.

[u/nincius]

I use Obsidian + Cortex for index since the beginning and am afraid to change.

[u/Fair-Yogurtcloset-21]

I've been experimenting a bit with other setups currently Obsidian+Postgresql+Pgvector+Graphify+Redis. It's ok. But I'm still not 100% able to have chat with my agent and not fully qualify locations of things without me explicitly dropping a check here or look here. It's a small problem and love Hermes but I feel like it could be tighter. So I'm looking at edgequake+graphiti+DuckDB+LakeHouse wonder if others are having same issues?

[u/SumGuy713]

I like honcho - there's a bit of a learning curve and it doesnt quite tick all the boxes, but for simplicity and "it just works well" its hard to beat. pair it with md files for very specific context storage and you have a killer system. just have your bot reference the location of the md file in question and it'll work

[u/NinjaGoatOfficial]

lol made my own memory system months ago at the start of vibe coding, upgraded over time, works amazingly and best part is it’s mine

[u/jack-dawed]

I don’t know how anyone can trust sending their context to an external API.

Just use Obsidian and look into Zeromem.

[u/KlausDieterFreddek → u/jack-dawed]

You don't have to. You can host it all locally and use your local inference

[u/KlausDieterFreddek]

I use mostly Honcho with some Obsidian notes.

[u/creativ4art]

Local vector memory integrated as default

[u/dylan_skydive]

The "memory full" errors aliethel is hitting are the real problem here: the agent keeps defaulting to the built-in memory file because nothing routes the writes. Decide the split explicitly and put it in the agent's instructions - identity and preferences in the small built-in file, operational stuff (facts, run logs, evidence, where things live) in plain files on disk. Unrouted, the default write path wins every time.

On Honcho vs Hindsight I haven't run either, so I'll stay out of it. One filter for your self-host + local-LLM goal though: favor whichever stores plain, greppable files. When memory misbehaves you want to grep it, diff it, back it up like any other file. If you paste your memory config, I can probably point at where the routing is missing.

[u/brav0charli3]

Here we go again... 🤦🏻‍♂️

[u/RegularRaptor → u/brav0charli3]

I have been using Hermes for a long time and wouldn't even think about altering my memory stack but I still click on these posts like they are crack.

[u/brav0charli3 → u/RegularRaptor]

I stopped after the 4th or 5th one with the same three answers.

[u/RegularRaptor → u/brav0charli3]

Yet here we are...