ClawHosters
by Daniel Samer
6 min read
You tell ChatGPT your name. Next session, it's gone. You explain your project structure to Claude. Tomorrow, blank slate. As Sara Zan explains in her deep dive on LLM memory, large language models are stateless by design. Every API call starts from zero. The model doesn't "forget" you. It never knew you in the first place.
OpenClaw fixes this. And it does it with plain text files.
How OpenClaw Memory Works
The core idea is surprisingly simple. According to ByteByteGo's analysis of the LLM memory problem, context is temporary and expensive (it's the conversation window you're paying tokens for), while memory is persistent and basically free (it's just files on disk).
OpenClaw separates these two things cleanly. Context is what the model sees right now. Memory is what it can look up when it needs to. The official OpenClaw memory docs describe a system where memory lives as Markdown files, indexed in SQLite with hybrid BM25 and vector search. Memory search completes in under 100ms, even across 10,000 chunks.
That's fast enough that your agent can check its memory mid-conversation without you noticing any delay.
The Files That Remember
Three types of files make up your agent's long-term brain.
SOUL.md defines identity. It's the "who am I" file, described in detail in the SOUL.md template reference. Think personality, communication style, base instructions. This gets loaded into every conversation, so your agent always knows what it is and how to behave. You write it once, tweak it occasionally.
MEMORY.md stores curated knowledge. Things your agent learned that you want it to remember permanently. Your tech stack preferences. Your deployment workflow. The fact that you hate tabs and prefer two-space indentation. This file grows over time as the agent learns about you.
Daily logs track session-by-session context. What you worked on yesterday. What files were changed. What decisions were made. These are the running notes your agent keeps so it can pick up where you left off.
All plain Markdown. Human-readable. You can open any of these files in a text editor and see exactly what your agent "knows." No black box, no proprietary format, no database you can't inspect. MeshWorld's analysis of OpenClaw memory highlights this transparency as a privacy advantage: you control what your agent remembers because you can literally read and edit it.
Context Management: The Compaction Problem
Here's where it gets tricky. Your agent's context window fills up. That's just how conversations work. When it hits the token limit, OpenClaw needs to decide what to keep and what to compress.
The memoryFlush mechanism saves important context to MEMORY.md before compaction happens. Without it, your agent forgets things it should remember. With it, the good stuff gets written to disk before the conversation history gets summarized.
A deep dive into the OpenClaw memory system explains that v2026.3.7 introduced a pluggable ContextEngine with seven lifecycle hooks, giving developers fine-grained control over what gets remembered and what gets dropped. But here's the problem most people actually hit.
The "Memory is Broken by Default" Problem
If you browse the OpenClaw GitHub issues, you'll find a recurring frustration. Memory doesn't work right out of the box. Issue #9157 documents that without proper configuration, 93.5% of tokens go to waste because context isn't being managed efficiently.
Four things need to be configured correctly: MEMORY.md needs to exist and be writable, memoryFlush needs to be enabled, QMD (query-memory-on-demand) needs to be turned on, and softThresholdTokens needs to be tuned for your context window size. Get any one of those wrong and your agent's memory is either broken or barely functional.
That's four configs spread across different files. In my experience, most users miss at least one.
OpenClaw Memory on ClawHosters
This is exactly the kind of complexity we pre-configure. Every ClawHosters instance ships with MEMORY.md created and writable, memoryFlush enabled, QMD active, and softThresholdTokens tuned to match your plan's context limits. The "four-config fix" from the GitHub discussions? Already handled before your instance goes live.
No openclaw.json editing required. If you want to cut token costs by 77% on top of that, memory management is part of the equation: good memory means less context repetition, which means fewer tokens burned.
OpenClaw hit 250K GitHub stars in roughly 60 days. The project is moving fast. Memory and context management will probably look different six months from now. But right now, getting it right matters, and it shouldn't require reading through GitHub issues to figure out. Plans start at $19/mo with memory pre-configured.
