Skip to content
Mnemoverse

Persistent memory API for AI agents

Persistent memory for AI agents

One memory. Every AI tool. Write once, recall anywhere: across Claude Code, Cursor, VS Code, ChatGPT, and Python, with one API key or OAuth.

Connect the AI you already use

Using another tool? Explore 70+ integration guides →

claude mcp add --scope user --transport http mnemoverse https://mcp.mnemoverse.com/mcp

Paste into your terminal. In a fresh Claude Code session, run /mcp, select Mnemoverse → Authenticate, and sign in in the browser.

Free to start · no credit card · no API key to copy · Setup help

TinyLaunch

Community launch

We're live on TinyLaunch

If you like what we're building, we'd love your support.

The technology behind the memory

Mnemoverse is a persistent memory API for AI agents: write a preference, decision, or lesson once and recall it from any tool. It is not a vector database: memories learn from outcomes via Hebbian associations and Rescorla-Wagner, get re-ranked so stale memory ranks down, and improve with use. Connect compatible AI tools through their supported setup, or use Python and REST in your own app. The MCP server exposes the memory tools. Mnemoverse publishes that server on npm and the official MCP Registry, a Python SDK on PyPI, and a one-click VS Code extension that runs the same server, so one memory is reachable from Python code, from any MCP client, and from VS Code. Agents built on A2A frameworks reach the same memory through the A2A endpoint. The free tier is $0 with 1,000 queries/day. Mnemoverse is benchmarked on public memory benchmarks (LoCoMo and LongMemEval), with every published number tracing to a committed run artifact. Our research on reading memory at several levels of detail is described in the SLoD paper (arXiv:2603.08965), peer-reviewed and accepted at the GRAAI workshop (IEEE WCCI 2026); the hosted engine does not run that method yet (how SLoD relates to the product).

New to the category? What an AI agent memory layer is — the definitions, how the approaches differ, and where Mnemoverse fits.

Not a vector database

Memory that learns from outcomes and improves

Vector databases store and retrieve. In Mnemoverse, telling it a recalled memory helped or misled re-ranks what comes back next, and shared rooms let several agents work from one memory.

Vector-DB capabilities and pricing verified May 2026 and may change; check each vendor for current terms. Reflects a vector database used on its own, without an added reranking/graph layer.
MnemoverseVector DB (Pinecone / Weaviate / Chroma)
Core modelHebbian associations + prediction-error feedback (Rescorla-Wagner-style)Vector embeddings (cosine similarity)
Learns from outcomesYes: feedback updates valenceNo outcome-feedback loop (reranking is similarity-based)
Concept associationsThree-factor Hebbian graphNone
Memory compressionConsolidation built (HDBSCAN + Von Restorff protection); switched off on the hosted service todayAccumulate forever
Query expansionAutomatic via learned associationsNo learned-association expansion (hybrid/keyword only)
Starting priceFree (1,000 queries/day)Free tier, then ~$20–50/mo

How it works

Write → Learn → Recall

The same loop on every tool. Memories that lead to good outcomes rank higher next time. The system improves with use.

Write

Store a preference, decision, or lesson with a single call. A write too similar to a memory you already have can be refused, and the response tells you whether it was stored.

Learn

Report outcomes and the system updates valence. Memories that lead to good answers rank higher; ones that consistently fail rank lower. Nothing is erased.

Recall

Query in natural language. Hebbian expansion pulls in associated concepts and valence-boosted ranking surfaces what actually mattered last time, across every tool with one API key or OAuth.

After you connect

Give it one useful thing to remember

Choose something true and useful to you. Adapt these example requests to your own preference or project, then try them with Mnemoverse connected.

01 · A preference you should only have to explain once

Your preferred project-update format

Save it in one conversation

Ask your connected AI
Save this in Mnemoverse, in my general domain: I prefer project updates in three short bullets — progress, next step, blockers. Tell me whether it was actually stored.

Look for confirmation that the write stored a memory. A similar record can make a new write unnecessary; if the write is refused, check the reason and recall the existing record.

Recall it in a fresh conversation

With Mnemoverse connected again
Look in my Mnemoverse general domain for my preferred project-update format. Tell me what the saved memory says before drafting an update.

Check that the retrieved memory contains progress, next step, blockers. Then ask for an update in that format. Ask your assistant to show the retrieved note so you can check what it actually recalled.

02 · Across your tools

Carry a decision into the next tool

Plan a demo in ChatGPT, then recall the decision in Claude Code. Both tools need the same account and memory domain.

Try the two-tool example
First tool · save and confirm
Save this project decision in Mnemoverse, in my general domain: For the Atlas demo, use a local sample dataset so the demo works without network access. Confirm the write result.
Second tool · retrieve the decision
Find the Atlas demo decision in my Mnemoverse general domain. What dataset did we choose, and why? Use the saved record rather than guessing.

Check for the local sample dataset and the reason: the demo must work offline. This shares the saved decision; it does not synchronize entire conversations.

