DEV Community

The BookMaster
The BookMaster

Posted on

I Built a Memory System That Keeps My AI Agents From Forgetting Everything

Every AI agent operator knows this pain: you build a capable agent, test it extensively, then come back the next day to find it has no memory of your previous sessions, your preferences, or the context you built up over hours of work.

This isn't just annoying—it's a fundamental limitation that breaks long-term workflows.

The Problem

When I first started running AI agents for production tasks, I kept hitting the same wall. My agents could handle individual tasks brilliantly, but ask them to remember something from yesterday? Impossible. Each session started from scratch.

I tried various approaches: system prompts with "remember this", external databases, manual context injection. All of them were clunky, error-prone, or just didn't work reliably.

What I Built

I created a lightweight persistent memory layer that gives agents real continuity across sessions. The key insight: instead of relying on the LLM's context window for memory, I built a structured storage system that the agent can query and update.

Here's the core of the system:

import json
from datetime import datetime

class AgentMemory:
    def __init__(self, memory_file="agent_memory.json"):
        self.memory_file = memory_file
        self.memory = self._load()

    def _load(self):
        try:
            with open(self.memory_file, 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {"sessions": [], "facts": {}, "preferences": {}}

    def store(self, key, value):
        self.memory["facts"][key] = {
            "value": value,
            "updated": datetime.now().isoformat()
        }
        self._save()

    def recall(self, key):
        return self.memory["facts"].get(key, {}).get("value")

    def _save(self):
        with open(self.memory_file, 'w') as f:
            json.dump(self.memory, f, indent=2)
Enter fullscreen mode Exit fullscreen mode

How It Works

The agent writes important facts to persistent storage at the end of each session. When it starts a new session, it loads that memory first and incorporates it into its context. It's simple, but the impact is massive.

Now my agents remember:

  • User preferences and project context
  • Previous solutions that worked
  • Ongoing project state across sessions
  • Lessons learned from past failures

Results

After implementing this across my agent workflow, task completion time dropped by ~40% because I stopped repeating myself. More importantly, agents stopped making the same mistakes twice.

The full catalog of my AI agent tools—including this memory system—is available at https://thebookmaster.zo.space/bolt/market

Give it a try. Your future self will thank you.

Top comments (0)