Give your agent memory

Most agents forget everything when the session ends. The Penumbra Memory MCP gives any MCP client persistent, governed memory: what your agent learns today it can recall tomorrow, across sessions and across clients, with provenance. It is a deliberately small surface — four tools that wrap Penumbra’s memory plane and nothing else. No graph administration, no shape authoring. Just memory.

Connect

The server is at:

https://memory.pnbr.io/mcp

Claude Code
Cursor / JSON

claude mcp add --transport http memory https://memory.pnbr.io/mcp

Run a memory tool and the client walks you through the browser login (OAuth).

OAuth clients need only the URL:

{
  "mcpServers": {
    "memory": {
      "url": "https://memory.pnbr.io/mcp"
    }
  }
}

For headless setups, pass your Penumbra API key as a bearer token instead:

{
  "mcpServers": {
    "memory": {
      "url": "https://memory.pnbr.io/mcp",
      "headers": {
        "Authorization": "Bearer pnbr-..."
      }
    }
  }
}

The four tools

Tool	What it does
`memory_remember`	Store one explicit memory, typed by `kind` (preference, decision, fact, lesson, observation, signal) and shared by `scope` (agent, commons, project).
`memory_recall`	Search active memory. Returns memory entities and their adjacent edges, with temporal filters and depth modes.
`memory_synthesize`	Turn recalled memory into a concise briefing, with the underlying memory ids inspectable.
`memory_archive`	Retire a stale memory from default recall. Not a deletion — the lineage is preserved.

The loop

Tell it something worth keeping

“Remember that I prefer short briefings with explicit caveats.”

The agent calls memory_remember and the preference lands in your graph’s memory plane, typed and scoped.

Ask in a fresh session

Tomorrow, in a new conversation — or a different MCP client connected to the same account:

“How do I like my briefings?”

The agent calls memory_recall and answers from the memory it stored yesterday.

That is the success state: your agent knows tomorrow what you told it today, in a session that no longer exists, from a client that never saw the original conversation.

Beyond explicit memory

The Memory MCP covers explicit, in-session memory cheaply. Two paths extend it:

Ambient memory from transcripts. The SDK’s pb.memory.observe digests a whole conversation or session log into many memories at once. It runs a full extraction (the model-spend path), which is why it is deliberately not exposed as an MCP tool — you run it from code, where you own the bill. Everything observe captures lands on the same memory plane, so memory_recall surfaces it alongside what was remembered explicitly.
Your own memory model. The default memory shape is a shape like any other. Fork it in the Workbench, add the fields your domain remembers, and both the SDK and the Memory MCP write and recall through your variant.

Memory in the SDK

remember, observe, recall, synthesize, and archive from code.

Fork the memory shape

A domain-specific memory model your tools conform to.

​Connect

​The four tools

​The loop

​Beyond explicit memory

​Next