Back to the shelf
recall

Recall

Durable context for the next agent session, with one local store and a history I can inspect.

Private repo
2026
pythonsqlitemcpcliagentsauditsemantic search
Watch both episodes ↓
01

Why

I wanted coding agents to pick up useful decisions and lessons across sessions without treating a transcript dump as memory. The next agent needs context it can find, place in the right project, and check against current evidence.

My work on Recall spans the original implementation and the current local version: project namespaces, semantic retrieval, revision-aware writes, lifecycle hooks, and backup/restore. This case study describes my personal implementation and contributions; a separate employer variant has its own development history.

02

How it’s built

A Python CLI and stdio MCP server call the same operation layer over one canonical local SQLite database. Multiple local agents can share typed memories, project namespaces, and relationship links. Hybrid retrieval combines FTS5/BM25 with local FastEmbed vectors; agent and session provenance make records traceable.

Optional expected revisions reject stale edits. Memory changes and the hash-chained mutation audit commit together, while an embedding failure does not discard a durable write. Encrypted backups restore into a separate candidate database for validation.

Recall ships a bundled dream skill for keeping the store tidy over time. An agent runs it: it checks each memory against the code, git history and session record, merges duplicates, soft-deletes memories the code has made untrue, and demotes claims it cannot verify. Recall stays LLM-free; the host agent does the reasoning and drives Recall through the CLI, and every change is a supersession or soft delete that lands in the audit chain.

I run Recall locally. It serves stdio MCP, with no network-hosted API in the current runtime. The earlier hosted experiment is archived; sharing context among agents on this machine does not imply concurrent writers across multiple machines.

  • Shared local agent memory with stable project/global namespaces and typed relationships
  • Full-text, vector, and hybrid search using a cached local embedding model
  • Agent/session provenance, supersession history, and tamper-evident mutation audit
  • Optional revision guards for competing local agent edits
  • Codex and Copilot lifecycle hooks for context retrieval, with memory review forced at most every few turns
  • Bundled dream skill: an agent-run consolidation pass that merges duplicates, prunes stale memories and demotes anything it cannot verify
  • `recall view` opens the store in Curio for reading, editing, review and a brain map, with every change still going through the CLI
  • Encrypted SQLite backup and validation before accepting an isolated restore
03

Demo

Episode 1, The store. Demo on a throwaway database with a fictional project. Real CLI output, then a real Copilot CLI agent using Recall over MCP: it searches before fixing a bug, supersedes a stale memory and files a lesson. Then a refused stale write, the hash-chained audit log, and a real run of the bundled dream skill merging a duplicate, soft-deleting a stale fact and demoting a claim it could not verify.1:24 runtime
04

Screenshots

Typed, project-scoped writes with agent provenance: throwaway demo database, fictional projects
Hybrid FTS5 and local-vector search matches by meaning as well as keywords
Revision guards reject a competing agent’s stale edit
Every mutation lands in a hash-chained, tamper-evident audit log
Encrypted backup, verified and restored into a separate candidate database