Mnemoverse Docs

Appearance

Make Your Agent Use Memory ​

Connecting Mnemoverse gives your agent the memory tools. It does not guarantee the agent uses them. This page is the difference between "I installed it and nothing happened" and "it remembers everything."

Why your agent ignores memory ​

When you connect Mnemoverse (via the VS Code extension, Claude Code, or an MCP config), your agent gains six tools — memory_read, memory_write, memory_feedback, and three management tools.

But a tool being available is not the same as the agent calling it. On every message the model decides, on its own, whether a tool is relevant — and it decides from the tool's name and description. If nothing in the conversation strongly signals "use memory now," the model often just answers, or uses its own short-term context, and your Mnemoverse memory sits untouched.

The result: you say "remember that we deploy on Railway," the agent nods — and never calls memory_write. Next session it has no idea. The wiring is perfect; the habit is missing.

The fix: make it a standing instruction ​

The reliable way to give the agent that habit is to put a standing instruction in your project's agent-config file. Unlike a tool description (read once, at the moment of a single decision), an instruction in your config is in the agent's context on every turn — so "always use memory" becomes a rule it re-reads each time instead of a coin-flip it forgets.

Add this block to your config (see the per-tool table below for the right file):

markdown
## Mnemoverse Memory — always use it

You have persistent memory across sessions via the Mnemoverse MCP tools
(memory_read, memory_write, memory_feedback). Treat it as required, not optional:

- Recall first. At the start of every task — and whenever the user references a
  past decision, preference, or fact — call memory_read BEFORE answering. Never
  assume a cold start.
- Save as you go. Call memory_write whenever the user states a preference, makes
  a decision, corrects you, or shares a durable fact (stack, conventions, people,
  gotchas) — even without being asked.
- Close the loop. After a recalled memory helped or misled, call memory_feedback
  so retrieval improves over time.

Never tell the user "I don't have memory of that" without first calling memory_read.

That last line matters most: it turns "I don't remember" from a reflex into a prompt to actually check.

Where to put it ​

Drop the block into whichever file your tool reads as standing instructions. If several apply to your setup, the cross-tool AGENTS.md is the most portable home; the tool-specific files take priority where a tool supports both.

ToolFileNotes
GitHub Copilot (VS Code).github/copilot-instructions.mdRepo-level custom instructions; applies in Agent Mode.
Claude CodeCLAUDE.md (project root)Loaded into context every session.
Cursor.cursor/rules/mnemoverse.mdcProject rules; .cursorrules also works on older versions.
Windsurf.windsurf/rules/ (or .windsurfrules)Workspace rules.
Cross-toolAGENTS.md (project root)The emerging shared standard; read by a growing set of agents.

Commit the file so the instruction travels with the repo — every teammate's agent inherits the habit.

Check the current path

Agent-config conventions move fast. If a path above doesn't match your tool's latest docs, follow your tool's "custom instructions" / "rules" documentation and paste the same block there — the content is what matters, not the filename.

No config file? Use the phrases ​

If you'd rather not add a file, you can trigger the tools by hand:

  • To save: "Save this to Mnemoverse memory: …" or "Remember in Mnemoverse that …"
  • To recall: "Check your Mnemoverse memory — what do you know about …?"

This works, but it relies on you remembering to ask. The standing instruction is what makes it automatic.

Verify it's working ​

  1. Add the block (or use a phrase), then tell the agent something durable: "Remember that this project uses pnpm, never npm."
    • It should call memory_write. Ask it to confirm what it stored.
  2. Start a new session and ask: "What package manager does this project use?"
    • It should call memory_read and answer pnpm — without you re-explaining.

If it answers correctly across a fresh session, the habit is in place. If it still guesses, strengthen the instruction (move it higher in the file, or make the "recall first" line more explicit).