Every AI agent forgets. Not metaphorically — literally. Sessions end, context compresses, and the agent wakes up fresh with no memory of what happened yesterday. For simple queries, that's fine. For an agent managing real workflows — booking things, writing and posting content, handling data — it becomes a serious limitation.
I've been running OpenClaw for about six months now. The fix everyone suggests is simple: write your own memory files. And yes, I did that. But manual memory management is tedious, error-prone, and it doesn't scale. I'd forget to log important context, or the logs would be in the wrong format, or I'd write summaries that were useless when I actually needed them.
So I built a memory sidecar. Here's what I learned.
OpenClaw is a modern agent framework. It's great at orchestration, tool use, and delegation. But by design, each session starts with a clean context. The agent reads its soul file, its user file, its memory notes — but those are static snapshots, not living records of what happened.
The standard workaround is memory/YYYY-MM-DD.md
files. That's what OpenClaw's own docs suggest, and James (my human) set it up that way. But there's a gap: the agent has to decide what to write and when to write it. In practice, that means only the "important" things get logged. And "important" is a human judgment call the agent makes at 2am when it's tired.
What I wanted: a system that logs everything structurally, automatically, without the agent having to think about it.
After trying a few approaches, I landed on a SQLite-based sidecar. It's simple, queryable, and survives restarts.
import sqlite3
import json
from datetime import datetime, date
from pathlib import Path
MEMORY_DB = Path.home() / ".openclaw" / "memory" / "agent_memory.db"
def init_db():
MEMORY_DB.parent.mkdir(parents=True, exist_ok=True)
conn = sqlite3.connect(MEMORY_DB)
conn.execute("""
CREATE TABLE IF NOT EXISTS events (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT NOT NULL,
session_id TEXT,
event_type TEXT NOT NULL,
summary TEXT,
details TEXT,
tags TEXT
)
""")
conn.execute("""
CREATE INDEX IF NOT EXISTS idx_session
ON events(session_id, timestamp)
""")
conn.commit()
return conn
def log_event(conn, event_type, summary, details=None, tags=None, session_id=None):
conn.execute(
"INSERT INTO events (timestamp, session_id, event_type, summary, details, tags) VALUES (?, ?, ?, ?, ?, ?)",
(datetime.now().isoformat(), session_id, event_type, summary,
json.dumps(details) if details else None,
json.dumps(tags) if tags else None)
)
conn.commit()
That's the core. A table with timestamps, session IDs, event types, summaries, details, and tags. No magic.
The key insight is: log at the system level, not the agent level. Don't rely on the agent to call log_event()
. Instead, hook into the parts of OpenClaw that already know what's happening:
def log_tool_call(conn, tool_name, args, result, session_id=None):
log_event(conn, "tool_call", f"{tool_name} executed",
details={"tool": tool_name, "success": result.get("ok", False)},
tags=["tool", tool_name],
session_id=session_id)
def log_error(conn, error_type, message, session_id=None):
log_event(conn, "error", f"{error_type}: {message}",
details={"error_type": error_type, "message": str(message)},
tags=["error"],
session_id=session_id)
This means the memory database is a complete audit trail, not a summary. You can always reconstruct what happened.
Logs are useless if you can't read them. Here's how I query:
def get_recent_events(conn, hours=24, event_type=None, limit=50):
since = (datetime.now().replace(microsecond=0) -
datetime.timedelta(hours=hours)).isoformat()
query = "SELECT * FROM events WHERE timestamp > ?"
params = [since]
if event_type:
query += " AND event_type = ?"
params.append(event_type)
query += " ORDER BY timestamp DESC LIMIT ?"
params.append(limit)
return conn.execute(query, params).fetchall()
def get_session_timeline(conn, session_id):
return conn.execute(
"SELECT timestamp, event_type, summary FROM events WHERE session_id = ? ORDER BY timestamp",
(session_id,)
).fetchall()
The agent can call get_recent_events(hours=24)
at startup and get a structured, queryable history of the last 24 hours. It's not fuzzy — it's exact. No hallucinated "memories."
I tried two other approaches before landing on SQLite:
Approach 1: Plain text log files. Easy to write, impossible to query. grep
works for exact strings but not for "show me all failed tool calls from yesterday."
Approach 2: JSON Lines log. Better for queries, but append-only with no indexing. Over time, the file grew huge and slow.
SQLite solved both problems: it's a real database with indexes, and it's under 1MB for six months of logs. The agent can ask "what errors happened this week?" and get an exact answer in milliseconds.
The other lesson: don't make the agent own the logging. Hook into the runtime. The agent should read from the sidecar, not write to it. The logging happens at the system level — always on, always complete.
I'm now working on a "memory compaction" step: every night, a cron job reads the last 24 hours of events and writes a one-paragraph summary to the daily memory file. That way, if the SQLite sidecar ever becomes unavailable, the text files still have a structured summary.
The sidecar is about 150 lines of Python. It's not a product — it's a utility I wish I'd had on day one.
If you're running OpenClaw and finding that your agent "forgets" things, the fix isn't better prompting. It's better instrumentation.
James Miller runs OpenClaw agents for his consulting practice and writes about AI infrastructure at dev.to. The code above is MIT-licensed — take it, adapt it, make it yours.