agentmem

agentmem

Shared memory for Claude Code, Cursor, and Codex that knows what's still true. Save sessions, catch stale and conflicting rules, and stop your agent from repeating old mistakes.

The Problem

Your AI coding assistant forgets everything between sessions. It repeats old mistakes. It can't tell current rules from outdated ones. Context compresses and recovery is painful.

Most memory tools solve storage. agentmem solves trust.

Get Started (Claude Code / Cursor / Codex)

pip install quilmem[mcp]

agentmem init --tool claude --project myapp

That's it. Restart your editor. Your agent now has 13 memory tools. Run memory_health to confirm.

Python-only? pip install quilmem works without the MCP extra. See the Python API below.

60-Second Demo

from agentmem import Memory

mem = Memory()

Store typed memories

mem.add(type="bug", title="loudnorm undoes SFX levels", content="Never apply loudnorm to final mix. It re-normalizes everything.", status="validated")

mem.add(type="decision", title="Use per-line atempo", content="Bake speed into per-line TTS. No global pass.", status="active")

Something you're not sure about yet

hypothesis = mem.add(type="decision", title="Maybe try 2-second gaps before CTA", content="Hypothesis from last session. Needs testing.", status="hypothesis")

Search — validated and active memories rank highest.

Deprecated and superseded memories are excluded automatically.

results = mem.search("audio mixing")

Context-budgeted recall — fits the best memories into your token limit

context = mem.recall("building a narration track", max_tokens=2000)

Lifecycle — promote what's proven, deprecate what's not

mem.promote(hypothesis.id) # hypothesis -> active -> validated mem.deprecate(hypothesis.id, reason="Disproven by data")

Supersede: replace an outdated memory with a newer one

replacement = mem.add(type="decision", title="Use 1-second gaps before CTA", content="Confirmed by A/B test.", status="active") mem.supersede(hypothesis.id, replacement.id) # old points to replacement

Health check — is your memory system trustworthy?

from agentmem import health_check report = health_check(mem._conn)

Health: 85/100 | Conflicts: 0 | Stale: 2 | Validated: 14

What Makes This Different

Other memory tools store things. agentmem knows what's still true.

Truth Governance

The core idea: every memory has a status that tracks how much you should trust it.

hypothesis    New observation. Not yet confirmed. Lowest trust in recall.

| active Default. Currently believed true. Normal trust. | validated Explicitly confirmed. Highest trust in recall.

deprecated Was true, no longer. Excluded from recall. Kept for history. superseded Replaced by a newer memory. Points to replacement.

Why this matters: Without governance, your agent's memory accumulates stale rules, contradictions, and outdated decisions. It doesn't know that the voice setting from January was overridden in March. It retrieves both and the LLM picks randomly. Governed memory solves this.

Conflict Detection

from agentmem import detect_conflicts

conflicts = detect_conflicts(mem._conn)

Found 2 conflict(s):

!! [decision] "Always apply loudnorm to voice"

vs [decision] "NEVER apply loudnorm to voice"

Contradiction on shared topic (voice, loudnorm, audio)

agentmem finds memories that contradict each other:

• Detects topic overlap (Jaccard similarity)
• Separates duplicates from contradictions
• Sentence-level negation matching (not just keyword scanning)
• Severity: critical (both active) vs warning (one deprecated)

Staleness Detection

from agentmem import detect_stale

stale = detect_stale(mem._conn, stale_days=30)

[decision] "Use atempo 0.90" — Source changed since import (hash mismatch)

[bug] "Firewall blocks port" — Not updated in 45 days

Finds outdated memories by:

