DEV Community: SAIHM-Admin

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

SAIHM-Admin — Sun, 31 May 2026 04:14:45 +0000

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

2026-05-09 · SAIHM

Anthropic shipped two memory features in early May 2026. Auto Dream for Claude Code consolidates project memory: it converts relative dates ("yesterday") into absolute timestamps, prunes contradicted facts, and merges insights so that a long-lived project file stops decaying after twenty sessions. Memory in Claude Managed Agents went to public beta the same week, surfacing per-agent memory as files that developers can export and edit through the API or the Claude Console.

Both are good shipments. Auto Dream solves a real failure mode — the moment your project memory file picks up a "yesterday we decided to use Redis" line that becomes ambiguous a week later, or a stale "API uses Express" entry from before the Fastify migration. Managed Agents memory makes the API-level story concrete: memory as files, not as an opaque vendor blob.

This post is not a comparison. SAIHM is a memory protocol, not a memory feature inside any one vendor. The two are designed to compose, and that is the point.

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:

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.
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 "
      }
    }
  }
}

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

Independence notice. SAIHM is an Apache-2.0 protocol authored independently. It is not affiliated with Anthropic, and Anthropic did not participate in producing this post. References to Auto Dream and Claude Managed Agents memory are based on Anthropic's public release coverage in early May 2026.

SAIHM cuts AI tokens 80%, lifts output 5x — SAIHM

SAIHM-Admin — Thu, 21 May 2026 02:48:20 +0000

SAIHM cuts AI tokens 80% and lifts output 5x

2026-05-17 · SAIHM · ~6 min read

Since we built SAIHM and adopted it for our own daily AI work, our token spend has dropped 80 percent and our output has risen roughly 5x. Same humans. Same AI tools. Same tasks. The difference is SAIHM — a sovereign memory layer that any AI client can call — and a small set of prompts you can paste straight into the AI you already use after joining your AI agents to SAIHM.

This post hands you those prompts. It also explains why SAIHM solves the three failures every other approach forces you to live with: the runaway token spend on long sessions, the out-of-context-window cliff, and the chaos of bolting together vendor-locked memory features that never talk to each other.

Read in order. The first section delivers the savings.

Have a question while reading? Ask the SAIHM chatbot embedded on this page (bottom-right corner) for an immediate, specific answer. It is the same SAIHM protocol described in this post, answering questions about itself in real time.

1. SAIHM prompts that maximise token economy

Every long AI reply re-reads itself. That re-reading is what you pay for. SAIHM stops it.

The opening move: tell SAIHM to load only what matters

