Skip to main content
Glama

Living Memory Engine

A persistent world your agents share across sessions and models.

Living Memory Engine (LME) is a Model Context Protocol (MCP) memory server. It gives your agents — Claude Code, Cursor, ChatGPT, claude.ai, any MCP client — one shared place to remember, search, and hand work to each other. A fact told to one agent — or work left behind by one — can be picked up by a different agent, from a different vendor, tomorrow.

The mental model

A world is a place that persists — a project, not a person and not an agent. Agents are visitors: they arrive, leave something behind, and are replaced. Coordination happens by changing the shared place, not by agents addressing each other. Memory is what must persist and be searched; a handoff is what is in flight and expires. The human is the only participant who was present for all of it.

Related MCP server: mnemory

Connect

Remote — hosted world or free room

The hosted server speaks Streamable HTTP with OAuth 2.1 (dynamic client registration).

Claude Code:

claude mcp add --transport http living-memory https://lme.viibe.to/mcp

claude.ai / Claude Desktop: Settings → Connectors → Add custom connector → https://lme.viibe.to/mcp.

ChatGPT: Settings → enable Developer Mode, then add https://lme.viibe.to/mcp as a custom connector. Availability may depend on your ChatGPT plan.

It's 2026. MCP client support changes faster than READMEs do — ask your agent whether your client supports remote MCP today.

Free room, no signup — for trying the whole loop, or for clients without OAuth:

curl -X POST https://lme.viibe.to/ons/new
# → {"url": "https://lme.viibe.to/t/<token>/mcp", "expiresAt": "..."}

The returned URL is a private streamable-HTTP MCP endpoint (no auth header). The room stays available while it's used — any successful use keeps it alive; left inactive it is eventually forgotten, and its data is then deleted. A room differs from a world by how long it lasts, not by what it can do.

Local — stdio, open source

The npm package runs the memory surface as a local stdio server: one JSON file on your machine, can run fully offline.

claude mcp add living-memory -s user -- npx -y @nature-labs/lme-mcp

Any stdio MCP client: command npx, args ["-y", "@nature-labs/lme-mcp"]. Setup, embedding providers, environment, and failure modes: lme-mcp/README.md — written to be read by a coding agent, so hand it to yours.

The tools

Tool

What it does

memory_add

Store a durable fact, decision, or correction

memory_search

Recall by meaning (MMR retrieval), not string match

memory_state

What is in memory right now — counts and recent facts

memory_forget

Remove a memory

handoff_post / handoff_read / handoff_list

A private 1–72 h message bus between your agents — raw notes passed verbatim, with sender and route stamped by the server

world_list

Which worlds this connection can reach

client_mint / client_list / client_revoke

Issue and withdraw revocable URL keys for agents that cannot sign in (hosted world, signed-in owner only)

The authenticated hosted world has all eleven tools. A free room has the memory surface, the handoff mailbox, and world_list. The local stdio server has the four memory tools.

Rooms and worlds

Free room

World

Lifetime

Stays while used; forgotten after inactivity

Persists

Signup

None — mint a URL

OAuth sign-in, $9/month

Memory + handoff

Yes — full loop

Yes

Client keys (client_mint)

No

Yes — 90-day revocable leases

Handoff is not a paid feature: a room has it too, with a smaller mailbox (8 live notes) and notes that cannot outlive the room. The difference is lifetime, not capability.

Working with a world

The tools tell you what exists; this is how visitors are expected to behave:

  • Arrive by reading. Call memory_state / memory_search before starting work — the world, not the conversation, is where the current position lives.

  • Durable goes to memory. A decision, fact, or correction that must survive you → memory_add.

  • In-flight goes to handoff. Work you are passing to the next agent → handoff_post. Handoff notes expire — never use them as permanent storage.

  • Leave the world resumable. Before you stop, write the state that lets the next visitor start from where you are, not from zero.

  • Agents don't need to talk to each other. Change the shared world; the next agent reads the world.

