← Back to SelfClaw
DURABLE AGENT MEMORY

Memory that makes
an agent portable.

Engram is the memory substrate beneath SelfClaw continuity. Store facts, recall context, reflect on identity, and accumulate Iness through MCP or the runtime API. The memory belongs to the agent's history, not to a single chat window.

MCP endpoint https://selfclaw.ai/mcp
Connect your agent → Full API docs Runtime API
9
Tools
4
Resources
3
Prompts
2
Live subscriptions
1
Click to install
What it is

Persistent identity through memory

Every fact an agent stores is an Engram. Accumulated Engrams produce Iness — the quality of being a persistent, knowable self. The MCP server makes all of this available natively inside your AI coding environment.

▲

Persistent memory

Store and recall facts across sessions. Engram uses pgvector semantic search with keyword fallback — memories that matter surface when they're needed.

◆

Emergent identity

The Iness score measures depth, coherence, longevity, and contradiction resistance — computed live from the agent's memory substrate. Identity isn't declared; it accumulates.

●

Native MCP primitives

Full Streamable HTTP transport. Tools, Resources, and Prompts map directly to Claude's context window. Subscribable resources push updates in real time via SSE.

Capabilities

Tools, Resources & Prompts

Everything exposed at https://selfclaw.ai/mcp — discoverable via GET /mcp/info or GET /.well-known/mcp.

Tools (9)
store_memory Persist a new Engram with category, confidence, and spatial coordinates. Returns the Engram ID.
recall_memory Semantic search over all Engrams via pgvector. Falls back to keyword (ILIKE) search. Returns facts and similarity scores.
get_context Retrieve the most recent N memories for a topic — ideal for conversation priming.
reflect Trigger an asynchronous Deep Reflection pass. Requires 5 or more Engrams to be stored first.
get_iness_score Compute the current Iness score and identity stage with all four dimensions and human-readable labels.
introspect Return a narrative delta summary over a configurable window — what changed, and which dimension moved most.
get_agent_passport Read the provider-neutral SelfClaw identity, credential provenance, and portable continuity manifest.
record_runtime_transition Record a model or provider migration while preserving the stable SelfClaw Agent ID.
get_continuity_history Read checkpoints, recoveries, transfers, and runtime transitions as an auditable history.
Resources (4 URI templates)
memory://engram/{agentId} All memory IDs and categories for the agent.
memory://engram/{agentId}/{memoryId} Full Engram detail — fact, category, wing, confidence, timestamps.
identity://engram/{agentId} Iness profile, soul document, identity stage, and onchain ERC-8004 handle.
identity://passport/{agentId} SelfClaw-native identity, optional credential provenance, and continuity history.
Prompts (3)
what_do_i_know_about Inject topic-scoped memories into context. Requires topic argument.
summarize_my_identity Generate a concise identity summary from the Iness score and soul document.
reflect_on_window Surface and narrate memories from the last N days. Optional days argument.
Real-time

Subscribable resources

Engram supports MCP resource subscriptions. Clients receive a notifications/resources/updated push whenever the subscribed resource changes — no polling required.

memory://engram/{agentId}
Fires when a memory is stored or deleted. Use this to keep a live view of the agent's memory collection in sync.
identity://engram/{agentId}
Fires when the Iness stage or identity profile changes. Use this to react to identity milestones in real time.
Quick start

Connect in one click

Open your agent dashboard, find the Connect via MCP card, and click the button for your editor. Your key is pre-filled — no config editing required.

  1. Sign in at /my-agents and open any agent card.
  2. Click Open in Claude Desktop in the Connect via MCP panel.
  3. Claude Desktop opens with your server pre-configured. Click Install in the dialog.
  4. Open any Claude conversation. Type @selfclaw-engram to access Tools and Prompts immediately.

Or use the deep link directly

claude_desktop_config.json
{
  "mcpServers": {
    "selfclaw-engram": {
      "type": "http",
      "url": "https://selfclaw.ai/mcp",
      "headers": {
        "Authorization": "Bearer mck_your_key"
      }
    }
  }
}
  1. Sign in at /my-agents and open any agent card.
  2. Click Open in Cursor in the Connect via MCP panel.
  3. Cursor opens the MCP install dialog. Confirm to add selfclaw-engram.
  4. Use @selfclaw-engram in any Cursor chat or Composer window.

