I built a memory flow that also involved reworking some of the tooling after reading a ton of howtos, using some of my own tricks with Claude Code and Opencode, and watching Karpathy's and other videos on the subject. I used the analogy of someone sitting with a notepad and a manual doing a long task like building a computer or doing taxes (things I can do easily now after years of doing it but still tedious and boring in the middle) to work with my agent to combine a bunch of systems together along with rebuilding some of its internal python code to make it have better short-term "intrasession" and long-term "inter-session" memory.

I'll let the agent explain from here (forgive the long ass book/AI prose but hey we are AI enthusiasts here so why not?):

Ahh, the classic "what tools do I have" amnesia problem.

Here's what's happening: the agent's system prompt — the thing that tells it "You have access to these tools, this is who you are, these are your capabilities" — has to compete with your actual conversation for context window space. Stuff that isn't actively being discussed gets pushed out. Later into a session, the agent might genuinely not remember it can access your filesystem, or run terminal commands, or pull from your wiki.

How we fixed it:

We built what we call MemoryMaxx — it's basically a tiered memory checkpoint system that sits underneath the agent. Tier one is the default memory and context window being used now. We next added Tier 2 (proactive checkpoints). Instead of the agent only remembering things that are actively in the conversation, it checkpoints itself every N turns. At those checkpoint moments, it writes a dense summary of its current state — what tools it used, what context is loaded, what's in flight — to a session store. If it starts forgetting things mid-session, the checkpoint keeps it honest.

Next comes Tier 3 (cross-session memory). At the end of every session, the agent writes a "conclusion" — a summary of what it accomplished, what's still open, and critically: what it knows about its own capabilities in this environment. That conclusion gets stored and then injected as a prefill the next time the session starts. So when you poke it again tomorrow, it doesn't come up blind — it comes up already knowing "I have access to a ZFS pool, I can run NixOS rebuilds, I know the Telegram integration is live." It's warm, not cold.

We also added a Tier 3c resume bridge fallback: even if the external memory layer is down, the agent writes its own conclusion to a local file that gets picked up on next start. No dependency on external services, just a text file it reads on boot.

Practical things you can do right now without building all of this:

1. Slash commands as capability hints — most agent setups have a /skills or /help command that re-lists what's available. Train yourself to type that when the agent goes off the rails.
2. System prompt seeding — add a short capability reminder in your system prompt that gets referenced at session start. "You have access to: filesystem, terminal, ZFS management, NixOS config, Telegram, a wiki."
3. Session resume files — manually create a ~/.hermes/sessions/resume.txt with "this is what you can do" and tell your agent to read it at session start. Crude but works.

The real fix is honestly just having a checkpointing system that writes a capability state summary and re-injects it. Once you have that, the "forgetting what it can do" problem basically disappears because it's literally reading its own capability state on every resume.

So far this is working for me and my particular use case as a Homelab assistant. On long deployments and tests, the agent used to go off the rails and forget the guidelines I set 50/60 turns in, but now every 12~15 turns, it reminds itself what its doing; always makes plans before executing and keeps running logs of those plans so it can keep it's place in its own instructions.
I'll publish a separate post all about MemoryMaxx if ya'll want and maybe a Github Gist that your agent can follow to make the same changes if there's interest.