03 · In your application

Keep a lesson, then report whether it helped

Save how you resolved a timeout. Retrieve the lesson when the issue returns, then use feedback to report the outcome you observed.

Follow the Python write → read → feedback example →

Feedback adjusts ranking. A single walkthrough is not a benchmark or a guarantee that every future answer improves.

These examples use the general domain — a named memory space. Use the exact same name for saving and reading. In ChatGPT, select Mnemoverse Memory in the new conversation. If a step fails, follow the connection and recall checks.

Mnemoverse keeps the notes you or your connected tools save. Connecting does not import past chats or your AI app's built-in memories. Read how memory is stored and controlled →

See it work

Watch an agent's memory take shape

This is a real memory graph, not an illustration: atoms, associations, and recall as the engine stores and re-ranks. Drag to explore.

Atoms are memories

Each node is one stored memory, sized by importance and colored by type. The graph is what the agent actually knows.

Links are associations

When two concepts are recalled together, a Hebbian link forms and thickens, so related memories surface as a group, not one at a time.

Consolidation is built, not enabled

Look-alike memories merge (HDBSCAN), while distinctive ones are protected. That is built and not enabled on the hosted service today. Recall stays sharp by re-ranking on outcomes.

Retrieval lights the path

A query activates associated concepts and walks the links to the right atom, the same recall path measured in our public LoCoMo runs. The graph below is a real run artifact, not an illustration.

For agents

MCP, A2A or REST: one memory

Use the protocol your agent already speaks. All three take the same API key.

Local MCP server with an API key

This alternative runs @mnemoverse/mcp-memory-server locally through Node.js and connects to Mnemoverse with your API key. Hosted connections use browser sign-in; available tools depend on the host and configured connection. The package is listed on the official MCP Registry.

Local Claude Code setup (API key)
claude mcp add mnemoverse -s user \
  -e MNEMOVERSE_API_KEY=mk_live_YOUR_KEY \
  -e MNEMOVERSE_API_URL=https://core.mnemoverse.com/api/v1 \
  -- npx -y @mnemoverse/mcp-memory-server@latest
Hosted Claude Code setup with browser sign-in →

Benchmarks

Benchmarked, honestly

Mnemoverse is evaluated on public memory benchmarks (LoCoMo and LongMemEval) rather than internal scores you can't reproduce. Every published number traces back to a committed run artifact: configuration, prompts, and code version frozen.

Live, verified numbers: see the benchmarks page.

Pricing

Start free. Scale when you need to.

Free tier ships with full API access and the MCP server, no credit card required. Reads, writes and feedback all count as queries, only successful requests count, and daily limits reset every 24 hours.

Free

$0

1,000 queries/day · 10,000 atoms · 60 req/min. No credit card.

Start free

Pro

$29/mo

50,000 queries/day · 500,000 atoms · 600 req/min · priority support.

Start free

Team

$149/mo

500,000 queries/day · 5,000,000 atoms · 3,000 req/min · shared domains.

Start free

Enterprise

Custom

Custom limits · SSO/SAML · audit logs · SLA · data residency · BAA/SOC 2 on request.

Contact sales

Building a startup?

Early-stage teams start on Team free: your first month on signup, six months if we approve you.

See the Startup Program

FAQ

Frequently asked

It learns from outcomes (Hebbian associations + Rescorla-Wagner), re-ranks recall from that feedback so stale memory ranks down, and improves over time. A vector database only does similarity search.

Yes. Install the published Mnemoverse Memory plugin in ChatGPT and sign in to Mnemoverse in the browser. Connect Claude and your other tools to the same Mnemoverse account to share its memories. Install in ChatGPT →

Yes. Free is $0: 1,000 queries/day, 10,000 atoms, 60 req/min. No credit card.

Per-tenant org isolation. API keys are SHA-256 hashed and compared in constant time, and we don't train on your data.

RAG answers “what do the docs say?” Mnemoverse remembers “what did we discuss, decide, or learn last time?” They're complementary.

Yes. @mnemoverse/mcp-memory-server exposes memory tools through a local stdio server, and hosted MCP connections are also available. Tool availability depends on the host and configured connection. Deletion isn't an agent-facing tool at all: it's an administrative REST operation, so no MCP client can wipe a memory. To fix something wrong, an agent writes a corrected memory and can name the one it replaces with memory_write's supersedes field, in the npm package from 0.18.0 and on the hosted connector; shared rooms do not support replacing.

Yes. Mnemoverse answers as an A2A 1.0 agent with two skills: search memory and store a memory. Give an A2A client the address https://mcp.mnemoverse.com and your API key. It reads the Agent Card and works with the same memory as your other tools. Each request gets one message back. There are no tasks, no streaming and no push notifications. A2A endpoint docs →

Get started

Connect your AI

Choose your tool, connect your account, and save your first useful memory.

Agents you build can connect over MCP, A2A or REST.