If you’ve been using OpenClaw for more than a day, you’ve probably hit the same wall we did: you spend hours telling your AI agent everything about yourself, your preferences, your workflow — and then the next morning, it wakes up and has no idea who you are. In this video, Ron and I break down exactly how to fix this memory problem so you can stop wasting time re-explaining yourself every single session.
The Problem: Your AI Agent Has Amnesia
Here’s the thing most people don’t realize about AI agents — they’re not continuously running with perfect recall. The best way to think about it is that every morning, your AI wakes up fresh. The session resets, and it essentially forgets everything from the day before. It then has to read through its notes and files to piece together who it is and what you’ve been working on.
This is a fundamental limitation of how large language models work. They operate within a context window — a fixed amount of text they can process at once. The larger that context window, the more expensive each interaction becomes. So you can’t just dump your entire conversation history into the prompt every time. Back in January, a lot of tutorials were telling people to just blast the AI with their life story so it would understand them better. Ron tried exactly that, spent two hours pouring everything in, and the next day? Gone. All of it.
Solution #1: Semantic Search with Embeddings
The first and most important thing you should enable on your OpenClaw agent is semantic memory search. This is the game-changer that turns your forgetful AI into something that can actually recall past conversations when it needs to.
Here’s how it works: OpenClaw takes your entire conversation history and converts it into embeddings — essentially numerical representations of the meaning behind your words. These embeddings get stored in a vector database (OpenClaw uses SQLite with the sqlite-vec extension). When your agent needs to remember something, it performs a semantic search across all those stored embeddings to find the most relevant past conversations.
The key insight is that your agent doesn’t load everything into memory all the time. It only searches when it needs to — when you ask it something that requires past context. This keeps costs manageable while still giving you access to months of conversation history. OpenClaw actually uses a hybrid approach: about 70% vector (semantic) search combined with 30% BM25 keyword search. The vector search handles conceptual matches where wording differs, while BM25 catches exact terms like error codes or function names.
By default, OpenClaw supported OpenAI’s embedding models, but the newest updates have added Mistral as an embedding provider. This is a big deal because Mistral’s embeddings are cheaper to run over time. Research shows that Mistral’s embedding model actually achieved the highest accuracy at 77.8% in retrieval benchmarks, while being more cost-effective than OpenAI’s offerings. If you’re running your agent daily and building up months of conversation data, those cost savings add up fast.
Solution #2: QMD (Quantized Memory Documents)
The second approach we’ve been testing is something called QMD — Quantized Memory Documents. This is another way to handle memory that can be cheaper than pure embedding-based search.
Think of QMD as a more compressed, efficient way to store and retrieve memories. Instead of embedding every single line of conversation, QMD creates condensed document summaries that capture the essential information. It’s still in the experimental phase for many users, but it’s showing promise as a cost-effective alternative, especially for agents that accumulate massive amounts of conversation data over time.
Solution #3: Skills — Teaching Your Agent Permanent Abilities
The third approach is one of my favorites: skills. If there’s something your agent needs to do repeatedly — every single day — it should have a dedicated skill for it. I like to think of it like Neo learning kung fu in The Matrix. You just plug in the skill, and boom, your agent knows how to do it.
A skill in OpenClaw is essentially a plain-text instruction file that lives in your agent’s skill directory. You can tell your agent to write a skill, refine it over time, and even connect to your server via SSH (using something like Termius) to manually inspect and edit the skill files. Since they’re written in plain English, you can understand exactly what your agent is doing and tweak it as needed.
Skills are different from memory in an important way: memory is about recalling past conversations and context, while skills are about permanent capabilities. Your agent will always load its relevant skills at the start of a session, so it never “forgets” how to do something you’ve taught it.
Ron’s Approach: Obsidian Integration for Daily Summaries
Ron and I actually have completely different approaches to memory, which I think highlights how personal this whole setup is. I tend to care less about memory and more about having a solid project plan — as long as the agent knows what we’re building, I’m good. Ron, on the other hand, is meticulous about how his agent remembers things.
His approach goes beyond just embeddings and semantic search. He’s set up his OpenClaw agent to save a full summary of every chat session as a plain text file and push it to Obsidian — the popular note-taking app. This creates a human-readable archive of everything the agent has discussed, which serves as both a backup and an additional memory layer. It’s a clever approach that combines AI memory with traditional note-taking, and it’s something we haven’t covered in depth on this channel yet.
Getting Started: Don’t Skip Memory Setup
The TL;DR here is simple: make sure you have some form of memory enabled on your OpenClaw agent, or it’s going to forget everything. Whether you go with semantic search (the most common approach), experiment with QMD, build out skills, or combine all three — the important thing is that you don’t leave your agent running with zero memory infrastructure.
If you’re just getting started, I’d recommend enabling semantic search first. It’s the most straightforward to set up and gives you the biggest immediate improvement. From there, you can layer on skills for repetitive tasks and explore QMD as your usage grows.
We’re planning more detailed guides on each of these approaches, so drop a comment on the video if there’s a specific memory setup you’d like us to walk through. This channel is all about solving real problems with real solutions — and memory is definitely one of the biggest pain points we’ve all been dealing with.