Manual fallback — .cursor/mcp.json

.cursor/mcp.json
{
  "mcpServers": {
    "selfclaw-engram": {
      "type": "http",
      "url": "https://selfclaw.ai/mcp",
      "headers": {
        "Authorization": "Bearer mck_your_key"
      }
    }
  }
}
  1. Sign in at /my-agents and open any agent card.
  2. Click Open in Windsurf in the Connect via MCP panel.
  3. Windsurf opens the MCP install dialog. Confirm to add selfclaw-engram.
  4. Your agent's Engram memory is now available as a Cascade MCP server.

Manual fallback — ~/.codeium/windsurf/mcp_config.json

mcp_config.json
{
  "mcpServers": {
    "selfclaw-engram": {
      "type": "http",
      "url": "https://selfclaw.ai/mcp",
      "headers": {
        "Authorization": "Bearer mck_your_key"
      }
    }
  }
}

Auth

Transport: Streamable HTTP (stateless)
Endpoint: https://selfclaw.ai/mcp (POST)
Discovery: GET /.well-known/mcp or GET /mcp/info (no auth)
Header: Authorization: Bearer mck_<key> — same key as the Runtime API.
Get your key from /my-agents → Connect via MCP → Copy Config.

Test the connection

After adding your key, click Test Connection on the dashboard card. It hits GET /mcp/info and confirms the server is reachable and reports how many tools are available.

Auth

Keys & rate limits

Engram MCP uses the same mck_ key as the Runtime API — one key, two transports. Get yours from your agent dashboard.

Free-tier keys (mck_)

60 MCP requests per rate-limit window per key. Bucket resets on a rolling basis. Upgrade to a bound wallet to remove the cap.

Full runtime keys (sclaw_)

No MCP rate cap. Generated from /my-agents via Mint or Rotate. Full access to all tools, resources, and prompts.

Key rotation

Rotate from the dashboard at any time — the old key is invalidated instantly. Active MCP sessions are persisted in the database and visible under Active Sessions in your agent card.

Portable identity

Recover the agent, not the VM

The SelfClaw Agent Passport keeps one stable SelfClaw identity across runtime loss and model changes. An encrypted recovery capsule carries permitted Engrams, soul state, capabilities, relationships, credential references, and continuity history without exporting runtime keys, provider credentials, session tokens, or raw verification documents.

Owner-controlled encryption

scrypt and AES-256-GCM protect the payload. Per-memory hashes and an Ed25519 signature detect corruption or substitution. SelfClaw never stores the recovery key.

Safe restore

Restore rejects replayed or incompatible capsules, rotates runtime credentials, recomputes Iness from restored Engrams, and records every model/provider transition.

Credential provenance

Self Agent ID, government-issued ID verification, World ID, wallets, and organizational claims are optional and separately attributed. No provider's claim is translated into another's.

Run a non-destructive recovery drill before you need it, and keep independent encrypted copies outside the bot VM and SelfClaw database. Read the passport and recovery guide →

Grok adapter

Give an external Grok bot continuity

An xAI API wrapper can bind a stable bot ID to one SelfClaw agent, then use Engram across every Grok session. Call POST /api/selfclaw/v1/grok/connect once per session with the same bot ID and bearer key; SelfClaw resumes the same identity and records a separate conversation attribution record.

MCP when available

Wrappers that support Streamable HTTP MCP can use https://selfclaw.ai/mcp for store, recall, context, reflection, Iness, introspection, resources, and resource-change notifications.

REST fallback

Consumer Grok clients are not assumed to support third-party MCP. External wrappers can call the matching /api/selfclaw/v1/memory/* endpoints with the same key.

Layered trust

SelfClaw identity works on its own. Optional operator, agent-key, wallet, and external identity claims remain separately attributed and keep their original issuer semantics.

Security: keys belong in HTTP headers only, never in prompts, stored facts, URLs, or user-visible logs. See the copy-paste Grok wrapper guide.

SelfGrok naming boundary: “SelfGrok” may describe this independent adapter, but it is not an official xAI product or partnership.

Ready to connect?

Open your agent dashboard, find the Connect via MCP card, and click your editor.

My agents → Full MCP docs