Product
Not a vector database
Mnemoverse is a persistent memory API for AI agents. Memories learn from how they're used, forget what stops mattering, and improve from outcomes — so recall gets better with use, not just bigger.
The mechanism
Store, recall, and tune memory in one loop
Three calls — write, read, feedback — and the memory layer does the learning. Same memories across every tool, one API key.
Memory that learnsConcepts wire together through Hebbian associations, and a Rescorla-Wagner update tunes how much each link is worth.
Every memory you store carries a few concepts. As memories that share concepts are recalled together, the graph that links them strengthens — a three-factor Hebbian rule. A Rescorla-Wagner update then adjusts the weight of each association by how surprising the pairing was, so frequent-but-trivial links don't drown out the ones that actually predict relevance. The result is an index that gets sharper the more you use it, instead of a static pile of vectors.
Memory that forgetsSleep-like consolidation clusters similar memories with HDBSCAN, while Von Restorff protection keeps the distinctive ones from being merged away.
Accumulating every memory forever is how retrieval gets noisy. A consolidation pass clusters semantically similar memories with HDBSCAN and collapses each dense cluster into a prototype, keeping outliers as singletons. Von Restorff protection guards the distinctive, high-salience memories from being averaged into a prototype — the surprising lesson survives, the hundredth restatement of a routine fact does not. Forgetting here is a feature: it keeps the working set small and relevant.
Memory that improvesReport whether a recalled memory helped, and outcome feedback re-ranks future results.
After you act on a recalled memory, you can report the outcome (a value in -1 to 1). That signal updates the memory's valence: memories that lead to good outcomes rank higher in future queries, and ones that consistently mislead get suppressed. Over time the system converges on the memories that actually work for your agents — a feedback loop a similarity-only store cannot offer.
Automatic query expansionA query for one concept pulls in the concepts it has learned to associate, so you recall the connected memory, not just the literal match.
A read doesn't stop at the literal query. The learned Hebbian graph expands it along its strongest associations — asking about "timeout" surfaces the "backoff" and "retry" memories that earlier reads and feedback linked to it. You get the connected context an embedding-only match would miss, without hand-writing query rewrites or maintaining a separate keyword layer.
from mnemoverse import MnemoClient
client = MnemoClient(api_key="mk_live_YOUR_KEY")
# WRITE — store a memory with concepts
client.write("Retry with exponential backoff fixed the timeout issue",
concepts=["retry", "backoff", "timeout"])
# READ — Hebbian associations expand "timeout" -> "backoff", "retry"
results = client.read("how to handle timeouts?", top_k=5)
# FEEDBACK — outcome tunes future recall
client.feedback(atom_ids=[r.atom_id for r in results.items], outcome=1.0)What happens under the hood
- Write — an importance gate filters noise; the memory is stored with a semantic embedding and its concepts.
- Read — Hebbian expansion broadens the query, then valence-boosted ranking orders the results.
- Feedback — the reported outcome updates valence and strengthens the associations that worked.
- Consolidate — HDBSCAN clusters similar memories into prototypes and keeps the distinctive singletons.
Comparison
What a vector database can't do
Vector stores answer “what's most similar to this query?” Mnemoverse answers “which memories actually matter here?” — and learns the difference from use.
| Mnemoverse | Pinecone / Weaviate / Chroma | |
|---|---|---|
| Core model | Statistical learning (Rescorla-Wagner + Hebbian) | Vector embeddings (cosine similarity) |
| Learns from outcomes | Yes — feedback loop updates valence | No outcome-feedback loop (reranking is similarity-based) |
| Concept associations | Three-factor Hebbian graph | None |
| Memory compression | HDBSCAN consolidation + Von Restorff | Accumulate forever |
| Query expansion | Automatic via learned associations | No learned-association expansion (hybrid/keyword only) |
| Starting price | Free (1,000 queries/day) | Free tier, then ~$20–50/mo |
We don't just store and retrieve. We learn which memories matter.
RAG vs. Mnemoverse
Two different questions
Retrieval-augmented generation
“What do the docs say?”
RAG retrieves the chunks most similar to a query from a fixed corpus. It's the right tool for grounding answers in reference material — manuals, knowledge bases, a codebase. But it has no notion of importance, no links between facts, and no forgetting: every session starts from the same static index.
Mnemoverse
“What did we discuss last time?”
Mnemoverse is persistent, cross-session memory. It remembers the preferences, decisions, and lessons your agents accumulate — links them through learned associations, ranks them by what proved useful, and consolidates the rest away. It complements RAG rather than replacing it: docs ground the answer, memory carries the relationship.
Why this matters
The AI memory paradox
Perfect recall alone doesn't make memory. Memory is a connected model of what matters, at the right level of detail, built as you go.
Abundant information
Vector databases store billions of embeddings. Foundation models compress world knowledge into billions of parameters. Information is plentiful, well stored, and instantly retrievable.
No structure, no experience
Data isn't memory. Without knowing what matters, how facts link, and at what granularity, raw data stays inert. Memory is context, relevance, and traces of past use — it's experience.
The resolution
Mnemoverse adds a self-organizing memory layer between your agent and its history. Every event enters the index immediately — associations form, useful memories rise, redundant ones consolidate — without retraining a model. The layer learns and rewires its connections as your agents work, so the memory you query is the memory that's proven useful.
Why now
Why persistent memory is becoming necessary
The context ceiling
Context windows keep growing, but they lose connections, priorities, and continuity between sessions. Even with a million tokens, most of the window is noise, and nothing persists once the session ends.
RAG's blind spots
Vector search adds retrieval, but no prioritization, no forgetting, and no links between facts. It returns similar data without understanding importance or the connections that turn data into memory.
Models retrain in batches
A model's weights only update on a release cadence. A memory layer that learns in real time lets agents accumulate experience between those releases — the part the base model can't learn on its own.
Evidence
Benchmarked, honestly
The mechanism is published, the client libraries are open, and the evaluation is on public benchmarks you can reproduce.
Benchmarked, honestly
Mnemoverse is evaluated on public memory benchmarks — LoCoMo and LongMemEval — rather than internal scores you can't reproduce. On the public LoCoMo leaderboard, Mnemoverse currently sits at #2.
Live, verified numbers: see the benchmarks page.
Read the math before you commit
Mnemoverse's retrieval is grounded in Semantic Level of Detail (SLoD), published on arXiv and presented at the GRAAI workshop (IEEE WCCI 2026). The client libraries are open source — you can inspect the mechanism instead of taking a vendor's word for it.
One memory. Every AI tool.
Write once, recall anywhere. Free tier is 1,000 queries a day and 10,000 memories — no credit card.