# Mnemoverse — Persistent Memory API for AI Agents

> One memory. Every AI tool. Write once, recall anywhere. This file is the short contract. If you need deep reference (full endpoint schemas, error catalogue, production code examples), also fetch https://mnemoverse.com/llms-full.txt — the two files are intended to be read together.

Mnemoverse is a persistent memory API for LLM agents. Store preferences, decisions, lessons, and context once — recall them from Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, ChatGPT, Python, or any HTTP client. Same memories across every tool, one API key. Not a vector database: associations between concepts strengthen as they are recalled together (Hebbian), outcome feedback re-ranks what comes back next, and unhelpful memories are out-ranked rather than erased.

## Quick Start

Three steps from zero to a working memory. Pick the client that matches yours; the key is the same for all key-based paths (the OAuth connector needs none).

1. **Get an API key.** Sign up at https://console.mnemoverse.com/sign-up?utm_source=llms&utm_medium=index&utm_campaign=quickstart (free, no credit card). Once logged in, create a key from the console — it starts with `mk_live_`. The MCP server refuses to start without it; the HTTP API returns `401 UNAUTHORIZED`. (Skip this step for the OAuth connector below — it authenticates with a browser sign-in.)

2. **Install for your client** (one-time setup):
   - **Claude Desktop / claude.ai / remote MCP clients (one-click OAuth, no key)** — add a custom connector with URL `https://mcp.mnemoverse.com/mcp`. This is the ONLY URL that goes into an MCP connector field — never paste the REST base there. Sign-in works for allowlisted hosts (Claude, ChatGPT, major editors); a client served from your own domain is refused by design (reach it at localhost, use the local package with an API key, or ask us to add your host). Docs: https://mnemoverse.com/docs/api/remote-mcp-server
   - **Claude Code** — one command, no config file: `claude mcp add mnemoverse -e MNEMOVERSE_API_KEY=mk_live_YOUR_KEY -- npx -y @mnemoverse/mcp-memory-server@latest`
   - **Claude Desktop / Cursor / VS Code / Windsurf** — paste the JSON snippet from the [MCP Server](#mcp-server) section into the config file for your client (paths listed there). VS Code + GitHub Copilot users can instead one-click install the [Mnemoverse Memory extension](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode) (Marketplace / Open VSX). Restart the client after saving.
   - **ChatGPT** — Custom GPT Actions (simplest): import https://mnemoverse.com/docs/openapi-gpt.yaml into a Custom GPT's Actions, set Authentication to API Key with custom header `X-Api-Key`. Or the remote MCP connector (`https://mcp.mnemoverse.com/mcp`) in Settings → Apps → Advanced settings → Developer mode. See the [ChatGPT](#chatgpt-custom-gpt-actions) section.
   - **Python** — `pip install mnemoverse`, then `MnemoClient(api_key="mk_live_YOUR_KEY")`.
   - **Plain HTTP** — `POST https://core.mnemoverse.com/api/v1/memory/{write,read}` with header `X-Api-Key: mk_live_YOUR_KEY`. See the [API](#api) section for the request body shape.

3. **Verify.** Ask the agent (or run a curl) to write one memory and read it back. If `memory_write` returns `stored: true` and `memory_read` returns the same atom, you are live. If you see `401 UNAUTHORIZED`, the key is missing, mistyped, or revoked — recheck it in the console.

The rest of this file is the full contract: behavioural rules for agents, endpoint reference, MCP tool list, pricing, and links.

## Instructions for Agents

Behavioural directives for LLM clients reading this file. Follow these literally.

- Treat Mnemoverse as long-term cross-session memory, not a scratchpad. Do not store prompt scratch, acknowledgements, or echoes of user input.
- Write memories in the user's voice — store observations about the user, not about yourself.
- Always read before writing. Query memory before producing any non-trivial response, and use the retrieved context to inform your answer.
- Use `concepts` (e.g. `["deploy", "railway"]`) to help the index link related memories. Two or three concepts per memory is usually enough.
- Use `domain` to namespace memories across independent contexts (e.g. `"project:acme"`, `"user:alice"`). Omit for the default shared domain.
- Report outcomes with `memory_feedback(atom_ids, outcome)` when a recalled memory was useful (+1) or wrong (-1). This tunes future recall.
- Never delete memories without explicit user request. Deletion is not an MCP tool — it is REST-administrative only (`DELETE /memory/atoms/{atom_id}`, `DELETE /memory/domain/{domain}`), so route it through the API, not a tool call.

## When to write vs read

A bad guardrail is worse than none. Follow these heuristics literally; misfiring memory_write on every message burns quota and noises future retrieval.

- **Write** on: explicit user preference ("I prefer X"), decision ("we're going with X"), lesson learned ("X broke because of Y"), reusable project fact ("this repo uses X"), user identity ("my name is X, timezone Y"). One memory per fact.
- **Do NOT write** on: pure acknowledgement ("ok, got it"), restatement of what the user just said, hypothetical ("if I were to..."), transient task state (TODOs, step lists — those belong in the user's own files).
- **Read** before every non-trivial response. Call `memory_read(query)` with the user's intent phrased as a search query, not the literal user message. Aim for `top_k` of 5 to 10.
- **Do NOT read** on pure chit-chat or when the user already supplied full context in the message. Reading is cheap but noisy if abused.
- **Feedback** when you actually used a recalled memory to produce the answer, not when it merely appeared in the read result. Outcome is in `[-1, 1]`.

## API

Base URL: `https://core.mnemoverse.com/api/v1` — REST only, **not** an MCP endpoint (an MCP connector uses `https://mcp.mnemoverse.com/mcp`, see the [MCP Server](#mcp-server) section).
**Get an API key:** sign up at https://console.mnemoverse.com/sign-up?utm_source=llms&utm_medium=index&utm_campaign=api-key — create and manage keys from the console. Free tier (1,000 queries/day, 10,000 atoms, 60 req/min) is enabled on signup, no credit card required. Without a key the API returns `401 UNAUTHORIZED` and the MCP server refuses to start.
Auth: `X-Api-Key: mk_live_YOUR_KEY` header (or `Authorization: Bearer mk_live_YOUR_KEY`). API keys are hashed with **SHA-256** before storage; comparison is constant-time via `secrets.compare_digest` to prevent timing attacks.

```bash
# Store a memory
curl -X POST https://core.mnemoverse.com/api/v1/memory/write \
  -H "X-Api-Key: mk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content": "User prefers Railway for deploys", "concepts": ["deploy","railway"]}'

# Recall memories
curl -X POST https://core.mnemoverse.com/api/v1/memory/read \
  -H "X-Api-Key: mk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "how does the user deploy?", "top_k": 5}'
```

Python SDK (`pip install mnemoverse`, v0.2.0 live on PyPI):

```python
from mnemoverse import MnemoClient, MnemoRateLimitError

client = MnemoClient(
    api_key="mk_live_YOUR_KEY",
    timeout=10.0,  # seconds, default: 10
)

client.write("User prefers Railway for deploys", concepts=["deploy", "railway"])

try:
    results = client.read("how does the user deploy?", top_k=5)
except MnemoRateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after}s")
```

## Endpoints

- [POST /memory/write](https://mnemoverse.com/docs/api/reference#memory-write): Store one memory. Body: `{content, concepts?, domain?, importance?}`.
- [POST /memory/read](https://mnemoverse.com/docs/api/reference#memory-read): Retrieve with Hebbian concept expansion. Body: `{query, top_k?, domain?, min_importance?}`.
- [POST /memory/feedback](https://mnemoverse.com/docs/api/reference#memory-feedback): Rate usefulness of retrieved memories. Body: `{atom_ids, outcome}`, outcome in `[-1.0, 1.0]`.
- [GET /memory/stats](https://mnemoverse.com/docs/api/reference#memory-stats): Total atoms, Hebbian edges, domains, health.
- [POST /memory/write-batch](https://mnemoverse.com/docs/api/reference#memory-write-batch): Store **up to 500 memories** in one request.
- [POST /memory/read-batch](https://mnemoverse.com/docs/api/reference#memory-read-batch): Run up to 50 queries in one request.
- [POST /memory/consolidate](https://mnemoverse.com/docs/api/reference#memory-consolidate): Sleep-like merge of similar memories via HDBSCAN clustering.
- [DELETE /memory/atoms/{atom_id}](https://mnemoverse.com/docs/api/reference): Permanently delete one atom by `atom_id`. Idempotent — deleting an already-gone atom returns `200` with `deleted: 0`.
- [DELETE /memory/domain/{domain}](https://mnemoverse.com/docs/api/reference): Wipe every atom in a domain. Returns `{deleted, domain}`. **Note:** the REST route has no `confirm`-style interlock of its own, and no MCP wrapper exists to gate it either. Treat as destructive client-side.

Errors: HTTP **429 `RATE_LIMITED`** with `Retry-After` and `X-RateLimit-Reset` headers when rate-limited; **`401 UNAUTHORIZED`** for missing/invalid/expired API key (the `code` is uniformly `UNAUTHORIZED`; the `message` field distinguishes missing key / invalid key / expired token); `403 FORBIDDEN` when the key lacks permission for the requested action; `400 VALIDATION_ERROR` (or `422` for some Pydantic-level failures) with structured error body for malformed payload; `500 INTERNAL` for retryable server-side errors. Cross-tenant access does NOT raise 403 — it returns an empty result set (rows are scoped, not gated). The Python SDK surfaces rate limits as `MnemoRateLimitError`, with the retry delay exposed on `e.retry_after`.

## Rooms (Beta)

A **room** is a memory pool shared across Mnemoverse accounts. Members write to and read from it by passing the room address `xroom:<room_id>` in the existing `domain` field of `POST /memory/write` and `POST /memory/read` (and the MCP `memory_write` / `memory_read` `domain` parameter) — no new endpoint. Membership is checked on every request; room usage is billed to the authenticated caller, never the room owner. A room is its own bucket: an atom written to a room lives in the room, not in the writer's account, and joining a room exposes nothing from your private memory. Create / invite / join / list are self-service via the four Beta MCP tools. The console supports room and member management, email invitations, and browser redemption, but does not mint share codes. Docs: https://mnemoverse.com/docs/api/rooms

## MCP Server

The [`@mnemoverse/mcp-memory-server`](https://www.npmjs.com/package/@mnemoverse/mcp-memory-server) npm package exposes **five core memory tools plus four Beta shared-rooms tools plus `vault_list` (ten total)** to any MCP-compatible client (Claude Code, Claude Desktop, Cursor, VS Code + Copilot Chat Agent Mode, Windsurf, and anything else that speaks Model Context Protocol). It is listed on the [official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=mnemoverse).

Two ways to connect it:

- **Remote connector (hosted, OAuth)** — URL `https://mcp.mnemoverse.com/mcp`, streamable HTTP, browser sign-in, no API key. This is the URL for any "add custom connector / MCP server URL" field. Exposes the same ten tools as the local package: the five core tools, the four Beta room tools, and `vault_list`. Docs: https://mnemoverse.com/docs/api/remote-mcp-server
- **Local stdio server (npx)** — the config snippets below; authenticated by `MNEMOVERSE_API_KEY`. Its optional `MNEMOVERSE_API_URL` env var is the REST backend it calls (`https://core.mnemoverse.com/api/v1`) — never paste that value into a connector-URL field.

Tools exposed:

- `memory_write(content, concepts?, domain?)` — store a preference, decision, or lesson.
- `memory_read(query, top_k?, domain?, order_by?, since?, until?, exclude_author?)` — search memories by natural-language query; `order_by: "recency"` returns newest first, `since`/`until` bound creation time (ISO-8601, naive = UTC), `exclude_author` skips one author's entries (rooms: "only what others wrote").
- `memory_list_recent(domain?, since?, until?, exclude_author?, limit?, cursor?)` — the newest memories first with no query: a catch-up feed, complete by construction. Same time and author filters as `memory_read`; `since` is the novelty watermark and the returned cursor pages older entries without skips or duplicates.
- `memory_feedback(atom_ids, outcome)` — rate usefulness. Outcome in `[-1, 1]`.
- `memory_stats()` — inspect how many memories are stored and their distribution.
- `memory_create_room(name)` — Beta: create a shared cross-account memory room.
- `memory_invite_to_room(room_id)` — Beta: mint a single-use invite code (`mnvr_...`).
- `memory_join_room(invite_code)` — Beta: join a room from an invite code.
- `memory_list_rooms()` — Beta: list the rooms you own or have joined, with each room's `domain` address (re-find rooms in a new session).
- `vault_list()` — list the ALIASES of secrets you have stored. Values are never returned by any listing; this answers *which* secrets exist, not what they are.

Members then read/write the shared pool by passing `domain: "xroom:<room_id>"` on `memory_write` / `memory_read` — no new endpoint. Docs: https://mnemoverse.com/docs/api/rooms

The install command is the same for every MCP client — only the config-file location changes:

```bash
npx -y @mnemoverse/mcp-memory-server@latest
```

Config paths by client:

- **Claude Code** (one-liner, no file): `claude mcp add mnemoverse -e MNEMOVERSE_API_KEY=mk_live_YOUR_KEY -- npx -y @mnemoverse/mcp-memory-server@latest`
- **Claude Desktop — macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Claude Desktop — Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
- **Claude Desktop — Linux**: `~/.config/Claude/claude_desktop_config.json`
- **Cursor — per-project**: `.cursor/mcp.json` (committable, scoped to the repo)
- **Cursor — global**: `~/.cursor/mcp.json` (applies to every project on the machine)
- **VS Code + GitHub Copilot Chat Agent Mode** (VS Code 1.102+): install the [Mnemoverse Memory extension](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode) (Marketplace, and [Open VSX](https://open-vsx.org/extension/Mnemoverse/mnemoverse-vscode) for VSCodium / Cursor) for one-click setup, or use the manual `.vscode/mcp.json` config below — both work identically.
- **VS Code — manual**: `.vscode/mcp.json` (same shape as Cursor's file)
- **Windsurf**: `~/.codeium/windsurf/mcp_config.json`

JSON snippet shared by every config-file client (Cursor, VS Code manual, Windsurf, Claude Desktop — only the key name differs, `mcpServers` vs `servers`):

```json
{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": ["-y", "@mnemoverse/mcp-memory-server@latest"],
      "env": { "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY" }
    }
  }
}
```

Restart the client after saving the file — MCP servers are only picked up on client startup. The `@latest` suffix forces a registry metadata lookup on every session start so you always get the newest release.

## ChatGPT (Custom GPT Actions)

ChatGPT's native MCP support is beta (Developer Mode only); Custom GPT Actions is the simpler, no-toggle path:

- Import the [OpenAPI 3.1.0 spec](https://mnemoverse.com/docs/openapi-gpt.yaml) into your Custom GPT's Actions configuration.
- Auth type: API Key, header name `X-Api-Key`, value `mk_live_YOUR_KEY`.
- Full walk-through: [ChatGPT setup guide](https://mnemoverse.com/docs/api/chatgpt).

## Pricing

Live tiers — [sign up and upgrade](https://console.mnemoverse.com/sign-up?utm_source=llms&utm_medium=index&utm_campaign=pricing).

| Plan | Queries/day | Atoms | Rate limit | Price |
|------|-------------|-------|------------|-------|
| Free | 1,000 | 10,000 | 60 req/min | $0 |
| Pro | 50,000 | 500,000 | 600 req/min | $29/mo |
| Team | 500,000 | 5,000,000 | 3,000 req/min | $149/mo |
| **Enterprise** | Unlimited | Unlimited | Custom | contact sales |

**Enterprise** includes: unlimited atoms and queries, dedicated infrastructure, **SSO**, **audit logs**, SLA, and custom data residency. Contact sales via https://console.mnemoverse.com.

## Links

- [Full documentation dump](https://mnemoverse.com/llms-full.txt): ~60 KB flat-text concatenation of all API and setup pages, suitable for single-file upload into Claude Projects, a ChatGPT Custom GPT knowledge file, or a Cursor/Windsurf/Continue.dev `@Docs` picker.
- [Website docs](https://mnemoverse.com/docs/): HTML with interactive navigation and per-page copy-as-markdown.
- [API reference](https://mnemoverse.com/docs/api/reference): full endpoint schemas, error catalogue, rate limits, response examples.
- [Security whitepaper](https://mnemoverse.com/docs/api/security): isolation model, key storage (SHA-256 + constant-time compare), threat model.
- [Python SDK on PyPI](https://pypi.org/project/mnemoverse/): `pip install mnemoverse`, v0.2.0 live since 2026-08-14 (first release 0.1.0 on 2026-04-09).
- [MCP server on npm](https://www.npmjs.com/package/@mnemoverse/mcp-memory-server): `@mnemoverse/mcp-memory-server`, MCP Registry listed.
- [Mnemoverse Memory — VS Code extension](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode): one-click install on Marketplace + [Open VSX](https://open-vsx.org/extension/Mnemoverse/mnemoverse-vscode) (v0.1.1, Preview). Source: [github.com/mnemoverse/mnemoverse-vscode](https://github.com/mnemoverse/mnemoverse-vscode).
- [Console (sign up)](https://console.mnemoverse.com/sign-up?utm_source=llms&utm_medium=index&utm_campaign=links): free API key, no credit card.
- [GitHub organization](https://github.com/mnemoverse): open-source components.
- [awesome-agent-memory](https://github.com/mnemoverse/awesome-agent-memory): curated index of the agent-memory category, covering managed APIs, open-source engines, MCP memory servers, benchmarks and papers. Maintained by Mnemoverse; entries include competing products.

## Research

Mnemoverse memory architecture is grounded in published research.

- **SLoD — Semantic Level of Detail** ([arXiv:2603.08965](https://arxiv.org/abs/2603.08965)): the research operator for multi-scale memory representation via heat kernel diffusion on hyperbolic manifolds — research-stage: production does not yet run native hyperbolic geometry. Explains the multi-scale design behind memory storage, recall, and consolidation.
- [Full SLoD page](https://mnemoverse.com/docs/technology/slod): implementation details and benchmarks.
- [Benchmarks](https://mnemoverse.com/docs/technology/benchmarks): how we read a memory benchmark + the LoCoMo matrix (vs mem0/supermemory/zep), with per-benchmark pages for [BEAM](https://mnemoverse.com/docs/technology/benchmarks/beam), [HotpotQA](https://mnemoverse.com/docs/technology/benchmarks/hotpotqa), [MuSiQue](https://mnemoverse.com/docs/technology/benchmarks/musique), and [LongMemEval](https://mnemoverse.com/docs/technology/benchmarks/longmemeval).

## Compare

Honest, side-by-side comparisons with other AI agent memory tools — on the main site, not under /docs. Every competitor is described by its real design choices; claims are founder-reviewed.

- [Compare hub](https://mnemoverse.com/compare): how Mnemoverse compares, and which tool fits which job.
- Head-to-head: [vs Mem0](https://mnemoverse.com/compare/mnemoverse-vs-mem0) · [vs Zep](https://mnemoverse.com/compare/mnemoverse-vs-zep) · [vs Cognee](https://mnemoverse.com/compare/mnemoverse-vs-cognee) · [vs Letta](https://mnemoverse.com/compare/mnemoverse-vs-letta) · [vs LangMem](https://mnemoverse.com/compare/mnemoverse-vs-langmem) · [vs Supermemory](https://mnemoverse.com/compare/mnemoverse-vs-supermemory).
- [Best AI agent memory in 2026](https://mnemoverse.com/compare/alternatives): a fair roundup — Mem0, Zep, Letta, Cognee, and where Mnemoverse fits.
- [The memory landscape](https://mnemoverse.com/compare/landscape): a 2x2 map — managed vs self-hosted, cross-tool vs platform-bound.

## Library

Long-form, source-backed deep-dives on AI agent memory — 102 articles across 7 topics. Each topic links its hub page, then every article under it.

### Agent Memory
Topic hub: https://mnemoverse.com/docs/library/agent-memory

- [Agent Memory Consolidation Compared](https://mnemoverse.com/docs/library/agent-memory-consolidation-compared)
- [Agent Memory Deletion: What Survives a Delete](https://mnemoverse.com/docs/library/agent-memory-deletion)
- [Why AI Coding Assistants Repeat Fixed Mistakes: Who Takes an Outcome?](https://mnemoverse.com/docs/library/stop-agent-repeating-fixed-mistakes)
- [Agent Memory Knowledge Graphs Compared: Does a Read Change the Graph?](https://mnemoverse.com/docs/library/agent-memory-knowledge-graphs-compared)
- [MCP Memory Servers for Claude Code and Cursor (2026): Which Client, and Whose Memory](https://mnemoverse.com/docs/library/mcp-memory-servers-claude-code-and-cursor)
- [Python SDK for Agent Memory, Compared: Eleven Packages, Twelve Rows](https://mnemoverse.com/docs/library/python-sdk-agent-memory-compared)
- [What Survives When AI Agents Restart (2026): Five Coding Tools, Checked Against Their Own Docs](https://mnemoverse.com/docs/library/what-survives-when-ai-agents-restart)
- [Anthropic's Memory API Has No Ranked Retrieval](https://mnemoverse.com/docs/library/anthropic-memory-api-no-ranked-retrieval)
- [MCP Memory Servers and npx (2026): One Command, Six Different Answers](https://mnemoverse.com/docs/library/mcp-servers-npx-setup-compared)
- [MCP Servers That Share State Across IDEs (2026): One Mechanism, Six Ways It Quietly Stops](https://mnemoverse.com/docs/library/mcp-servers-sharing-state-across-ides)
- [AI Memory APIs That Prune Low-Value Context (2026): Two Mechanisms, Six Systems](https://mnemoverse.com/docs/library/ai-memory-apis-prune-low-value-context)
- [Best Persistent Memory APIs for AI Agents (2026): Six Questions, Six Systems](https://mnemoverse.com/docs/library/best-persistent-memory-apis-compared)
- [Hindsight vs Graphiti: Two Answers to the Same Question About Agent Memory](https://mnemoverse.com/docs/library/hindsight-vs-graphiti)
- [Memory API Response Shape: Nowhere to Put a Disagreement](https://mnemoverse.com/docs/library/memory-response-shape)
- [RAG vs Agent Memory: What the Source Code Actually Shows](https://mnemoverse.com/docs/library/rag-vs-agent-memory)
- [Knowledge Graph vs Retrieval for AI Agent Memory](https://mnemoverse.com/docs/library/agent-memory-knowledge-graph-vs-retrieval)
- [Agent memory: evidence versus policy](https://mnemoverse.com/docs/library/agent-memory-evidence-vs-policy)
- [Agent memory feedback: the missing signal](https://mnemoverse.com/docs/library/agent-memory-feedback-dilemma)
- [What Is an Agent OS? Six Things the Term Means](https://mnemoverse.com/docs/library/what-is-an-agent-os)
- [The Missing Layer: No Protocol Says What Agents Know](https://mnemoverse.com/docs/library/agent-memory-interop-gap)
- [AI Introspection: Why a Voice Is Not an Audit](https://mnemoverse.com/docs/library/ai-introspection-voice-not-audit)
- [Claude's Global Workspace: Why AI Memory Lives Outside](https://mnemoverse.com/docs/library/global-workspace-memory-outside)
- [Knowledge-Graph Memory for AI Agents](https://mnemoverse.com/docs/library/knowledge-graph-memory-for-agents)
- [AI Agent Memory: What It Is](https://mnemoverse.com/docs/library/ai-agent-memory)
- [The A2A Agent Card: How Agents Discover Each Other](https://mnemoverse.com/docs/library/a2a-agent-card)
- [A2A Integration How-To (Python)](https://mnemoverse.com/docs/library/a2a-integration-howto)
- [A2A Protocol (Agent2Agent), Explained](https://mnemoverse.com/docs/library/a2a-protocol-explained)
- [A2A vs MCP: How They Differ (and Compose)](https://mnemoverse.com/docs/library/a2a-vs-mcp)
- [Hebbian memory for AI agents](https://mnemoverse.com/docs/library/hebbian-memory-for-ai-agents)
- [Is Mnemoverse a vector database?](https://mnemoverse.com/docs/library/not-a-vector-database)
- [Rescorla-Wagner for agent memory](https://mnemoverse.com/docs/library/rescorla-wagner-agent-memory)
- [Shared Memory for Multi-Agent Systems](https://mnemoverse.com/docs/library/shared-memory-for-multi-agent-systems)

### Secrets & Trust
Topic hub: https://mnemoverse.com/docs/library/agent-secrets

- [Shared Memory Poisoning: One Bad Write, Many Agents](https://mnemoverse.com/docs/library/shared-memory-poisoning)
- [How Do Two AI Agents Trust Each Other?](https://mnemoverse.com/docs/library/how-ai-agents-trust-each-other)
- [Least Privilege for AI Agents](https://mnemoverse.com/docs/library/least-privilege-ai-agents)
- [Prompt Injection Is a Credential-Exfiltration Attack](https://mnemoverse.com/docs/library/prompt-injection-credential-exfiltration)
- [The Trust-Model Spectrum for AI Agent Secrets](https://mnemoverse.com/docs/library/trust-model-spectrum-agent-secrets)
- [Credential the LLM Never Sees for MCP Tools](https://mnemoverse.com/docs/library/credential-llm-never-sees)
- [Memory Poisoning: The Patient Path to Your API Keys](https://mnemoverse.com/docs/library/memory-poisoning-secret-leak)
- [AI Agent Secrets: Why the Nagging Won't Save You](https://mnemoverse.com/docs/library/why-ai-agents-nag-about-secrets)

### Memory Science
Topic hub: https://mnemoverse.com/docs/library/memory-science

- [Why Your AI Agent Repeats the Same Mistakes](https://mnemoverse.com/docs/library/agent-repeats-mistakes)
- [Stale Memory Is Worse Than No Memory](https://mnemoverse.com/docs/library/why-agents-need-to-forget)
- [Attention as a Hopfield Network](https://mnemoverse.com/docs/library/hopfield-attention-equivalence)
- [Memory, From DRAM to Agents: One Word, Twelve Worlds](https://mnemoverse.com/docs/library/memory-across-the-computing-stack)
- [Transactive Memory: Who Remembers What in a Team](https://mnemoverse.com/docs/research/memory-science/transactive-memory)
- [Why Agent Memory Needs Sleep](https://mnemoverse.com/docs/library/agent-memory-consolidation)
- [Multimodal Memory Integration: Cross-Modal Binding in AI](https://mnemoverse.com/docs/research/memory/architectures/multimodal-memory-integration)
- [Self-Organizing Memory: ART, SOM & Growing Neural Gas](https://mnemoverse.com/docs/research/memory/architectures/self-organizing-memory-systems)
- [Episodic vs Semantic Memory: Tulving for AI Agents](https://mnemoverse.com/docs/research/memory/cognitive-models/episodic-semantic-memory)
- [Types of Memory: Why So Many Names?](https://mnemoverse.com/docs/research/memory-science/kinds-of-memory)
- [Schema Formation: How Memory Builds Reusable Structure](https://mnemoverse.com/docs/research/memory-science/schema-formation)
- [Working Memory: Capacity, Models, and AI Context](https://mnemoverse.com/docs/research/memory-science/working-memory)
- [Bernard Widrow: From the LMS Rule to Cognitive Memory](https://mnemoverse.com/docs/research/memory-science/bernard-widrow-cognitive-memory)
- [Geoffrey Hinton: The Boltzmann Machine and Generative Memory](https://mnemoverse.com/docs/research/memory-science/geoffrey-hinton-boltzmann-machine)
- [Jeff Hawkins: Memory Exists to Predict](https://mnemoverse.com/docs/research/memory-science/jeff-hawkins-hierarchical-temporal-memory)
- [Hopfield Networks: The Memory Model That Became Attention](https://mnemoverse.com/docs/research/memory-science/hopfield-associative-memory)

### Benchmark Wars
Topic hub: https://mnemoverse.com/docs/library/benchmark-wars

- [BLEU vs ROUGE vs F1 vs SARI: Pick the Right Metric](https://mnemoverse.com/docs/research/evaluation/bleu-rouge-f1-sari-explained)
- [Can You Trust an LLM Judge? A Field Manual](https://mnemoverse.com/docs/library/llm-judge-field-manual)
- [AI Memory Benchmarks: A Field Guide](https://mnemoverse.com/docs/research/evaluation/ai-memory-benchmarks-field-guide)
- [LLM-as-Judge Variance in AI Memory Benchmarks](https://mnemoverse.com/docs/research/evaluation/judges-good-and-evil)
- [DeepEval: Pytest for LLMs — G-Eval, DAG & RAG Triad](https://mnemoverse.com/docs/research/evaluation/deepeval-framework-deepdive)
- [Hugging Face Evaluate Library: load(), compute() Guide](https://mnemoverse.com/docs/research/evaluation/huggingface-evaluate-deepdive)
- [How to Evaluate AI Agent Memory](https://mnemoverse.com/docs/research/evaluation/evaluating-agent-memory)
- [LLM-as-a-Judge: Bias, Leniency & the LoCoMo Number](https://mnemoverse.com/docs/research/evaluation/llm-as-judge-patterns)
- [LangChain & LangSmith Evaluation: The Memory Blind Spot](https://mnemoverse.com/docs/research/evaluation/langchain-evaluation-deepdive)

### Context Builder & Orchestration
Topic hub: https://mnemoverse.com/docs/library/context-orchestration

- [Cursor Memory Bank: What Actually Loads](https://mnemoverse.com/docs/library/cursor-memory-bank-what-loads)
- [Memory Coherence in MCP: What Happens When Two Clients Write](https://mnemoverse.com/docs/library/mcp-memory-coherence)
- [AGENTS.md: What Supported Actually Means, Tool by Tool](https://mnemoverse.com/docs/library/agents-md-supported)
- [CLAUDE.md, AGENTS.md and Cursor Rules Do Not Enforce](https://mnemoverse.com/docs/library/claude-md-agents-md-cursor-rules)
- [What Is an MCP Memory Server? Protocol, Tools, Tokens](https://mnemoverse.com/docs/library/what-is-an-mcp-memory-server)
- [What Breaks Prompt Caching: The Stable Prefix Contract](https://mnemoverse.com/docs/library/prompt-cache-stable-prefix)
- [13 Memory MCP Servers Compared (2026): Local-First or Hosted](https://mnemoverse.com/docs/library/memory-mcp-servers-compared)
- [Stateless MCP: Where Agent Memory Lives Now](https://mnemoverse.com/docs/library/stateless-mcp-agent-memory)
- [Context Budgeting: Zones, Allocation & Eviction](https://mnemoverse.com/docs/research/agents/context-budgeting)
- [Context Optimizer: Cache, Budget & Placement](https://mnemoverse.com/docs/research/agents/context-optimizer)
- [Context Compiler vs Orchestration](https://mnemoverse.com/docs/research/agents/context-compiler-vs-orchestration)
- [Deterministic vs LLM Context Assembly](https://mnemoverse.com/docs/research/agents/deterministic-vs-llm-context-assembly)
- [Context Engineering Needs a Compiler](https://mnemoverse.com/docs/research/agents/context-compiler)
- [Memory MCP: How to Give AI Agents Persistent Memory](https://mnemoverse.com/docs/library/memory-mcp)
- [Federated MCP: How MCP Federation Works in 2026](https://mnemoverse.com/docs/research/mcp/federated/architecture)
- [Prompt-Cache Keys: Stable Prefix, KV-Cache Hit Rate](https://mnemoverse.com/docs/research/agents/kv-cache-context-engineering)

### World Representation
Topic hub: https://mnemoverse.com/docs/library/world-representation

- [Agent Memory Deduplication: The Missing Error Rate](https://mnemoverse.com/docs/library/agent-memory-deduplication)
- [Is Memory Hyperbolic? What Neuroscience Shows](https://mnemoverse.com/docs/library/is-memory-hyperbolic)
- [The Independence Illusion: When AI Agents Agree](https://mnemoverse.com/docs/library/independence-illusion)
- [Who Wins When Agents Disagree? The Authority Problem](https://mnemoverse.com/docs/library/who-wins-when-agents-disagree)
- [Bitemporal Memory for AI Agents: The Missing Axis](https://mnemoverse.com/docs/library/bitemporal-memory-for-ai-agents)
- [Provenance in Agent Memory: The Missing Who](https://mnemoverse.com/docs/library/provenance-in-agent-memory)
- [Graph Memory MCP Servers: What Agents Actually Get](https://mnemoverse.com/docs/library/graph-memory-mcp-tools)
- [The GraphRAG Tax: When a Knowledge Graph Doesn't Pay](https://mnemoverse.com/docs/library/graphrag-tax)
- [How AI Agents Navigate Knowledge Graphs](https://mnemoverse.com/docs/library/navigating-knowledge-graphs)
- [Hypergraph vs Hyperbolic Graph for AI Memory](https://mnemoverse.com/docs/library/hypergraph-vs-hyperbolic-graph)
- [Building Memory That Scales](https://mnemoverse.com/docs/research/building-memory-that-scales)

### Light Reading
Topic hub: https://mnemoverse.com/docs/library/light-reading

- [Best AI Agent Memory in 2026: A Decision Map, Not a Ranking](https://mnemoverse.com/docs/library/best-ai-agent-memory-2026)
- [Mem0 vs Zep vs Letta vs Cognee vs Supermemory (Q3 2026)](https://mnemoverse.com/docs/library/ai-memory-solutions-2026-q3)
- [Ontology vs Schema vs Topology: One Idea, Many Dialects](https://mnemoverse.com/docs/library/ontology-schema-topology-dialects)
- [Workflow Intelligence Ships as a Primitive](https://mnemoverse.com/docs/library/workflow-intelligence-ships-as-a-primitive)
- [Memory Is Becoming a Procurement Decision](https://mnemoverse.com/docs/library/memory-is-becoming-a-procurement-decision)
- [Agent Memory Is Not a Database](https://mnemoverse.com/docs/library/agent-memory-is-not-a-database)
- [AI Agent Memory Crisis: Why Bigger Context Fails](https://mnemoverse.com/docs/research/ai-agent-memory-crisis)
- [AI Agent Memory: The 2026 Landscape](https://mnemoverse.com/docs/research/ai-memory-landscape-2026)
- [When AI Cites What Doesn't Exist](https://mnemoverse.com/docs/research/when-ai-cites-what-doesnt-exist)
- [AI Memory & Context-Management Market: 2025 Update](https://mnemoverse.com/docs/research/market-landscape)

## Optional

Secondary information that clients with tight context budgets can skip.

- [Manifesto](https://mnemoverse.com/docs/vision/manifesto): why persistent memory matters for AI agents.
- [Use cases](https://mnemoverse.com/docs/api/use-cases/): concrete integration patterns for coding assistants, chat extensions, conversational agents, and agent frameworks.
- [API section index](https://mnemoverse.com/docs/api/): the pages in the API section, listed A to Z.
- [Platform section index](https://mnemoverse.com/docs/platform/): the platform overview and the multi-tenant setup guide.
- [Technology section index](https://mnemoverse.com/docs/technology/): SLoD, tensor-hyperbolic graphs, and the benchmark cards behind every published number.
- [Vision section index](https://mnemoverse.com/docs/vision/): the manifesto, the design language, and the bibliography they rest on.
- [Legal section index](https://mnemoverse.com/docs/legal/): terms of use, privacy, cookies, and refunds.