How AI Agents Remember Things
How Does AI Memory Work?
Understanding AI Agents and Memory
- AI agents start without memory, meaning each conversation begins with no prior context. OpenClaus addresses this using markdown files and specific mechanisms.
- Conversations are stateless; they lack memory between calls, leading to a blank slate for each new interaction.
Components of Memory Systems
- Memory systems consist of session memory (short-term) and long-term memory. Session memory retains the history of a single conversation.
- Compaction occurs when the context window limit is reached, summarizing conversation history into essential information to maintain continuity.
Strategies for Compaction
- Three strategies trigger compaction:
- Count-based: Activated after exceeding token size or turn count.
- Time-based: Triggered when user inactivity is detected over time.
- Event-based/Semantic: Initiated upon completion of a task or topic, though it's complex to implement accurately.
Long-Term Memory Framework
- Long-term memory persists beyond sessions, akin to organizing notes on a desk versus filing them away in cabinets.
- Google’s framework categorizes agent memory into three types:
- Episodic: Recalls past interactions with the LLM.
- Semantic: Stores facts and user preferences about topics or users.
- Procedural: Contains workflows and routines for task accomplishment.
Effective Memory Management
- An effective memory system must filter key details from conversations while consolidating similar entries to avoid redundancy.
- The system should also allow updates to previous knowledge as user preferences change over time, preventing contradictory information.
Implementation Examples
- Various storage solutions exist for memories, ranging from simple markdown files to advanced vector databases that can be searched efficiently.
OpenClaw's Memory Model
- OpenClaw exemplifies practical agent memory with three core components:
- Memory MD File: A semantic store containing stable facts and user identity info, capped at around 200 lines.
- Daily Logs: Append-only records of recent contexts organized by day representing episodic memory.
- Session Snapshots: Captures the last meaningful messages during a session via specific commands, excluding non-essential data like tool calls.
Understanding Open Claw's Memory Mechanisms
Overview of Memory Systems
- Clause memory is essentially markdown files, but they require mechanisms to read and write them effectively. These files alone do not serve a purpose without proper management.
- The first mechanism discussed is bootstrap loading at the session start, where the memory MD is automatically injected into the prompt for every new conversation, ensuring the agent has access to necessary context.
Key Mechanisms in Memory Management
- The second mechanism involves pre-ompaction flush, which uses a count-based approach. When nearing context window limits, an invisible agentic turn prompts the LLM to save important information before potential loss.
- A checkpoint is created when the agent writes to the daily log upon receiving this message. This process transforms a potentially destructive operation into a safeguard against losing context.
Session Management Techniques
- The third mechanism is session snapshots that are saved whenever a new session starts (via /new or /reset commands). It captures meaningful messages from previous conversations and generates descriptive file names.
- Lastly, users can directly request memory retention by instructing the agent with phrases like "remember this." The agent determines how to categorize this information without needing special hooks.
Conclusion on Open Claw's Memory System
- Overall, Open Claw’s memory system relies on markdown files and specific timing for writing to them—semantic memory in memory MD files, episodic memories in daily logs and session snapshots. This structured approach ensures efficient data management across sessions.