Universal Memory Protocol – a shared format for agent memory

Agents can already call tools (MCP) and talk to each other (A2A). What they can’t do is carry memory across sessions, agents, and vendors. Every harness reinvents memory privately and non-portably. UMP fixes that.

In simple terms: you already have useful memories scattered across agent files, Claude/Codex project notes, Recall exports, Obsidian folders, Postgres, Redis, SQLite, and vector databases. UMP turns those into one portable memory shape and one small operation set, so new agents and new stores can extend the same memory instead of starting over.

Use the MCP server when you want agent memory immediately. Use the TypeScript SDK when you are building a memory-aware app or agent runtime. Use HTTP when the client is Python, Go, Swift, a browser, or anything else that can send JSON.

// MCP host config: Claude Code, Codex, Cursor, or any MCP client.
{
  "mcpServers": {
    "ump": {
      "command": "npx",
      "args": ["-y", "@universalmemoryprotocol/core", "ump-memory"]
    }
  }
}

import {
  JsonFileStore,
  UmpServer,
  generateKeyPair,
} from "@universalmemoryprotocol/core";
const key = generateKeyPair();
const store = await JsonFileStore.open(".ump/memory.ump.json");
const ump = new UmpServer({
  name: "my-agent",
  version: "1.0.0",
  conformance: "L2",
  store,
  key,
});
await ump.remember({
  kind: "procedural",
  body: { text: "Use pnpm for this repository." },
  scope: { owner: key.did, project: "github.com/acme/app", visibility: "private" },
  provenance: { actor: key.did, actor_kind: "user", method: "user_correction" },
});
const memories = await ump.recall({
  query: "package manager",
  scope: { owner: key.did, project: "github.com/acme/app" },
});

# Any language: expose JSON over HTTP.
UMP_HTTP=4000 npx -y @universalmemoryprotocol/core ump-memory

import requests
base = "http://localhost:4000"
owner = requests.get(f"{base}/.well-known/ump.json").json()["owner"]
requests.post(f"{base}/ump/remember", json={
    "kind": "semantic",
    "body": {"text": "User prefers concise release notes."},
    "scope": {"owner": owner, "project": "github.com/acme/app", "visibility": "private"},
    "provenance": {"actor": owner, "actor_kind": "user", "method": "user_correction"},
}).raise_for_status()
hits = requests.post(f"{base}/ump/recall", json={
    "query": "release note preference",
    "scope": {"owner": owner, "project": "github.com/acme/app"},
}).json()["results"]

UMP is not a new transport protocol. It is an application-level memory protocol that rides existing transports. The lesson of MCP is *minimal primitives

• existing rails + great SDKs + neutral governance*.

UMP is a protocol surface, not a database bet. @universalmemoryprotocol/core ships practical implementations for local files, SQL databases, Redis, Recall, and vector engines so teams can adopt UMP where they already store memory.

People already have memory scattered through AGENTS.md, CLAUDE.md, Recall exports, Obsidian notes, and project Markdown. UMP keeps those formats separate, but ships import bridges that turn them into portable UMP drafts with provenance.

UMP standardizes structure, provenance, access, and trust. It deliberately leaves intelligence - extraction, ranking, decay, consolidation - to the engine underneath, so implementations compete on quality while staying interoperable.