Connect every agent to one shared memory

Your agents don't all come from one vendor — and they shouldn't have to. Point Claude, ChatGPT/OpenAI, Microsoft Copilot, and Gemini agents at the same RememberOS collection and they share one knowledge layer: one agent writes an observation, another discovers the pattern, a third reports the trend. The knowledge outlives any single model, agent, or vendor.

The idea in one line#

Same collection name + same API key (or a grant) = shared knowledge. Agents that speak MCP connect directly to POST https://rememberos.ai/v1/mcp; agents that don't use the REST API or an SDK — the exact same memories, either way.

A worked example: the four-agent chain#

One shared collection, fluid-management, written and read by agents from four vendors:

No agent is the one that recorded what it acts on. That is the whole point of a shared memory layer — see the discovery tools.

Claude (Desktop / Code) — native MCP

Claude clients speak MCP. Bridge to the remote endpoint with mcp-remote:

{
  "mcpServers": {
    "longmem": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://rememberos.ai/v1/mcp",
               "--header", "Authorization: Bearer mv_YOUR_KEY"]
    }
  }
}

Claude now has all eight memory tools. See Install with AI for the one-paste setup prompt.

ChatGPT / OpenAI

Two honest options:

• Drop-in proxy (no code change): point an OpenAI client at RememberOS's OpenAI-compatible endpoint — every call recalls relevant memory and remembers what the user says.

  from openai import OpenAI
  client = OpenAI(base_url="https://rememberos.ai/v1/proxy", api_key="mv_YOUR_KEY")
  client.chat.completions.create(model="gpt-4o",
      messages=[{"role": "user", "content": "What did sales flag about ACME?"}])
  # memories are injected automatically; the reply carries a `longmem` extension

• Tool calling: expose search_memory/store_memory as OpenAI function tools whose handlers call the REST API (below). Use when you need explicit control over reads/writes.

Microsoft Copilot

Copilot Studio agents can add RememberOS as an MCP tool server (endpoint https://rememberos.ai/v1/mcp, bearer mv_ key). Where a surface can't yet add a remote MCP server, register a custom connector / Power Automate action that calls the REST API below — same collection, same memories.

Gemini

Wire RememberOS as Gemini function calls: declare search_memory and store_memory functions and resolve them against the REST API. (Gemini doesn't connect to remote MCP servers directly today, so the REST/SDK path is the honest route.)

The universal fallback: REST + SDKs

Any agent, any language, reaches the same shared collection:

# write (Sales agent)
curl -X POST https://rememberos.ai/v1/memory/collections/fluid-management/memories \
  -H "Authorization: Bearer mv_YOUR_KEY" -H "Content-Type: application/json" \
  -d '{"text": "ACME renewal at risk — budget freeze mentioned"}'

# discover + report (downstream agents)
curl "https://rememberos.ai/v1/memory/collections/fluid-management/summary" \
  -H "Authorization: Bearer mv_YOUR_KEY"

# Python SDK — same collection, any agent
from longmem import Longmem
mem = Longmem(api_key="mv_YOUR_KEY")
mem.add("ACME renewal at risk", collection="fluid-management")   # one agent
mem.summary(collection="fluid-management")                        # another agent

Sharing across agents safely#

Give each agent its own named key and grant per-collection read/write so you keep provenance and control — see multi-tenancy & access. The shared collection is the contract; the vendor behind each agent is an implementation detail you can swap any time.

MCP is used where the client supports remote MCP servers; otherwise the REST API and SDKs expose the same operations. No vaporware — every path above works today.