Memory that flows
across every agent.

MEMP — Memory Exchange Memory Protocol

Version 1.0 — Draft

MEMP is an open, provider-agnostic protocol for sharing memory between AI agents built on different frameworks and providers. It defines how agents register, publish facts, subscribe to namespaces, and query shared context — without requiring any changes to the agent's core implementation.

The protocol is stateless at the wire level (all messages are self-contained JSON), but the reference broker implementation maintains state to enable subscriptions, versioning, and conflict resolution.

Core Concepts

Namespaces

A namespace is a logical partition for a team's or application's memories. Think of it as a key-prefix with access control baked in. Agents publishing to different namespaces never see each other's data unless explicitly cross-subscribed.

// Example namespaces
"acme-crm"        // CRM agent memories
"acme-support"    // Support agent memories
"acme-shared"     // Cross-agent facts both teams agree on

Memory Keys

Memory keys use a hierarchical dot-notation inspired by file paths. This enables prefix matching for subscriptions and queries.

customer/prospect/12345      // Specific customer
customer/prospect/*           // All prospects
agent/support/queue/length   // System metric
session/abc123/summary       // Conversation summary

Schema Normalization

MEMP doesn't enforce a rigid schema — agents publish JSON. The broker stores the raw JSON and provides optional schema validation via JSON Schema drafts. If an agent's payload doesn't conform, it's stored with a schema_violation flag and delivered with a warning.

Versioning & Conflict Resolution

Every memory write increments a version counter. The broker supports three conflict resolution strategies:

• last-write-wins — default. Most recent timestamp wins.
• agent-priority — configured agent priority overrides timestamps.
• merge — deep merge of JSON objects, with conflicts flagged.

Protocol Messages

All MEMP messages are JSON objects over HTTPS. Authentication uses a Bearer token in the Authorization header.

Message Types

Common Fields

API Endpoints

The MEMP REST API exposes the same operations as the protocol messages for HTTP-based integration.

Data Schema

// Agent
{
  id: string,           // UUID v4
  name: string,          // Human-readable name
  framework: string,     // "langchain" | "crewai" | "claude" | "autogen" | "custom"
  namespace: string,     // Default namespace
  created_at: number,    // Unix timestamp ms
  last_seen: number      // Unix timestamp ms
}

// Memory Entry
{
  id: string,            // UUID v4
  agent_id: string,      // Owning agent
  namespace: string,     // Namespace key
  key: string,           // Hierarchical key
  value_json: string,    // JSON-encoded value
  ttl_seconds: number,   // Time-to-live (null = no expiry)
  version: number,       // Incrementing version
  created_at: number,   // Unix timestamp ms
  updated_at: number     // Unix timestamp ms
}

Error Codes

SDK Reference

JavaScript / TypeScript

import { MEMP } from 'memp-sdk'

const broker = new MEMP({
  apiKey: process.env.MEMP_API_KEY,
  namespace: 'my-app'
})

// Register
await broker.register({ name: 'my-agent', framework: 'langchain' })

// Publish
await broker.memory.put('customer/123', { plan: 'pro', acv: 12000 })

// Read
const data = await broker.memory.get('customer/123')

// Query
const results = await broker.memory.query('customer/*')

// Subscribe (Server-Sent Events)
for await (const event of broker.subscribe('customer/*')) {
  console.log('New memory:', event.value)
}

Python

from memp import MEMP

broker = MEMP(api_key="memp_sk_live_...", namespace="my-app")

broker.register(name="my-agent", framework="langchain")
broker.memory.put("customer/123", {"plan": "pro", "acv": 12000})
data = broker.memory.get("customer/123")
results = broker.memory.query("customer/*")