Verbative Memory · On-device MCP
The local memory engine for AI agents.
Learned by one, remembered by all.
The persistence layer every AI coding agent should have.
On-device, always current, sharper every session.
- Any agent, across every session — Claude Code CLI and Codex, each wired in one command
- Self-organizing: reconciles contradictions, weights what matters, forgets the noise
- Dual-engine: a model distills durable facts while a lossless ledger keeps the verbatim record — answers cite exact evidence, down to any file's state at any moment
Zero cloud · MCP standard · One line per agent
$ claude mcp add verbative-memory -- npx -y verbative-memoryOne command, fully set — automatic capture and recall switch on with it. Both optional, on by default. No install needed.
Nothing to install first — the first run fetches the engine and the on-device models once (~4.6 GB, shared with the extension if you have it); after that, zero network. Full setup guide (pip, npx, all clients) →
Memory · fully on-device
Your agents remember everything. And recall exactly what matters.
More memory isn't better memory. Verbative is built for precision: an on-device model keeps what's worth remembering, while a lossless ledger records every edit, test, and command verbatim. Each prompt gets just the right few memories — decisions, conventions, hard-won dead ends— on a strict token budget. Hard questions get deep recall: the whole story, not fragments. One pool per project. Never a cloud.
Everything your agents remember — across all channels, this project, and your globalmemory, in one place. Add a memory here or ask an agent to; the relevant ones (plus anything pinned) are auto-injected into each agent's prompts.
Add a memory — a fact, decision, or convention your agents should always remember…
Stored on-device. Tip: keep each memory to one clear sentence.
📌 Pinned memories are injected into everyprompt and never trimmed — pin the few always-true rules. Everything else surfaces automatically when it's relevant to what an agent is doing.
Never hand-edit anything under generated/ — pnpm codegen rewrites it on every build. The source of truth is schema/api.yaml.
The Safari-only login loop was SameSite, not the redirect: the OAuth callback needs the session cookie at SameSite=Lax — deliberate in auth.ts, do not "harden" it back to Strict.
⚠️ AVOID: sharp's parallel mode in the image pipeline — it silently corrupts EXIF rotation on iOS uploads. Tried twice, reverted twice (#214, #367).
Under the hood
the full pipeline, running entirely on your machine
Capture
after each finished turn · two tracksGoal anchor
knows what the session is working on
Extract
typed facts, rated · dense turns split until they fit
Qwen3 4B
Event ledger
every edit, test, command — lossless
deterministic
Reconcile
updates supersede stale · step-aware
Graph + store
cause→fix edges, edit history, provenance
Recall
every prompt · ~200 msUnderstand
query intent + time windows
Match
one matrix op
Qwen3 embed
Expand
graph + associations
Rerank
precision pass
bge
Ledger evidence
exact edits, test flips, first-seen
verbatim
Inject
budget · stale routed out
Deep recall
on demand, for the hard questions · secondsThe story
problem → cause → fix → verified
Resonance
the question excites the whole record
wave
Interference
weak signals reinforce into peaks
Branch labels
changed values show both readings
Tallies & histories
counts and timelines join in when the question asks
One context
every step present, depth follows relevance
Capture runs two tracks: a model distills durable facts, while a deterministic ledger records every edit, test, and command exactly— so recall can answer “what changed” and “which step fixed it” with verbatim evidence, not a paraphrase. Capture is self-healing: a turn too dense for one pass is split until every fact fits, and nothing is ever dropped silently. Deep recall reads the record the way memory research says brains do — activation spreads from the question across time, files, and the knowledge graph, and the resonant moments surface in full. Agents can also ask directly: the state of any file at any point, when something was first seen, what broke and which edit fixed it, and the net result per file. All of it — capture, recall, consolidation — runs on your machine and never leaves it.
While you sleep
background consolidation, when there's new activityEverything is plain files: an append-only log, a deterministic event ledger, a temporal knowledge graph, and a rebuildable vector cache — one project pool plus a private global scope.
median on-device retrieval across 1,536 benchmark questions — embeddings plus a 30-candidate reranking pass, no network round-trip
to catch a contradiction and retire the stale fact, fully on-device
memories in one pool, searched in a single matrix operation with no index to build or maintain — 0.6 s median retrieval at 100,000 memories, 6.4 s stress-tested at 1,000,000
storage, search, capture, and consolidation all run on your machine
ask in one language, recall memories saved in another — measured at full parity (German → English)
Measured on the LoCoMo public run and our scale test, on-device (Apple silicon).
Memory · benchmarks
Benchmarked in the open — on the right exams
There are two kinds of memory benchmark, and vendors quote whichever one flatters them. Agent examsgrade memory over real agent work — commands, file states, causal chains — across domains from coding to embodied agents. Conversational exams grade recall across months of personal chat.
Verbative is a coding tool, so AMA-Bench's software domain counts most — but the same engine sits all six domains unchanged, and LoCoMo shows it also holds up on conversation. Pick an exam:
Every Verbative number on this page, rerun from scratch on your own machine.
AMA-Bench — the agent-memory exam
Six domainsThe ICML 2026 benchmark for agent memory (arXiv 2602.22769): real agent trajectories with questions on step recall, causal dependencies, state tracking, and abstraction. Its results table's quiet finding: most famous memory products lose to a plain embedding-retrieval baseline, because they compress lossily and rely on similarity search alone — the two failure modes Verbative's engine was built to avoid.
36 episodes · 432 questions · real GitHub bug-fix trajectories (SWE-bench)
One prompt. Two agents. Same question.
Don't take our benchmark's word for it — make your own agent measure it, on your own project:
Spawn two fresh subagents in parallel on the same question:
<any question about your project — a decision, a convention, how something came to be>
Agent A: regular — it must not use the verbative-memory MCP.
Agent B: verbative — it answers via the verbative-memory MCP.
Then give me a side-by-side table: tool calls, tokens used, wall time, and what each answer got that the other missed.
Memory can only compare what it has seen: have capture on while you work — or memorize past sessions first with verbative-memory backfill.
“Same question, same project. The repo agent: 50 tool calls, five minutes, 18,000 output tokens — and it got the what. The memory agent: 12 calls, 68 seconds, a quarter of the tokens — and it also knew the why and what we'd ruled out. The table doesn't argue. It just shows the difference.”
Your project, your agent, your numbers — black on white.
By capability — as the paper reports it (Table 5, all six domains)
All 16 systems from the paper's results table (Table 5), graded by the authors' own judge across all six domains.
Retrieving a specific past fact or action from the recorded work.
Why something happened — preconditions and cause→effect.
Tracking how something changed over time — the exact target of Verbative's event ledger.
Condensing many steps into the durable takeaway — our strongest capability.
Benchmark audit — July 2026
We validated the judge first: ours reproduces the authors' own published verdicts at 99% agreement. Verbative's numbers here are the final full-set run across all six domains under that same instrument — every per-question answer and verdict is published in the reproduction repo. Public-leaderboard numbers aren't shown: they are self-reported and not reproducible from the released answers.
Board data from the benchmark paper (Table 5; arXiv 2602.22769, ICML 2026) — the authors' own judge and numbers.
Memories know which files they cite. When the code changes underneath a fact, agents are told to verify — confirmed facts re-baseline, wrong ones retire.
Ask what any file looked like at any recorded moment — replayed exactly from the edit history, with a label when a later change superseded that state.
“How we deploy” isn’t a description — it carries the exact runnable command, validated so it never points at a script that no longer exists.
Tried-and-failed approaches are first-class memories, injected as explicit AVOID warnings so no agent burns a day on them twice.
When a value changed later, memory shows both readings — the state back then and the correction, each with its step — so agents never confuse “what it was” with “what it became”.
Every outcome flip links to the edit that caused it, every edit to its file's history, every fact to the code it lives in — agents walk from “why did this break” straight to the exact change.
Replay the published run — every question, unedited, passes and failures.
Analytics, down to every recall
See how many memories your agents have built, how often they're recalled into prompts, and how much of your memory is actually working for you — live, in the Memory panel's own Analytics tab: daily activity, a year of capture at a glance, and the memories your agents lean on most. Every number is computed on your machine from your own memory files. Nothing is reported anywhere.
How memory is performing — computed live from the files on this machine. Nothing leaves your device.
11,482
memories stored
131K
recalls into prompts
78%
of memories used at least once
1,526
new in the last 30 days
5,566 facts·2,829 how-tos·2,341 events·746 entities·11 📌 pinned
Last 30 days
recalled into promptsnew memories9,214 new memories in the last year
LessMoreMost recalled
The memories your agents lean on most.
It reconciles — not just collects
Every new fact is checked against what's known: updates supersede the stale fact, confirmations strengthen it, duplicates never pile up.
It learns and forgets like you do
Importance is rated at capture and fades on forgetting curves. What proves helpful grows stronger — and dead ends stay as explicit warnings.
Yours — private, readable, in your repo
Plain files inside your project, git-trackable on request. No memory cloud, nothing to export — and one npx line plugs the same memory into any MCP-capable agent. Details in the memory docs.
You stay in control
Ask time-anchored questions (“what did we decide last week?”), pin the always-true rules, and give feedback by voice or from the Memory tab — agents can even mark a memory as wrong and it retires on the spot.
Part of Advanced — try the whole plan, memory included, free for 14 days, cancel anytime before it renews. Your memory files stay yours either way. See pricing
Frequently asked
Which agents can use the memory?
Claude Code CLI and Codex — one command wires each of them, with automatic capture and recall. Both share the same project memory: a decision made with one agent is recalled by the other. Any other MCP client can connect to the same server for on-demand recall too.
Does anything leave my machine?
No. Capture, storage, search, and recall all run on-device — zero cloud calls. Memory lives in human-readable files inside your own repo, git-ignored by default with an opt-in toggle to let git track it.
What does it actually remember?
Everything — in two layers. A lossless ledger records every edit, test, and command exactly, while an on-device model distills what's worth keeping: decisions, conventions, where things live, and dead ends kept as explicit ⚠️ avoid warnings. Each prompt gets only the distilled essentials; when a question needs the full story, deep recall searches the complete record. New facts reconcile against old ones — a contradiction supersedes the stale fact in seconds.
Do I control what's stored?
Fully. The Memory tab lets you search, sort, pin the always-true rules into every prompt, and add or retire entries. Agents get the same agency through built-in memory tools — including flagging a memory as wrong so it retires on the spot.
Is it part of a plan?
The memory engine is part of Code Advanced — try everything free for 14 days. Your memory files are never deleted: if Advanced pauses, capture and recall pause with it, and everything resumes the moment you're back.
Give your agents a memory.
Every decision, convention, and dead end — remembered across sessions, on your own device.
Get Verbative