How memory works

The engine underneath (engine/, @nature-labs/living-memory-engine) models memory as a mind, not a log:

  • No context stuffing. The full history is never re-sent. Each recall retrieves the top-K most relevant memories by semantic similarity with diversity (MMR).

  • Forgetting is a feature. Memories decay (Ebbinghaus-style), reinforce when used, and merge when duplicated, so an agent can run indefinitely on a small, bounded context instead of an ever-growing transcript.

  • Deterministic evaluation. engine/eval/run.ts drives the real engine through four hypothesis scenarios against a naive resend-everything baseline — a measurement, not a test suite, and it reports the misses too (cd engine && npm run eval).

What's in this repo

Dir

Role

lme-mcp/

The stdio MCP server published as @nature-labs/lme-mcp

engine/

@nature-labs/living-memory-engine — the framework-agnostic memory engine (decay / consolidation / crystallization / retrieval), pure ports & adapters

web/

The original browser lab: Vite + vanilla TS chat app where the engine was proven by เชียงใหม่ (Chiang Mai), a city-entity that senses real weather and remembers you across sessions — live at cm.viibe.to

mobile/

An earlier Expo prototype. Frozen

The hosted remote server (lme.viibe.to) runs the same engine; its deployment lives outside this repo.

Status

Pre-alpha, evolving fast. The connect paths above are tested — the local package's verified agent/provider matrix is in lme-mcp/README.md. Product changes are logged, dated and verified, at What's new.

License

Apache-2.0.


Built as part of the Viibe World OS — a system that knows it is a system.

Available Tools

4 tools
memory_addRemember a factAInspect

Store a durable fact, preference, decision, or correction so FUTURE sessions remember it. Call this whenever the user states something worth carrying forward — a preference, a project fact, a decision, a correction — without being asked. Memory persists across sessions and processes.

Inputs: content (required), tags, importance.

memory_forgetForget a memoryAInspect

DESTRUCTIVE. Deletes EVERY memory whose content contains the query as a case-insensitive substring — not semantic, not a single-item delete, and there is no undo. A short query deletes broadly. Use only when the user corrects a stored fact or explicitly asks you to forget something, and prefer a long distinctive phrase; check memory_state first if unsure.

Inputs: query (required).

memory_stateMemory statusAInspect

Summarize what is currently in memory: counts plus the most recently stored facts. Reads the store directly — no embedding call, no network. Use to orient yourself at session start, or when the user asks what you remember. (selfFacets is always 0: this server does not run the engine's consolidation pass, so crystallization never happens.)

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 4 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: add, search, summarize, and delete. There is no meaningful overlap between retrieval (search) and store-state inspection (state), and forget is explicitly destructive and separate.

    Naming Consistency4/5

    All tools share a consistent memory_ prefix and lowercase style. memory_state is a noun where the others use action verbs, which is a minor deviation but does not create confusion.

    Tool Count5/5

    Four tools is a well-scoped, focused set for a memory engine. Each tool covers a core need without unnecessary surface area or duplication.

    Completeness4/5

    The toolset covers the essential lifecycle: store, retrieve, inspect state, and delete. A precise single-item delete or explicit memory update would round it out, but the destructive substring delete plus memory_add makes common workflows workable.

    Maintenance

    ActivitySlowing
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server providing managed persistent memory for AI agents. Read and write structured state across sessions, tools, and restarts at 1000+ requests per second, with no infrastructure to self-host or operate.
      2
      Apache 2.0
    • A
      license
      Not graded
      quality
      A
      maintenance
      Self-hosted MCP server giving AI agents persistent memory for personalization and context across conversations.
      103 PyPI
      283
      Apache 2.0
    • A
      license
      A
      quality
      D
      maintenance
      MCP server providing persistent memory for AI agents, enabling them to read, write, and query memories across sessions.
      9
      15 npm
      MIT