• Age (not updated in N days)
• Source file missing (referenced file was deleted)
• Hash drift (source file content changed but memory wasn't updated)

Health Check

from agentmem import health_check

report = health_check(mem._conn) print(f"Health: {report.health_score}/100") print(f"Conflicts: {len(report.conflicts)}") print(f"Stale: {len(report.stale)}")

Scores your memory system 0-100 based on: conflicts, stale percentage, orphaned references, deprecated weight, and whether you have any validated memories.

Provenance-Aware Sync

Sync canonical markdown files into the DB with source tracking:

# Each memory tracks where it came from

mem.add(type="bug", title="loudnorm lifts noise", content="...", source_path="/docs/errors.md", source_section="Audio Bugs", source_hash="a1b2c3d4e5f6")

The sync engine:

• Same hash = skip (idempotent, re-running changes nothing)
• Different hash = update (source file changed)
• Section removed = deprecate (with reason)
• Section restored = resurrect (reactivates deprecated memory)

Three Interfaces

Python API

from agentmem import Memory

mem = Memory("./my-agent.db", project="frontend")

CRUD

record = mem.add(type="decision", title="Use TypeScript", content="...") mem.get(record.id) mem.update(record.id, content="Updated reasoning.") mem.delete(record.id) mem.list(type="bug", limit=20)

Search + recall

results = mem.search("typescript migration", type="decision") context = mem.recall("setting up the build", max_tokens=3000)

Governance

mem.promote(record.id) # hypothesis -> active -> validated mem.deprecate(record.id, reason="No longer relevant") replacement = mem.add(type="decision", title="Use v2 approach", content="...") mem.supersede(record.id, replacement.id) # links old to replacement

Session persistence

mem.save_session("Working on auth refactor. Blocked on token refresh.") mem.load_session() # picks up where last instance left off

Health

mem.stats()

CLI

# Get started in 30 seconds

agentmem init --tool claude --project myapp

Check if everything's working

agentmem doctor

Core

agentmem add --type bug --title "CSS grid issue" "Flexbox fallback needed" agentmem search "grid layout" agentmem recall "frontend styling" --tokens 2000

Governance

agentmem promote agentmem deprecate --reason "Fixed in v2.3" agentmem health agentmem conflicts agentmem stale --days 14

Import + sessions

agentmem import ./errors.md --type bug agentmem save-session "Finished auth module, starting tests" agentmem load-session

MCP server

agentmem serve

MCP Server

Built-in Model Context Protocol server for Claude Code, Cursor, and any MCP client.

pip install quilmem[mcp]

Claude Code config (.claude/settings.json):

{

"mcpServers": { "agentmem": { "command": "agentmem", "args": ["--db", "./memory.db", "--project", "myproject", "serve"], "type": "stdio" } } }

MCP tools: add_memory, search_memory, recall_memory, update_memory, delete_memory, list_memories, save_session, load_session, promote_memory, deprecate_memory, supersede_memory, memory_health, memory_conflicts

Tell your agent how to use memory: Copy the agent instructions into your CLAUDE.md, .cursorrules, or AGENTS.md. This teaches your agent the session protocol, trust hierarchy, and when to search vs add.

Typed Memory

Seven types that cover real agent workflows:

Trust-Ranked Recall

recall() doesn't just find relevant memories. It finds the most trustworthy relevant memories:

1. FTS5 search returns candidates
2. Each scored: relevance (25%) + trust status (20%) + provenance (20%) + recency (15%) + frequency (10%) + confidence (10%)
3. Validated canonical memories rank above unprovenanced hypothesis memories
4. Deprecated and superseded memories are excluded entirely
5. Packed greedily into your token budget

Project Scoping

frontend = Memory("./shared.db", project="frontend")

backend = Memory("./shared.db", project="backend")

frontend.search("bug") # Only frontend bugs backend.search("bug") # Only backend bugs

Battle-Tested

This isn't theoretical. agentmem was built under production pressure over 2+ months of daily use:

• 65+ YouTube Shorts produced with zero repeated production bugs
• 330+ memories governing voice generation, FFmpeg assembly, image prompting, upload workflows
• Every bug caught once, fixed once, never repeated
• Governance engine reduced conflicts from 1,848 false positives to 11 real findings

How It Works

• Storage: SQLite with WAL mode (concurrent reads, thread-safe)
• Search: FTS5 with porter stemming and unicode61 tokenizer
• Ranking: Composite score: text relevance + trust status + provenance + recency + frequency + confidence
• Governance: Status lifecycle, conflict detection, staleness detection, health scoring
• Sync: Provenance-aware with source hashing and resurrection
• Zero infrastructure: No API keys, no cloud, no vector DB. Just a .db file.

License

MIT