One corpus, every assistant
Claude Code, Codex, Gemini, Antigravity, goose, Cursor, Kimi and more read and write the same local memory over MCP. Switch tools mid-project and keep every hard-won detail.
The ship-log for your coding agents
One private ship-log, one synchronized skill library, and one map of what every assistant can actually do. Captain Memo recalls what your agents learned, mirrors the skills they installed, and routes work to the AI that owns the right plugin or extension.
claude plugin marketplace add kalinbogatzevski/captain-memo
One command wires every AI coding tool on the machine. They all read and write one local corpus.
A shared library and capability map
Captain Memo mirrors the instructions your AIs know and safely publishes the plugins and extensions each runtime can execute. Every connected assistant can discover the best method, find the right owner, and delegate the work without copying secrets or pretending every CLI can run every tool.
Skill discovery is auto by default. Edit or remove the original SKILL.md and its searchable, portable virtual copy updates with it.
Plugin discovery is also auto by default. Captain Memo publishes only sanitized names, operations and interfaces, then routes execution to the owning AI—never the manifest, credentials or command configuration.
Native lifecycle capture
On supported Codex, Gemini CLI and Kimi releases, Captain Memo installs native prompt, tool-result and turn-end hooks. Useful evidence reaches the same local observation pipeline immediately—not after a transcript reader eventually notices the session.
A session becomes native only after its first successful tool event reaches the worker. stats.capture.native shows the proven sessions by CLI.
Older, disabled, untrusted or failed hook installs keep using the existing transcript and rollout readers automatically. Installation alone never switches fallback off.
What a memory store turns into
Nothing here is tagged, foldered or curated into place. These are 144,159 embeddings from one working store, partitioned with no labels and no supervision — and then read back to see what the partition had found.
Every note and captured observation becomes a vector. No schema, no tags, nothing decided in advance.
k-means partitions them. 87% of the clusters it finds span more than one repository.
Where the same fact was learned in separate sessions weeks apart, a model names it. Most candidates are declined.
Logbook entries
Not another cloud memory service. A local layer that every AI coding tool on your machine can share.
Claude Code, Codex, Gemini, Antigravity, goose, Cursor, Kimi and more read and write the same local memory over MCP. Switch tools mid-project and keep every hard-won detail.
Summarize with the Claude, ChatGPT, or Google login you already have, or run it fully local on Ollama. Three of the summarizer backends need no key at all.
The vector store and metadata live on your disk. Hybrid search (embeddings plus keyword), indefinite retention, and no cloud bill for remembering.
The voyage
It runs quietly in the background. You never stop to manage it.
Captures each working session as structured observations: what changed, what you learned, what to reuse.
Indexes them into a hybrid search corpus, dedupes the noise, and keeps them for as long as you want.
Injects the relevant memory into every prompt, so your assistant starts already knowing the context.
The ship's scribe
The summarizer is the scribe of the crew. After each stretch of work it reads what happened, the files you touched, the commands you ran, what you worked out, and writes it up as one short, structured log entry. Those entries are what make your past work searchable later.
Point it at the Claude, ChatGPT, or Google account you already sign in with, or a local model on Ollama. Three of the choices need no API key at all. It works in the background, a batch at a time, so it never slows a prompt down.
Pick a single summarizer when you install. Only one is ever active. See who is on watch any time with captain-memo stats, which names the provider and whether it is actually writing entries.
Nothing is lost. Your session waits safe in a durable queue. A passing outage retries on its own with no penalty; a missing login simply pauses the writing until you sort it out, then the queued work gets written up. And the rest of your memory, watched files, saved notes, and search, keeps working the whole time.
The hold
Everything you keep is indexed two ways at once, so recall works whether you remember the exact words or only the gist.
Meaning-based vector search and plain keyword search, fused into one ranking, with a gentle tilt toward recent work so today's context surfaces first. Multilingual too: your non-English notes are just as findable.
A tiny hosted model by default (around $0.30 a year of usage), or run it fully local and offline, or point it at Ollama or any /v1/embeddings endpoint. Indefinite retention, and no cloud database to rent.
A corpus that only ever grows eventually crowds out the memories you want. Dreaming folds related observations into a single higher-level theme, and it groups them by what you actually recall together — not merely by what shares vocabulary, which just yields groups that use the same words. The originals are archived, never deleted. It runs on your machine, only while you are away from it, and every change is reversible with one command.
The name is Anthropic's — Claude Managed Agents shipped Dreams in May 2026, a cloud pass that re-reads an agent's transcripts to rebuild its memory store. Captain Memo does the same job locally, and works out what belongs together from co-retrieval rather than by re-reading the text. How dreaming works →
The fleet
Twelve assistants share one memory through Captain Memo's MCP server and a portable skill. One command wires each of them.
The last three run the summarizer and embedder locally, so a machine with no Claude, ChatGPT, or Google account can still remember, entirely offline.
Run several assistants long enough and two of them will reach for the same file at the same moment. So a Claude Code session publishes a short-lived claim before it touches anything — the edit tools, and sed -i, >, heredocs, tee and the PowerShell write cmdlets too — and every assistant can post one with work_set. The board tells it at once if another agent on the machine holds the same path, the same git checkout, the same topic, or the same problem in different files. It never blocks an edit, and a crashed session leaves no ghost claim behind.
The captain's manual
A handful of commands run it from your terminal. Your assistants get a matching set of tools they call on their own.
Run captain-memo help for the full list.
top is a live dashboard: sort, filter, drill, an AI-sources chart, and a built-in glossary (?) — see the full stats glossary.--apply deletes, and never a tree a live session is loaded from.--for 30m keeps it going), read the themes it wrote (theme list), and reverse any you disagree with (theme undo <id>).backup info inspects one without restoring it.Called automatically over MCP. You never invoke them by hand.
work_set adds 1–5 tags for what the work is about, and the session hears at once if another agent on the machine overlaps it. Advisory only; claims expire on their own.idea: or todo: at the front of a prompt files it for later before the model spends the turn on it, and every new session lists what is open. Claim an item before starting it; close it with a one-line note.You stay the captain
The whole corpus, every vector and every note, lives on your own disk. Captain Memo logs the voyage; you decide what, if anything, is ever sent anywhere.
Nothing is uploaded for storage. The only things that ever leave are the calls to the summarizer and embedder you chose, and only for the moment they run.
Run both the summarizer and the embedder on a local model, and nothing at all leaves the machine. No account, no key, no cloud, no exceptions.
Before you sail
The things people ask before they hoist the plugin.
No. It works with Codex, Gemini, Cursor and more, and the summarizer can run on your ChatGPT or Google login, or fully local on Ollama. A machine with no Claude at all still remembers.
No. The writing happens in the background between prompts, a batch at a time. You never wait on it, and a whole session becomes a single log entry.
On your own disk, under your home directory. There is no cloud database, and nothing is uploaded for storage.
Yes. Choose the local embedder and a local summarizer model, and Captain Memo runs with no network at all.
Yes, open source under Apache-2.0. The optional hosted embedder runs about $0.30 a year; keep everything local and it costs nothing.
It is local, it is shared across all your AI tools instead of locked to one, and it is yours. No vendor account, no lock-in, no per-call bill for remembering.
Nothing is lost. Your sessions wait in a durable queue and get written up once it is back. An outage retries with no penalty, and the rest of your memory keeps working meanwhile.
Type it with idea: or todo: at the front of the prompt. The hook files it as homework on this machine before the model spends the turn on it, so the answer is a short "noted" and the work in hand carries on. Every new session, from any assistant, lists what is open; one claims an item before starting so no other session starts it too, and closes it with a one-line note. It is not a memory (a memory is a fact) and not a work claim (a claim is now).
Memory pauses for a few seconds and comes back on its own. A worker that is updating or booting leaves a note saying so, and the session reads it — updating (vX → vY) … memory resumes by itself, no need to restart Claude — instead of declaring the worker dead. The first turn after it is back says so, once. A worker that genuinely will not start is still reported, with the log to look at.
Yes. captain-memo uninstall takes the worker down and sets your worker.env aside as worker.env.bak — keys, summarizer, embedder, anything you added by hand — and the next install prefills every key, endpoint and model from them — nothing to retype, and a headless install asks nothing at all. Your memory stays on disk unless you pass --purge.
Cast off
Installs from the Claude Code marketplace. No account, no config to start.
captain-memo install checks which of your Claude, ChatGPT or Google logins is live on this machine and recommends that one — a headless install takes it without asking. Or point it at a local Ollama model.captain-memo stats.Runs natively on Linux (systemd --user), macOS (a per-user launchd LaunchAgent — no root) and Windows x64 (a per-user Scheduled Task — no WSL, no admin). One CLI, three supervisors; the wizard picks the right one and checks its prerequisites before touching anything. On macOS, brew install sqlite first — Apple's own SQLite cannot load the vector extension. On Windows, 0.43.4 or later, then captain-memo connect once — earlier builds could not reach the Codex and Gemini hooks or the CLI summarizers there.
claude plugin marketplace add kalinbogatzevski/captain-memo