Speaker A
So, to me, this is pretty wild that not only are we able to get the agent to remember things, but it's able to build this graph based on our memory in a way that improves the agent on the problems
Learn how to give AI agents true memory using Hermes with built-in and external memory providers like Nemesis and Hindsight.
Ask about this video. Answers come from its transcript only — with the timestamp, so you can check them.
Generated from the transcript and can be wrong — check the timestamp.
Key Takeaways
- Agentic memory is a multi-layered stack combining world knowledge, built-in memory, and external memory providers.
- Built-in memory is good for simple sessions, but external memory providers improve performance and scalability for complex projects.
- Nemesis is a fast, lightweight local memory layer requiring no dependencies, ideal for quick setups.
- Hindsight is a powerful memory engine with advanced features but requires cloud or server infrastructure.
- Choosing the right memory provider depends on your goals, hardware, and whether you prefer free or paid solutions.
What the video covers
- The video explains the concept of agentic memory as a stack consisting of world knowledge, built-in memory, and external memory providers.
- It compares built-in memory in Hermes, which includes files like memory.md and user.md, to dedicated external memory providers that optimize token usage.
- The presenter introduces two popular memory providers: Nemesis, a lightweight local system, and Hindsight, a more feature-rich memory engine requiring cloud or server resources.
- Nemesis runs fully locally with zero dependencies and uses a SQLite backend, making it fast and easy to install.
- Hindsight offers advanced features and ranks highly in benchmarks but needs cloud connectivity or a local server with an LLM.
- The video covers installation steps and configuration tips for both Nemesis and Hindsight memory providers.
- It highlights the importance of keeping built-in memory lean to avoid wasting tokens and improve agent recall.
- The presenter also discusses the relationship between agentic memory and knowledge layers like Obsidian LLM Wiki.
- Future videos will explore integrating Obsidian as a complementary knowledge layer to agent memory.
- The video encourages viewers to like, subscribe, and join memberships for more insights on agentic AI and knowledge management.
Chapters
- 00:00Introduction to Agentic Memory and Its Benefits
- 01:36Understanding the Memory Stack: World Knowledge vs Operational Memory
- 03:22Built-in Memory in Hermes: Files and Session Search
- 04:48Choosing a Memory Provider: Considerations and Options
- 06:34Overview of Nemesis: Lightweight Local Memory Layer
- 08:08Installing and Configuring Nemesis Memory Provider
- 11:38Introduction to Hindsight: Advanced Memory Engine
- 19:47Setting up Hindsight with Docker and Local Models
- 24:21Using Memory Providers in Practice and Final Thoughts
- 26:05Conclusion and Next Steps with Agentic Memory
Full Transcript — Download SRT & Markdown
Speaker A
I'm trying to solve. Have you ever been frustrated that your AI just forgets things? You explain the same context over and over again, wasting tokens and time. And if you're running multiple agents, it gets even worse because you
Speaker A
have to share context just to keep them on the same page. That's because you're not using a real memory system, or at least not a very good one. Let's fix that. Hi, my name is Callum, also known as Waterlitz, and welcome to today's
Speaker A
video on giving your agent true memory. Today, I'm using Hermes agent as an example, but the memory tools I talk about apply to any different agentic AI.
Speaker A
And more importantly, they work between any AI agents. You can set this system up once and then connect it to any agent with the same universal memory. If you're new to Hermes and want to get it set up safely, I have a full agentic AI
Speaker A
playlist here. By the end of this video, you'll understand the different tiers of the memory stack and how agentic memory compares to a knowledge layer like Obsidian LLM Wiki. Why you might want a dedicated memory provider instead of
Speaker A
using built-in memory, the different memory options and why I picked the two we're setting up today, how to install an unofficial lightweight memory layer, and how to install an official heavyweight memory engine. I'm personally very excited because memory
Speaker A
is something I've been looking at for a long time, and I can't wait to help you get it set up today. Now, let's take a look at agentic memory.
Speaker A
Before we get anything installed, I just want to quickly clear up some common confusions on agentic memory. It's not a layer, it's a stack. When people say second brain or agentic memory, they're actually referring to three things: world knowledge, built-in memory, and
Speaker A
external memory. The knowledge layer like Obsidian vaults or an LLM Wiki is part of the memory stack, but it's not true operational memory the way we mean it when we say agent memory. It's world knowledge, the ground truth across every
Speaker A
project and every agent. You can even limit the access your agent has to this knowledge layer, like I talked more about in connecting agentic AI to Obsidian here. Then we have operational memory, which splits into two tiers, built-in memory and dedicated memory
Speaker A
providers. Operational memory focuses more on what the agent should remember about working with me specifically. A simple test is to consider if it's knowledge you want preserved and organized across everything you do, that's Obsidian. If it's a fact about
Speaker A
how you like to work or what you're working on right now, that's agentic memory. So, putting it all together, we have built-in memory, which is great for simple single session chats, a memory provider when you're running complex ongoing projects or you just want
Speaker A
noticeably better performance and agent recall, and your knowledge layer, like Obsidian, for building world knowledge that spans every project and every agent you run. I talked more about getting Obsidian connected to agentic AI in this video here. So, today I want to focus
Speaker A
more specifically on the first two layers, on the built-in memory and the external memory provider. My next video is going to go deeper into setting up an Obsidian LLM wiki that complements the agent memory we're setting up today.
Speaker A
Let's start by comparing the built-in memory to true memory providers. If you find this video helpful, please like, hype, and subscribe as I appreciate your support a lot. If you're looking for more ways to support me, please consider
Speaker A
joining my YouTube or my Patreon membership, where I give my members access to tips, insights, and my thoughts on the future of agentic AI and knowledge management.
Speaker A
So, what does built-in memory actually look like for Hermes? It has three files, memory.md, which is your operational memory, user.md, which is who you are, and soul.md, which is technically not memory but the agent's own personality. On top of that, the
Speaker A
built-in memory includes session search, stored in a local database, so you can literally ask Hermes to search across your past sessions. As a quick tip, the best way to get going with an agent like Hermes is to tell Hermes about yourself
Speaker A
right off the bat. If it understands a little bit more about who you are and how you like to work, the whole system gets so much smarter almost immediately.
Speaker A
One question I get a lot about running the built-in memory is if you're using Hermes terminal execution back end, you're running the code in something like Docker, can Hermes still access the memory? And the answer is yes, it can.
Speaker A
Running in Docker doesn't impact Hermes' ability to access its own memory and user files. That's done using a memory tool, which is the same thing that the memory providers use, rather than running through code that ends up being
Speaker A
sandboxed in Docker. I talked more about that in my how to get your agent isolated and operating more safely on your computer. The key is that the built-in user and memory files get injected into every new session. It
Speaker A
becomes part of the context of every chat you have with Hermes. Now, this is great because it means that your agent never forgets who you are, but it also means that it's using up some of the context and tokens for every single
Speaker A
chat. You want to keep this as lean as possible, so you're not wasting tokens.
Speaker A
And that's where having an actual memory provider comes in. A memory provider is an external layer that stores and retrieves facts at runtime or when the agent actually needs it, rather than inserting it into every conversation.
Speaker A
This helps keep your context lean and your facts on point for when you actually need them. Let's take a deeper look into memory providers.
Speaker A
A lot of people feel overwhelmed when trying to pick a memory provider, and that's fair. There's a lot of options and things to consider. It depends on your goals, how many agents or people are accessing that shared memory, what
Speaker A
hardware you have available to run it, and whether you want to use free or paid tools. The good news is that most, if not all of them, allow you to migrate between each other, so you're not locked into one that you pick up front. You can
Speaker A
test and experiment, and if you don't like one tool, you can always migrate your memories to another one. But rather than comparing them all in this video, which would take a while, I put together my analysis free Patreon post that I'll
Speaker A
link in the top comment of the video, so you can take a look at the different options and see what works best for your scenario. But today, rather than going off of benchmarks or feature lists, I thought I would take a look at what the
Speaker A
community has been rating the most highly and what many people have recommended to me. And they are Nemesis and Hindsight. Nemesis is a zero-dependency lightweight system and doesn't require an LLM to work. It runs fully locally, incredibly fast with
Speaker A
built-in embeddings. Nemesis is great if you want a memory provider that doesn't slow your system down. Hindsight has more features and it ranks at or near the top of most memory benchmarks, but it either needs a cloud connection or
Speaker A
your own server plus an LLM to actually power it. The simplest way to think of it is Nemesis is a memory layer, Hindsight is a memory engine. So, let's start with the lightweight option of Nemesis so you can see a memory
Speaker A
provider in action before we move on to a little more power with Hindsight. So, we can think of Nemesis as a universal memory layer for any AI agent running a SQLite backend with sub-millisecond zero dependencies. So, the purpose of showing you this one
Speaker A
first is that it is very fast and it doesn't require you to install a lot of other things. So, a little bit more about Nemesis is that it's biologically inspired by the BEAM architecture, which brings in different memo
Speaker A
working, episodic, semantic, and a scratchpad where each one is optimized for different access patterns.
Speaker A
Everything stays local, which is good for privacy. It has sub-100 millisecond queries and it has native Hermes integration.
Speaker A
Let's take a look at the architecture for a moment. So, the key is that we're building auto context injection, which basically means that when you have a query, when you ask Hermes something, Nomasyne will receive that query, use a
Speaker A
recall tool to go take a look at its existing context, and inject that context into the agent's prompts before it responds to you. As you continue having conversations, it's going to remember more, which is going to get fed
Speaker A
back into Nomasyne to help it build this context assembly. So, this is just one great way to continue building out a self-evolving memory system for your agent. And like we can see, it can be used for Claude code, for Codex, it can
Speaker A
be used for Cursor, it can be used for any agent that you want, and we can have all of them connect to the same memory bank if we want to. All right, so let's get Nomasyne set up.
Speaker A
So, if we go to their docs here, we can see that they have Hermes agent integration and it gives a list of quick commands here, so it's pretty easy to install. And one thing I want to mention just very quickly is that if you're
Speaker A
running Hermes and you have your terminal execution back end running in Docker, we can't just give Hermes the task of setting up Mnemosyne for us because Hermes would try and run its terminal, and it would run inside of a
Speaker A
Docker container here, and that's not what we need because we need our memory system to survive outside of the terminal back end Docker container. If you're not running inside a Docker, you can just ask Hermes to do it, but
Speaker A
basically this just means that we need to run it from our host device inside of our computer. So, I'm going to install it directly from terminal myself.
Speaker A
Mnemosyne is not a built-in provider, so we need to install Mnemosyne a little bit more manually. But the key here is that we're not installing it inside of Hermes managed virtual environment because every time you run Hermes update, it rebuilds that virtual
Speaker A
environment, and then it wipes any extra packages. So, we have two options that are listed here. We can use pipx, which creates a separate virtual environment, or we can manually create a virtual environment using the fallback option.
Speaker A
However, neither of these options worked perfectly for me. So, if you install Mnemosyne and you run Hermes memory status and you get a plugin missing error, or when you first install it, the Python environments don't match error, you might need to add another step in
Speaker A
between. So, the first step is going to be to install Mnemosyne Hermes into its own pipx environment, then set the config.
Speaker A
So, these two steps are the same, but then before we restart the gateway, we need to link the new environment that we just created into the Hermes plugins folder, and then we need to run what's called the Hermes memory setup. That's
Speaker A
just a very easy way that you can run it inside of terminal, and it will go through and configure Mnemosyne for you so that it gets recognized as a memory provider instead of just as a plugin.
Speaker A
So, let's get started. Okay, so I'm going to go to the documentation. I'm going to copy the install. I'm going to go to my terminal and paste this in.
Speaker A
Great, there we go. That took less than a minute. So, we now have Mnemosyne Hermes set up. Now, if we go over to memory and context, we can see that we currently have the default memory system enabled, and this is the built-in memory
Speaker A
provider. But, we can see here, if we click the drop-down, we don't have access to Mnemosyne inside of here.
Speaker A
That's because it's a plugin, it's not a built-in memory provider. So, we need to enable that for our default profile outside of the settings of the desktop app. So, let's do that for a moment. So, I'm going to go back to the docs here,
Speaker A
copy this string, paste it in. Great, there we go. That just took 2 seconds.
Speaker A
And basically, what just happened there is it modified the config.yaml file to use Mnemosyne as the memory provider.
Speaker A
Now, we just installed Mnemosyne into One Bin, and we want to create a symlink or a link between where we just installed it using that separate environment and the actual Hermes plugin folder right here. So, that's what we
Speaker A
can see right here. It just went through and verified that the provider of Mnemosyne is available and that it was able to connect Mnemosyne to Hermes. So, our next step is to run Hermes memory setup, and this is where we can see
Speaker A
here, we want to go to Mnemosyne local, click yes. So, now that we are running Hermes memory setup, we're going to go through step-by-step and select all of the different configurations we want for Mnemosyne as Hermes memory provider. I
Speaker A
just used the default option for everything except for being able to access global rather than session memories. But, I do recommend reading what it's asking, and if you're not sure, asking Hermes to help you understand the setup in a way that's
Speaker A
going to work best for you. The most important setting, what's the default scope for remembering? I don't want to limit it per session, I want to have it be across all sessions. That's one of the benefits of running a memory system,
Speaker A
so it's really important to switch this one to global. And there we go. So, we can see that this just went through and it saved the memory provider of Mnemosyne. So, now what we do is, if we go over to config.yaml inside of our
Speaker A
.hermes folder, there we go. We can see that we have a whole memory system here with all of these different skills and tools set up for the Mnemosyne provider.
Speaker A
So now I'm going to restart the Hermes Gateway. Going to type in Hermes memory status and we can see that the memory tools enabled, the provider is Nemesis, we have all of the configurations that we just went through so we can change
Speaker A
this later if we want. We have the plugin installed and the status is available which is key. And now we can see here if I type in Hermes Nemesis stats, everything is currently at zero because we haven't actually stored
Speaker A
anything yet. So let's get that started. I'm going to open the Hermes desktop app and if you go over to memory and context, we can see that Nemesis is now set up as the memory provider. Great. So now we have it all installed and if we
Speaker A
ever want to upgrade this, we can just type in pipx upgrade Nemesis-Hermes. One more step I want to quickly mention here is that the Nemesis documentation suggests disabling legacy memory. And basically what that means is just this persistent memory and user profile we
Speaker A
have set. The main reason is to avoid duplication and token waste. So I would suggest disabling it to start and then testing it out and if you notice a problem, you can always re-enable it.
Speaker A
But don't disable it using a command like this. Make sure you just update it inside of the config.yaml file where we can see memory enabled false, user profile enabled false, which is the same thing as toggling these buttons off
Speaker A
right here. Okay, so let's quickly test it out. If I ask Hermes a question, it shouldn't know anything about me. So previously I had told Hermes who I was, but now why don't we try it again since we have Nemesis
Speaker A
set up. So we can see here it's going and it's actually enabling the Nemesis recall skills and the canonical skill, but it doesn't have anything. So I'm going to give it a little bit about me so that it can remember it. Just as a
Speaker A
quick tip, this is always the first thing I would do when you're setting up a new memory system is give Hermes or your agent some context on who you are and what you like. That way it starts to
Speaker A
build a profile around you and the chat will start to feel more personalized and effective for what you're trying to accomplish. So my name is Callum, I go by Wander Roots, I run a YouTube channel, I'm a patent agent,
Speaker A
intellectual property lawyer. I studied mechanical materials science engineering, and this is my preference for how I like to respond. So, we can see here, now Hermes is going through and is running the Nemesis tool. It's running remember. It has professional
Speaker A
background, alias, and name. And all of these things are being stored into the database that Nemesis has set up. So, now for example, if I open a new chat and I say who am I, we should see Hermes
Speaker A
recall from Nemesis. Here we go. It pulled it in. That's awesome. That means that it is working perfectly. And now if we go back to terminal and run Hermes Nemesis stats, we can see here there's a total of four pieces of working memory
Speaker A
unconsolidated. So, this is where it's going to go through and over time it's going to shift working memory into episodic memory and then deeper into it.
Speaker A
And this is bringing in what's called the beam architecture. So, it's going to observe, it's going to take in conversation and tool results, and it's going to remember all of these things into its working memory. Then over time
Speaker A
it's going to consolidate that into its long-term experiences or its episodic memories. Every time we ask the agent something, every time there's an input, it's going to go through and pull from both of those and then recall it. So,
Speaker A
there's more details on working memory but this is a pretty cool system especially considering that it's all happening locally inside that SQLite database. And what's cool too is it's also bringing in structured knowledge stored as subject predicate object
Speaker A
triples which is the basis of a knowledge graph. And if you want to learn more about that, I do have a video on knowledge graphs and how we can use it for improving agent systems. But I highly recommend going through and just
Speaker A
exploring the beam overview so you understand a little bit more how this is all operating. This is pretty cool.
Speaker A
Remember, if we go here, we had to manually add Nemesis to this list. But there's all these built-in ones that perhaps are a little more powerful depending on what you're looking for.
Speaker A
And I'm going to work on installing hindsight today. So, I personally like the fact that Nemesis can run locally, it runs without me needing to create anything extra. It doesn't have any dependencies and it's very fast. So, I'm
Speaker A
going to leave this as my default right now, but I'm going to create a new profile and I'm going to call it hindsight and I'm going to use this to set up a separate configuration here.
Speaker A
Okay, so I'm now on the hindsight profile and if we go over to memory and context again, we can see here that I have persistent memory and user profile still turned on and the built-in memory provider is set. So, I don't have this
Speaker A
one set up to connect to Namaseni. You can see that the hindsight profile doesn't even see it here. So, what we can do is we can go over to memory provider in our settings. We can go down to hindsight and turn this on. But, just
Speaker A
before I do that, let's take a look at the hindsight website itself. So, hindsight is a native memory provider in the Hermes agent, which means it's built-in. And hindsight is a little bit different because it operates by having the agent actually connect to
Speaker A
a separate server. So, it's not something that's running within Hermes itself, but what's cool is it has a whole bunch of different ways of operating. It builds its own mental models. It pulls in observations. It has standard memories. There's a lot you can
Speaker A
do here and it can even reflect and then it's going to go through and extract more aware responses using a deeper sense of reasoning. So, when you run reflect, it runs an agentic loop that automatically searches the memory and
Speaker A
then applies that to shape its own reasoning style and then produces a final answer grounded in what it's found. So, rather than just returning raw facts, reflect is a more synthesized response, which is why it also requires an LLM. So, there's a little bit more
Speaker A
complexity here. I highly recommend exploring the hindsight documents if you want to learn a little bit more about it, but the key here is that this requires actually running a separate server or connecting to a separate server. So, if we go back to our memory
Speaker A
provider here and select hindsight, we can see that a mode appears. So, this mode we have the option to switch between cloud and local external.
Speaker A
And to understand that a little bit more, we can go specifically to the Hindsight docs on setting up for Hermes desktop specifically. And if you want to do it for the command line, there's also a separate way to get it going using the
Speaker A
Hermes memory setup like you saw we did for Namacini. So basically we just need to select Hindsight, set what mode we want. And here we have cloud which requires an API key. That's where we can connect to the Hindsight cloud. But this
Speaker A
does have a fee to it. It has you go so you can start for free and then depending on how often you're using it, depending on how big your system gets, you are going to have to start paying
Speaker A
for it. You could just run the system yourself for free on your own computer if you have the hardware to do so. But if you don't, it might be worth taking a look at Hindsight cloud to see how much
Speaker A
it costs. I personally haven't tried this yet. And today we're going to set up a local system. So take a look at this comparison here on comparing local to cloud LLMs for running your agent memory. So this is the LLM that's going
Speaker A
to power the actual system as opposed to connecting to Hindsight cloud which also deals with storage. You can just connect to an open AI Anthropic or Gemini API, but then you're going to pay per token for every time you retain it. So you can
Speaker A
run free locally on your own computer using something like Ollama which I have a video on running Ollama for agentic AI if you're interested in seeing how that works. One thing to keep in mind is that not all local models support tool
Speaker A
calling. So you have to make sure that the one you're using does. I'm going to use GPT-OSS 20 billion parameters which is 13 gigs. So make sure you have that model installed already. And also make sure that you have the Ollama app
Speaker A
running in the background or serve it yourself from terminal. So our next step now that we have the local model downloaded is that we need to connect Hindsight to that local model and get the server running in the
Speaker A
background. So I'm going to do this inside of a docker container because this just improves the safety. Right now I already have my Hermes terminal back end is connecting to a docker container, so we're going to add another Docker
Speaker A
container here that runs our memory system in hindsight directly. We can paste in this string, which I'll include in the free article linked in the top comment, but basically we want to run the Docker container with the name of
Speaker A
hindsight, and we want it to even if the computer shuts down and starts up again, we want it to restart on its own. We're giving it two different ports, one for running the actual server, and then one for us to be able to look at the
Speaker A
dashboard. And then these are all just environment variables that we are configuring so that it can connect to specifically the model that I have just selected here, which is the GPT-OSS 20 billion. Okay, there we go, and it was
Speaker A
able to download hindsight for us. And now if we go over to Docker Desktop, which by the way this has to be running, I have a whole video that goes deeper into how to get your Hermes agent and
Speaker A
now something like hindsight containerized inside of Docker, but we can go here and we can see that we have our server is now running. So if we go over to dashboard here, we can select memory bank, we can create a new one, we
Speaker A
can get everything going. But this just shows us that we have the server running and it's available for us to connect to.
Speaker A
Okay, so our next step is to connect this running server to Hermes. Let's do that for a moment.
Speaker A
So remember I'm in my hindsight profile, I'm going over to memory and context. We have hindsight settings here since we've selected the drop-down, and I'm going to change this to local external. Because of that we can leave the API key blank.
Speaker A
I'm going to instead of having this connect to hindsight cloud, I'm going to put in the local host server that we just set up. I'm going to give it the name of Hermes, and I'm going to keep this recall budget as mid. So this isn't
Speaker A
doing anything to control the AI model, this is just telling Hermes where to find the hindsight program that we just launched. So now just to test this, I'm going to go back and I'm going to actually turn off persistent memory.
Speaker A
This is something that you can run in the background with hindsight. I'm just going to turn it off for a second so we can test hindsight. And this is different than Namaste, which recommends disabling this. So I'm going to say who
Speaker A
am I? There we go. So we can see hindsight recall just triggered, but it doesn't know who I am. So, I'm giving it the same prompt as before to see if it can remember this. We can see it's
Speaker A
planning durable memory. It's trying to update it, but again, in memories I turned that off. So, now it's running hindsight retain, and this can take a little bit because I'm running a local model. But, if we go take a look at
Speaker A
Docker for a second, we can go to my hindsight container. We can see here that it's running triggering the memory engine. So, if the model that I selected has gone to sleep, it can take a little bit. But, we can see here it's working
Speaker A
to store in chunks. Okay, there we go. It was able to use hindsight retain to store the user profile and preferences.
Speaker A
Cool. So, now it's saying too, the most useful optional context would be what are the answers to all of these things.
Speaker A
But, I'm just going to start a new session and say, "Who am I?" and see if it's able to pull that information from hindsight. There we go. So, rather than retain, it's now running hindsight recall, and it pulls up all the details
Speaker A
that we had before, which is great. That means that this memory provider is working.
Speaker A
And now, if we go back to localhost 99 dashboard, we can select the Hermes memory bank that now exists here. We can click on it, and what's super cool is we have the ability to see all of the
Speaker A
information here that's already been created as part of the hindsight system. So, to me this is pretty wild that not only are we able to get the agent to remember things, but it's able to build this graph based on our memory, and
Speaker A
there's so much detail we can get into here. This is called constellation view. We can switch it to table. We can take a look at timeline, which would happen as we get more details. There's experiences observations mental models. There's so many things that we
Speaker A
can structure here that I'm personally super excited to dive into. So, for example, I'm just going to answer the question that Hermes had given me, giving it a little more context on what I hope to do with my
Speaker A
YouTube channel, who I like to help, why I'm doing this in the first place. So, I'm going to have hindsight now retain this information. Okay, so it was able to run there, and if I click refresh on this graph, we can see that there's now
Speaker A
a few more pieces of information. I can tell Hermes to please reflect on this conversation.
Speaker A
So, here's the result of the reflection that also pulled in some recall. There was a bit of an issue, but it seems to have done a pretty good job pulling in a deeper understanding of what it is I'm
Speaker A
trying to do just based on that brief discussion I've had. I'm pretty impressed that it's pulling this in so quickly. The capable but overloaded builder people that I'm chatting with and I'm teaching here are curious and are wanting to understand rather than
Speaker A
just getting answers, but I hope you can see that not only are these memories being stored here, they're being used in a way that improves the reflection that the agent has on the problems I'm trying to solve and what I'm interested in
Speaker A
doing. And that was just after a basic amount of information. So, that's pretty cool. And again, this reflection is something that from what I understand at least at this moment, Mnemosyne doesn't have yet. So, that brings me to the
Speaker A
question of which one should you choose? What should we actually care about here and where should we take this next?
Speaker A
The author of Mnemosyne says these are not direct competitors. Hindsight is a memory engine with sophisticated natural language processing and multi-signal retrieval. Mnemosyne is a memory layer optimized for simplicity, speed, and single machine deployments. So, this is really the summary of it. Hindsight is
Speaker A
an engine, whereas Mnemosyne is a layer. So, it's up to you to decide what works best for you. I am going to put more information here and all of the resources I talk about today into a free Patreon article that will go more
Speaker A
in-depth on how to make this decision yourself, think the key here is to test one provider for a week and see if it improves your workflow. If it doesn't, try another one. You can always export from one to the other, there's no
Speaker A
lock-in. And again, one thing that I personally am excited to explore a lot more is the dashboard here. I just think this is so cool that I'm able to go and see all of these elements coming together, this full dashboard of the
Speaker A
memories that are being created from my agent as I just have conversations with it. And to me, this is also the key benefit of running something like hindsight over Nemesimy because while Nemesimy does have a dashboard, it's a
Speaker A
community dashboard. It's not built by the creator of Nemesimy. So, Nemesimy is a smaller tool built by a smaller team and hindsight is a full system that's got a lot more going for it. And that brings me to the next step, which I'm
Speaker A
really excited about. Not just building memories based on my chats with the agent, but also connecting this to my world knowledge, my library, or my second brain inside of my Obsidian LLM Wiki.
Speaker A
So, now your agent has true agentic memory. Nemesimy gives you a fast lightweight memory layer, and if you're looking for a little more power, you can use the memory engine of hindsight. If you have any questions about what we
Speaker A
talked about today or tips for how you're using your own workflow, please let me know in the comments. I'm happy to answer questions and I love learning how you're using these systems as well.
Speaker A
But, there's still one piece missing, world knowledge. Your operational memory, the agentic memory we set up, now knows how you work. Next, I'll connect it to the Obsidian LLM Wiki so your agent isn't just remembering facts about you. It's also reasoning against
Speaker A
everything you already know. If you found this video helpful, please like and subscribe. I really appreciate it.
Speaker A
And don't forget to check out the free Patreon post that I've linked below with more information on the setup, the code, and the memory provider options. Thanks again for watching and I will see you in the next video.
Topics:agentic AIHermes agentAI memorybuilt-in memoryexternal memory providerNemesisHindsightObsidian LLM Wikiknowledge managementAI agent tutorial
