Your AI coding agent has amnesia. Here's how to fix it — locally.

Every developer using an AI coding agent knows the ritual: you open a fresh session and re-explain everything — the decision you made yesterday about the database layer, the convention that errors surface a clean message rather than a raw stack trace, the approach you already tried that didn't work.

Within a single session, the model keeps up fine. But as the context window fills, older turns get compacted into a summary, and the specifics blur into gist. Across sessions, the tools have started to help — the Claude Code CLI now keeps automatic notes and session summaries next to a hand-written CLAUDE.md, and Codex has its AGENTS.md.

That's real progress — but each half has a catch. The automatic notes and summaries are lossy by design, and they live inside one tool, in one vendor's store. And the hand-written files? CLAUDE.md and AGENTS.md are readable and yours, sure — but you maintain them by hand, they hold one flat brief rather than specific facts, and each is bound to its own tool, not one memory every MCP client shares.

So you reach for a workaround. Each is a bad trade-off:

• A giant CONTEXT.md you paste into every prompt — it bloats the context and goes stale the moment the code moves on.
• An LLM-maintained "wiki" — a curated doc the model reads and edits. Better, but it lives at the wrong resolution: it captures a project's high-level shape, not the granular facts that unblock the next task — the one convention this repo follows, the exact decision you made yesterday, the approach that already failed. Broad enough to orient a newcomer; too coarse to be the memory you needed.
• A hosted "memory" product — which ships your codebase knowledge off to someone else's database.

None of these is what you actually want. And what you want is simple: the agent should remember the specific things that matter, recall them exactly when they're relevant, and keep that memory yours.

Simple to ask for, anyway. Building it — locally, losslessly, without a vendor database — turns out to be the fun part. Here's how it works.

What "memory" should actually mean

Good agent memory isn't a bigger context window. And the key design choice is counter-intuitive: be exhaustive when you capture, and selective only when you recall. Trying to be clever at write time — guessing which line will matter next week — is exactly how "smart" memory drops the one specific fact you needed. So don't guess. Keep everything, and move the judgment to read time.

That's exactly what Verbative does — three things working together:

1. Complete capture, in two layers — nothing is dropped on a hunch about importance. Underneath sits a lossless ledger: a mechanical, no-model record of everything that happened — every command, edit, and test result — so "what did we actually run" and "when did this test start failing" are exact, replayable facts, not retrieval guesses. On top of it, an on-device model distills the stream into atomic, typed memories — the decisions, conventions, and dead ends — deduped and superseded as they change. The complete record underneath, the clean facts on top.
2. Selective recall — the two layers fused — the judgment happens when you read, not when you write. A single recall surfaces only the handful of distilled facts that matter — ranked by semantic search and a reranker — and interleaves them, by time, with the exact ledger record around them: what you decided sitting next to what you actually did (the commands, the edits, the test that flipped), with the causal and temporal links between. Not two separate lookups for two kinds of question — one answer that fuses meaning with ground truth, instead of dumping the whole history back in.
3. Self-maintenance — it reconciles contradictions (you switched from npm to pnpm — the old fact is superseded, not duplicated), lets genuinely stale facts decay, and doesn't drown you in near-duplicates.

A static file does none of this. A hosted service does some of it — but at the cost of privacy and portability.

Local, part of your project

Verbative Memory runs the capture and recall models on your own machine and stores everything as plain, human-readable files inside your repo. That has some non-obvious benefits:

• It's yours. Read it, diff it in code review, git-track it, or delete the folder — there's no vendor database holding your codebase knowledge hostage.
• It's private by default. Verbative uploads nothing — your client names, architecture decisions, and unreleased plans stay on your machine unless you explicitly desire to share them (say, by committing the memory to a shared repo).
• It's portable. It speaks MCP, so the same memory works across the Claude Code CLI, Codex, and any other MCP client — not one locked-in editor.

Does it actually recall well?

Recall quality is easy to claim and hard to prove — so we measure it, not assert it. The engine runs on the public memory benchmarks — LoCoMo and AMA — through an open reproduction harness you can point at the same datasets and run yourself, instead of taking our word for it. And it all happens on your own machine: recall lands in about 100 ms, with zero cloud calls.

Getting started

The best part is that you don't have to do anything. Install Verbative Memory for the Claude Code CLI or Codex and it registers a pair of hooks — and from then on it works on its own: after every turn it captures what matters, and before every prompt it injects the handful of relevant memories straight into the agent's context. No tool calls, no "remember this," no re-explaining your project every morning. The agent just already knows.

And the agent isn't limited to what the hooks feed it. The full memory toolset is right there over MCP — recall, search, revise, pin, deep_recall, and the rest — so it can query the record on purpose, correct a fact it knows is outdated, or dig through the history when a task calls for it. The hooks make memory effortless; the MCP tools make it deliberate. You want both, and you get both.

Verbative Memory is part of Verbative — voice-first, on-device tooling for AI coding agents. See how the memory works →