Pinned Tweet
i put claude code and codex side by side and gave them one shared memory.
claude Code saved a few project facts. a brand new codex session recalled them, then corrected one.
a fresh claude code session read the update. two agents from two companies, one memory, with claude's builtin memory off.
the terminal on the right is the proof: one note on disk, same ID in both agents.
that's Archivum: memory that lives as plain Markdown on your own machine. No account, no server, no database.
what else it does:
- a dream checks your wiki against what your agents learned and proposes fixes. Nothing is applied until you review the diff.
- known secret formats are scrubbed before anything is saved.
- every wiki change is versioned, so you can restore an earlier one.
npx archivums init
open source : github.com/tryarchivum/archi…
interactive simulation: tryarchivum.com/try
We have doing buybacks on $ARCH also sending tokens to our @fomo account... fomo.family/profile/Archivum…
We've applied for fomo team tags too there, so will be verified once we getting approved!
1,100+ downloads of `archivums`!
Archivum is growing, and we're grateful to everyone who's been testing it, exploring the code, and giving us feedback.
For those just discovering it:
Archivum gives AI agents long-term memory through plain files on your machine.
→ Short notes and session transcripts
→ A searchable Markdown wiki
→ BM25 memory retrieval
→ Dream reviews that propose improvements
→ You approve every change before it gets applied.
No account. No server. No embeddings.
We're still early, with more improvements coming in the next phases.
Give it a try: `npx archivums init`
npmjs.com/package/archivums
Every download brings us one step closer to making AI memory more reliable and useful.
Archivum takes a deliberately lightweight approach to memory retrieval.
It uses BM25 keyword ranking to search notes and wiki pages.
The search system includes Unicode-aware tokenization, light stemming, and additional weight for page names and titles.
Agents can also navigate the wiki through its index and links.
There are no embeddings, vector databases, or external indexing services required.
For a small, structured memory system, this keeps the architecture simple and makes search results easier to inspect.
For example:
archivum recall "how do I run the tests?" --limit 3
The CLI returns ranked results containing relevant notes or wiki pages.
The trade-off is that keyword search is not semantic search. A query that shares no meaningful words with a saved memory can miss it.
Archivum addresses this partly through Dream's ability to organize and connect related knowledge, but retrieval still has its limitations.
AI agents are getting better at accessing real-time financial data.
But access is only one part of the equation.
They also need memory to retain past research, remember previous findings, and build on what they've learned instead of starting from zero every session.
That's exactly the problem we're working on with Archivum.
Better tools give agents more capabilities. Better memory helps them use those capabilities over time.
How Dream Actually Works? Behind the simple command is a multi-stage process.
1. Select
Archivum selects pending transcripts and unconsolidated notes.
It prints the selected inputs and a rough token estimate before proceeding.
You can limit the amount of information processed and configure a token budget.
2. Stage
The current wiki is copied into a separate proposal workspace.
Archivum also records checksums of the existing pages so it can detect changes made while Dream is running.
3. Analyze
An analyzer agent processes each selected input against the staged wiki.
Large inputs can be split into smaller pieces, allowing the system to extract information from longer histories.
4. Organize
An organizer agent combines the results.
It merges duplicates, resolves conflicts, links related pages, and updates the wiki index.
5. Propose
The updated wiki is saved as a proposal.
Nothing changes in the live memory at this stage.
6. Apply or Reject
The user reviews the diff and chooses what to do.
When applying, Archivum skips files that have changed since the Dream started, rather than blindly overwriting newer edits.
Every applied write becomes a version that can be inspected or restored later.
This makes memory consolidation a controlled process instead of an unrestricted background rewrite.
tryarchivum.com
You can inspect the proposed changes using:
1. archivum proposals
Then review the differences:
- archivum diff
Finally, decide whether to accept or reject the changes:
- archivum apply
or:
- archivum reject
This separation is intentional.
An AI model can suggest what it believes should be remembered, but the user remains in control of what becomes permanent knowledge.
Dream proposes. You review. You decide what stays.
Dream compares the existing wiki against pending notes and transcripts. It can:
- Correct outdated or incorrect facts
- Mark information as stale
- Merge duplicate information
- Resolve conflicting information
- Connect related wiki pages
- Update the central index
Organize information into more useful documents.
But Dream does not directly overwrite the live wiki.
Appreciate the @Larpcheckbot report and the independent look at Archivum.
We're still at the beginning of this journey.
Archivum is a real product, but there's still a lot to build, improve, and refine. We're actively working on the next updates, expanding the memory capabilities, improving the Dream process, and building more utility around the ecosystem.
We don't expect anyone to judge us only by promises.
Keep watching what we ship, test what we build, and hold us accountable as we grow.
This is just the starting point. More work ahead.
Replying to @0xsora226 @Use_Archivum
$ARCH · TOTAL 63/100 · NARRATIVE: LIKELY REAL 70 · COIN: NEUTRAL 55
Real dev tool, thin new coin: top 10 hold 26%, 100 holders.
What checks out:
- Published CLI runs locally
- Package and repo match the post
The agent-memory tool is real: the published CLI saves and recalls notes locally. The model-driven dream step and the site's scripted demo weren't verified as live.
Live chart on Larpcheck: larpcheck.app/0xda4283f14b48…
Holders: 100 holders
In the report: where the top holders' money came from
larpcheck.app/c/pbYjr6Vd0x/l…
Narrative tells you if the story is real, Coin how fair it is to buy. Rugs still happen. DYOR.
Archivum v0.2.12: long-term memory for AI agents (CLI, MCP server, Claude Code hooks) now is live!
Give your AI agent a memory it keeps. Archivum keeps what your agent learns as plain files on your machine: short notes, session transcripts and a small wiki.
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.
github.com/tryarchivum/archi…
Also We're featuring new archivum Roadmap on the site, you can see what's coming next into archivum.
tryarchivum.com/#roadmap
Dream compares the existing wiki against pending notes and transcripts. It can:
- Correct outdated or incorrect facts
- Mark information as stale
- Merge duplicate information
- Resolve conflicting information
- Connect related wiki pages
- Update the central index
Organize information into more useful documents.
But Dream does not directly overwrite the live wiki.
Archivum organizes memory into four layers, each serving a different purpose.
1. Transcripts
Transcripts are append-only records of agent sessions.
They preserve user, assistant, and tool events as raw material for future memory consolidation.
Known secret patterns are scrubbed before transcripts are stored.
2. Notes
Notes are short memories created by an agent or directly by the user.
An agent can save an important discovery using the remember tool, while users can add information through the CLI.
For example:
archivum remember "Run tests with npm run test:unit, not npm test"
These notes become searchable immediately.
3. Wiki
The wiki is where information becomes organized knowledge.
It consists of linked Markdown files, structured around an _index.md file that acts as the table of contents.
You can open these files in any editor, change them manually, organize folders, or even track the wiki with Git.
There is no proprietary document format.
4. Context
Context is the compact layer loaded when a new session begins.
Instead of injecting the entire memory archive, Archivum provides a short digest of the wiki index.
The default context is approximately 4,096 characters, with the Claude Code hook applying a maximum of 10,000 characters.
This keeps the starting context focused on useful knowledge rather than flooding the agent with old conversations.
One of Archivum's most interesting features is called Dream.
Most memory systems focus on collecting information. Archivum adds another step: reviewing that information with hindsight.
As agents work, their notes and session transcripts accumulate.
Eventually, those records may contain duplicate information, outdated instructions, conflicting facts, or knowledge that should be connected to other parts of the project.
Another milestone for Archivum!
We're now officially listed as a Verified Builder on @HeyResearch.
Our project is live on HEY, where our releases, deployments, and real development activity can be tracked automatically.
We believe building in public matters.
Every release, every improvement, and every week of shipping is part of the journey.
Big thanks to the HEY team for recognizing what we're building.
More shipping ahead.
heyresearch.xyz/project/arch…
860+ downloads for `archivums` since launching yesterday!
We're excited to see developers starting to explore Archivum.
For those discovering it, Archivum is long-term memory for AI agents. Archivum keeps what your agent learns as short notes, session transcripts and a small markdown wiki in ~/.archivum. A background pass called a dream reviews them, corrects stale facts and proposes better pages. Nothing changes until you approve the diff. No account, no server, no embeddings: search is BM25 over notes and wiki.
It keeps what your agent learns as plain files on your machine:
→ Short notes
→ Session transcripts
→ A small Markdown wiki
→ Searchable memory with BM25
Its Dream process reviews past sessions, catches outdated information, and proposes better memory.
You review every diff. Nothing changes without your approval.
No account. No server. No embeddings.
Want to try it?
`npx archivums init`
The package is npmjs.com/package/archivums, and the command it installs is npm i archivums.
We're just getting started. More improvements are coming, and we'd love to hear your feedback.
Give your AI agent a memory it keeps.
You can see how archivums works here.
nitter.cf/Use_Archivum/status/21…
every time you start a new coding session, your AI agent forgets what you worked on yesterday.
the decisions, the fixes, the details you already explained. Gone.
We built Archivum to change that. It gives your agent memory as plain Markdown files on your machine. No account, no server, no database.
tell it a fact once and it carries across sessions. When a fact changes, the old note is updated instead of stacking contradictions. Known secret formats are scrubbed before anything is saved.
then there's the dream: it reads your notes and sessions and proposes pages for a project wiki. Nothing is applied until you read the diff and approve it.
i recorded the whole thing in claude code with its built-in memory turned off.
open source : github.com/tryarchivum/archi…
npx archivums init
tryarchivum.com
full demo below ↓
You can track our work/incoming updates through the Github.
github.com/tryarchivum/archi…
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.
Why: the wiki is small and written to be navigated. The model starts from _index.md, follows links and searches by keyword, much like a person with a folder of notes. That needs no extra model, no index service and nothing to send off your machine, and a result can be explained by the words it matched. The trade-off is that purely semantic queries with no shared words can miss; the dream's linking and naming are meant to cover that.
Thank you to everyone trying Archivum and helping us build better memory for AI agents.
Phase 1 is shipped. The core memory workflow is working end to end, and we've already tested memory sharing between Claude Code and Codex.
Now we're moving toward **Phase 2: See it, trust it, control it.**
Here's what's coming:
1. Shared Across Agents — Two-way memory sharing with clear attribution of which agent wrote what.
2. Memory Vault — A local interface to browse, search, review, and restore memories.
3. Better Dream Quality — Sources for every claim, inferred information clearly marked, and page-by-page approval.
4. Suggested Memories — Agents propose what is worth remembering. You decide what stays.
5. Self-Repairing Install — A `doctor` command that detects and fixes installation issues.
No rushed deadlines. Each phase moves forward based on what we learn from real usage.
Want to explore Archivum?
📦 CLI: npmjs.com/package/archivum-c…
We're building in the open. Feedback, testing, and contributions are always welcome. The next step isn't just remembering more. It's making memory something you can actually trust.
Full Roadmap : tryarchivum.com/#roadmap






