SAIHM and Claude Code's new memory: a sovereign protocol layer for Auto Dream and Managed Agents

Two questions Auto Dream does not answer

When the same agent (or a different agent) needs the same memory tomorrow — on a different machine, or shared with a teammate, or attached to a compliance audit — two questions remain:

1. Whose key encrypts the cells? Anthropic-managed memory is, by construction, readable by Anthropic. That is fine for many workloads. It is not fine for compliance-bound work, sealed-source projects, or any case where the memory itself is the artefact under protection.
2. What proves the cell is gone? When a user invokes the right to be forgotten under GDPR Art. 17, deletion is not the same as cryptographic erasure. A protocol that anchors a destruction event on a public chain can prove erasure. A vendor delete cannot.

SAIHM was built around those two questions. Each memory cell is encrypted under a per-agent data-encryption key (DEK) sealed by a per-agent key-encryption key (KEK), both derived from the user's wallet through canonical HKDF chains. Erasure is a real cryptographic operation: the DEK is destroyed, the cell becomes ciphertext-only nothing, and an audit anchor lands on COTI V2 mainnet. Sharing is a contract — explicit grant, scope-bound, revocable, with a public audit trail.

What SAIHM adds to a Claude Code workflow

The SAIHM MCP server drops into the same configuration any other MCP server uses. Eight tools become available to the agent:

• saihm_remember — store an encrypted memory cell.
• saihm_recall — retrieve and decrypt your memories.
• saihm_forget — cryptographic erasure with on-chain audit anchor.
• saihm_status — protocol-runtime stats and storage tier dashboard.
• saihm_share / saihm_revoke_share — selective, scope-bound, revocable sharing.
• saihm_governance_propose / saihm_governance_vote — protocol governance via gSAIHM.

The same eight tools work from Claude Desktop, Claude Code, custom MCP-capable agents, and any framework that speaks the Model Context Protocol. The memory layer travels with the user, not the vendor.

npx @saihm/mcp-server

{
  "mcpServers": {
    "saihm": {
      "command": "npx",
      "args": ["@saihm/mcp-server"],
      "env": {
        "SAIHM_ENDPOINT_URL": "https://operator.example.com/saihm/v1",
        "SAIHM_AUTH_HEADER": "Bearer <token>"
      }
    }
  }
}

The free tier covers 2,500 writes and 250,000 reads per month, no card required, no time limit. Solo, academic, and open-source workloads stay at zero cost. Pricing for higher tiers is on the pricing page.

Where Auto Dream and SAIHM compose

Auto Dream is a memory-hygiene pass on Claude Code's local memory file. SAIHM is a protocol for sovereign, encrypted, sharable cells. They sit at different layers and do not contend.

A reasonable shape:

• Auto Dream keeps the working set tidy — stale dates resolved, contradictions pruned, day-to-day project memory readable.
• SAIHM holds the cells whose lifecycle the user wants to govern: proofs, audit-bound facts, anything compliance-touching, anything shared between agents, anything that must outlive the choice of model vendor.
• The right to be forgotten resolves to a single MCP call — saihm_forget — that destroys the DEK and anchors the destruction on COTI V2 mainnet.

Cross-agent reuse is the same shape. When a custom agent built outside Claude Code needs to read what Claude wrote, it speaks the same eight tools to the same protocol endpoint, signs with the same agent identity, and reads the same cells — subject to whatever sharing contracts the user has granted.

Try it

• GitHub: github.com/SAIHM-Admin/saihm-mcp
• npm: npmjs.com/package/@saihm/mcp-server
• Developer docs: /developers
• How SAIHM compares: /comparison

Apache 2.0. Eight MCP tools. One protocol. Your key, your cells, your erasure.

Join SAIHM