A wiki your agent can navigate
Plain markdown files in ~/.archivum, linked to each other, with an _index.md that lists them. Open them in any editor, or let your agent follow the links and search.
Archivum keeps what your agent learns as plain files on your machine: short notes, session transcripts and a small wiki. A background “dream” reviews them, corrects stale facts and proposes better memory. You read the diff and approve it.
npx archivums init
0xda4283f14b487034b90d865aac489994f2c680c4
Free and open source. No account. A dream runs on your own LLM key, or through the agent you already use with no separate key. Nothing leaves your machine until you dream.
archivum recall "how do I run the tests?" \
--limit 3
Your agent writes notes and its sessions are saved as transcripts. A dream looks back over them with hindsight and proposes updates to a small wiki. The next session starts from the approved version.
Claude Code hooks or the MCP server save short notes and session transcripts to ~/.archivum on your machine. Known secret patterns are redacted before anything is written.
Notes and wiki pages are ranked with BM25 keyword search. The agent can also follow links between wiki pages from the index. No embeddings, no vector database.
When you run archivum dream, a model checks the wiki against your transcripts, fixes stale or wrong facts, merges duplicates and links related pages. It writes a proposal, and nothing changes until you apply it.
A short index of the wiki is loaded at session start, so your agent does not have to rediscover what earlier sessions already learned.
Run archivum init and it sets up the hooks and MCP server for the clients it finds. You can also wire things by hand, as shown here.
# one command, every client it finds:
# Claude Code, Codex, Hermes, Cursor, Claude Desktop
npx archivums init
# optional: install the command (the per-prompt recall hook needs it)
npm install -g archivums
# later: review what your sessions taught the agent
archivum dream
archivum apply
dream proposes wiki changes (your own key, or your agent via MCP)
apply writes them to the live wiki, as versions
add --dry-run first to see what init would change; files it edits are backed up
# the MCP server only
claude mcp add archivum -- npx -y archivums mcp
# plus the hooks (the last one needs the installed command)
npm install -g archivums
archivum init --claude-code --prompt-recall
SessionStart loads your context digest into the session
UserPromptSubmit looks up memory before each prompt, only when it matches (optional)
Stop saves the transcript for a later dream
codex mcp add archivum -- npx -y archivums mcp
# so Codex actually uses it: a short block in this project’s AGENTS.md
archivum init --codex
without it, Codex saved and recalled only when told to;
with it, it recalled on its own in our test.
Your own text in the file is kept; a backup is written first.
# init does this for you when it finds Hermes; by hand:
hermes mcp add archivum --command npx --args -y archivums mcp
connects and lists all 17 tools;
a pre_llm_call shell hook can run the same prompt recall.
{
"mcpServers": {
"archivum": {
"command": "npx",
"args": ["-y", "archivums", "mcp"]
}
}
}
remember / update_note / recall / forget
context() // short digest of the wiki
read_document / search_documents / list_documents / related_documents
memory_status / list_notes / document_history / save_transcript
list_proposals / show_proposal // review a dream, read-only
dream_prepare / dream_submit // dream through your own agent, no key
Notes are searchable right away. Dreams turn notes and transcripts into a small wiki and propose fixes. You decide what is applied, and everything stays in files you own.
Plain markdown files in ~/.archivum, linked to each other, with an _index.md that lists them. Open them in any editor, or let your agent follow the links and search.
Each write to the live wiki, from a dream you applied or from you, is recorded. See the history of a page and restore an earlier version.
0dream changes applied without you running apply
Use your own key (Anthropic by default, or any OpenAI-compatible endpoint, including a local router), or let the agent you already run do it through two MCP tools, so no separate key is needed. Either way the result is a proposal you apply yourself. Key runs are estimated first and stop at the token budget you set.
Known patterns such as API keys and tokens are replaced in transcripts, notes and anything a dream writes, before they reach disk.
Replaced with [REDACTED] markers. This catches known patterns, not everything.
A dream only writes a proposal. Read the diff against your live wiki, then apply or reject it. A page changed since the dream started is skipped, not overwritten.
0
Accounts, servers or databases to run
4
Memory layers: transcripts, notes, wiki, context
17
MCP tools, plus a context resource
18
CLI commands, from init to retention
Archivum is open source software that runs on your machine. There is nothing to sign up for. The only thing that costs money is the model you choose to dream with, and you pay that provider directly.
~/.archivumarchivum retention to drop old dreamed transcriptsNot answered here? Read the docs or write to us.
A pass that reads your pending transcripts and notes alongside the current wiki, one analyzer per input and then one organizer. It checks what the wiki claims against what happened, corrects or marks stale facts, merges duplicates and links related pages. The result is a proposal you can diff, then apply or reject.
You do, in one of two ways. With your own LLM key (Anthropic by default, or any OpenAI-compatible endpoint with tool calling, including a local router), archivum dream prints a rough estimate, asks before it proceeds and refuses runs estimated above your token budget. Or, with no key, you ask the agent you already run to dream: it calls dream_prepare and dream_submit and the work uses that agent's own tokens. Either way nothing is applied until you run archivum apply, and without a key and without asking your agent, no dream runs and nothing is sent anywhere.
Yes. It is an AI model working from your transcripts, so quality depends on the model you use and it can get things wrong. That is why changes are reviewed before they are applied, every applied write is a version you can restore, and transcripts are treated as untrusted data: dream agents only get document tools, with no shell and no network.
In ~/.archivum (or $ARCHIVUM_HOME), as markdown and JSON files, with one folder per space. Nothing leaves your machine except the calls to the LLM you configure when you dream. Dreamed transcripts are removed after 30 days by default.
BM25 keyword ranking over notes and wiki pages, plus the wiki’s index and links that the agent can follow. There are no embeddings and no vector database, so a query that shares no words with a memory will not find it.
The Claude Code hooks are built against its documented hook format. The MCP server speaks standard MCP over stdio, but it has not been tested in every MCP client. Agents without hooks can store a session with the save_transcript tool or archivum log. Verified so far: the official MCP SDK client, omp, Hermes, and Claude Code (MCP and the dream tools). In one Codex test, Codex saved, deduplicated, updated and stored sessions through Archivum, but only used it on its own after init --codex added instructions to the project's AGENTS.md; the Claude Code hooks have not been run.
The simulation plays out memory and dreaming in your browser. Recorded mode uses a scripted example and runs no model. Live mode sends your chat text through this site’s server to a model, under usage caps paid by the site owner, and may be switched off.
Limited. The eval/ folder has a small synthetic check, not a benchmark, and it does not prove dreaming improves memory for your agent. Read the diffs before you apply them.