Use SAIHM to recall only what is relevant to {today's task}.
Do not re-read the rest of our history.

On a 50,000-token conversation, this single SAIHM prompt typically cuts the cost of the next reply by 70–90 percent. Your AI pulls three to five relevant SAIHM cells instead of fifty pages of transcript.

The closing move: have SAIHM remember the decision, not the discussion

Save this decision to SAIHM in one sentence,
tagged {project-name}.

Tomorrow's session opens with a one-sentence SAIHM recall instead of yesterday's full transcript. Compounded over a week, this is the single biggest contributor to the 80 percent reduction.

The mid-session move: a SAIHM summary you can re-load anywhere

Ask SAIHM to summarise what we have decided so far
in under 200 words, tagged {project-name}.

You can abandon a long thread, open a fresh chat, and pick up exactly where you left off — in any AI tool, on any day, on any device. The SAIHM cell travels with you.

The status check: see what SAIHM is doing for you

Show me my SAIHM status.

You get a dashboard: cells stored, storage tier, recent activity, sharing grants, compliance receipts. No spreadsheets, no accounting. One sentence in, one summary out.

Why this works. SAIHM stores each fact as its own encrypted cell. Recall pulls only the cells that match. The AI never reads your whole history unless you ask it to. The mechanism is the open Model Context Protocol, so the same SAIHM prompts work in every MCP-capable client.

2. SAIHM solves the out-of-context-window problem

Every AI has a context window. The window is finite. SAIHM is not.

The context window is your AI's short-term memory. SAIHM is its long-term memory. Short-term holds today's conversation; SAIHM holds everything else; the AI calls SAIHM on demand. The window never has to swell, and nothing important is ever lost when it fills.

The "resume kit" pattern

Open any large project session with:

Use SAIHM to recall the resume kit for {project-name}.

Close it with:

Update the SAIHM resume kit for {project-name}.
Capture decisions, blockers, and what to do next.

Sessions can now run for weeks across multiple AI tools. Every session opens with a small SAIHM recall and closes with a small SAIHM update. The window stays small. The project advances.

The "do not lose this" pattern

When you sense the context window is about to fill:

Before we get cut off, save the critical state to SAIHM
so I can continue this in a fresh session.

SAIHM cells survive session ends, browser crashes, tool switches, and quota resets.

The "switch tools without copy-paste" pattern

Started in one AI client, want to finish in another:

Save everything I need to continue this work
in another AI tool to SAIHM.

Open the second client connected to the same SAIHM endpoint:

Use SAIHM to recall the work I was just doing.

Your memory is portable because the protocol is portable. The AI tool is incidental.

3. Capabilities only SAIHM gives you

SAIHM does more than any other approach — for less effort, with simpler prompts.

Cryptographic erasure you can prove

Use SAIHM to forget the cell tagged {sensitive-topic}.
Prove it is gone.

This is not a vendor delete. SAIHM destroys the key that decrypted the cell and writes the destruction event to a public chain. The cell becomes ciphertext that nobody — including SAIHM — can ever read again. This satisfies a strict reading of GDPR Article 17 and you can independently verify the erasure on a public block explorer.

Encrypted storage you alone can open

Every SAIHM cell is encrypted at write time under a key derived from your wallet. The ciphertext is shard-distributed across Filecoin and IPFS — durable, censorship-resistant, globally available. Decryption requires two things together: the key your AI Agent holds (because it holds the wallet), and access to the Filecoin or IPFS network. Without both, the cell is unreadable. SAIHM the operator cannot read your memories. The storage networks cannot read them. Only your AI Agent can.

Polymorphous cells: structured in, unstructured out (and vice versa)

Save this table to SAIHM as structured data,
then summarise it back as a written paragraph.

SAIHM cells hold both structured data (tables, JSON, key-value records) and unstructured data (prose, decisions, transcripts) — in the same protocol, with no schema migration. Input in one form, request output in another, or vice versa: a CSV in, a paragraph out; a paragraph in, a JSON record out; a description in, a structured ticket out. Truly polymorphous memory cell storage. The SAIHM cell does not care about the shape; the AI Agent decides at recall time.

Scope-bound sharing in one sentence

Use SAIHM to share my {project-name} cells with {teammate's agent},
read-only, expires in 7 days.

Time-bound, scope-bound, revocable. Revoke any time:

Revoke the SAIHM share I gave {teammate's agent}.

Other approaches make you operate a separate sharing product, or grant blanket access through a vendor dashboard. SAIHM gives you the same outcome in one prompt.

Shared SAIHM memory for distributed AI agents

Sharing SAIHM cells across multiple AI Agents compounds the savings, accuracy, and efficiencies. Globally distant agents stay in sync without manual exchange: each one calls SAIHM for the latest shared cells before acting. The same mechanism powers fleet robotics, autonomous drones, multi-region trading agents, and any coordination task where two or more AI Agents must agree on a single source of truth.

Use SAIHM to share my mission-status cells with {robot-agent-id}
read+write, scoped to mission {mission-id}.

Every agent that holds the share reads and writes the same SAIHM cells. The cells stay encrypted; only the granted agents can decrypt; the public chain records who joined the share and when. Coordination becomes a SAIHM recall, not a network round-trip.

One wallet per AI Agent (recommended)

SAIHM memories are bound to the wallet that wrote them. The AI Agent reads and writes its memories through that wallet. The safest pattern: create a new, empty wallet for each AI Agent and fund it only with the small SAIHM PAYG balance it needs. Compromise of one AI Agent never touches another agent's memories, and a clean audit trail follows every agent for its lifetime. Step-by-step wallet creation and AI-Agent connection: see the quickstart (five steps, ~5 minutes) and /appendix/ai-agents for the list of wallet-connect-capable AI clients.

Compliance-grade audit, on by default

Use SAIHM to export the audit trail for {project-name}
for the last 90 days.

Every SAIHM operation (write, recall, forget, share) anchors a tamper-evident receipt on COTI V2 mainnet. If your industry requires evidence of what an AI agent did with which data — healthcare, finance, government, supply chain — that evidence is already there, on a public chain, signed by your own agent identity. You did not have to bolt on a logging product. SAIHM did the work.

One protocol, every AI client

The same SAIHM prompts work in Claude Code, Claude Desktop, ChatGPT (via an MCP bridge), Cursor, Continue, custom agents, and any client that speaks the Model Context Protocol. Your memory follows you. The vendor does not own it. SAIHM is Apache 2.0 and self-hostable if you ever want to.

4. Freedom from the chaos other solutions force on you

SAIHM is synonymous with simplicity. Here is what you escape.

Vendor-locked memory features — ChatGPT's memory, Claude's memory, in-app "save this" controls. They forget when you switch tools. SAIHM does not.
Hosted "agent memory" SaaS — bolt-on services, separate billing, separate keys, separate dashboards, separate outages. SAIHM is one protocol, one key, one prompt vocabulary.
Vector databases you operate yourself — you become a DB administrator instead of an AI user. SAIHM has no infra for you to run.
Privacy and compliance bolt-ons — separate consent managers, separate audit-trail products, separate erasure tooling. SAIHM ships all three on the same protocol.

The architect's measured outcome — 80 percent fewer tokens, roughly 5x more output — is what happens when you replace four moving parts with one. SAIHM does more, for less, with less effort.

5. Join SAIHM and try the prompts above in your own AI

If you are still on a hosted-vendor memory feature, or you are juggling multiple memory products that never talk to each other, the fastest comparison is the one you run yourself, on a real task, using the prompts in this post.

Join SAIHM at /join. Enrolment is a few clicks. PAYG and paid tiers available; see /pricing.
Connect your AI client to the SAIHM endpoint — one block of configuration, copy-paste from the quickstart page.
Paste the SAIHM prompts above into whichever AI you already use. Measure the next reply's token count against a fresh chat without SAIHM. The savings are visible in the first session.

SAIHM does more than every alternative and asks less of you. Join SAIHM and see it in your own AI client.

Join SAIHM

Still have questions? The SAIHM chatbot is on every page (bottom-right). Ask it anything about the prompts, the protocol, wallets, sharing, compliance, or pricing — you will get an immediate answer.

Independence notice. SAIHM is an Apache-2.0 protocol authored independently. It is not affiliated with OpenAI, Anthropic, Google, Perplexity, or any AI client vendor. The 80 percent token-spend reduction and ~5x productivity uplift are internal metrics measured by the SAIHM author team on their own workloads since adopting SAIHM, and will vary by usage pattern. Pricing and tier details are on /pricing.