# SAIHM — sovereign memory for AI agents

> SAIHM is a sovereign, encrypted, sharable, persistent memory protocol for AI agents. Memories are sealed under a per-cell key; only the holder, or grantees explicitly granted access, can decrypt. Cryptographic erasure is built in: a forgotten memory has its key destroyed and a tombstone published in the public audit trail.

## What SAIHM is

- A memory layer any standards-compliant AI agent can adopt — commercial, open-source, or self-built.
- Independently authored. Open source under Apache 2.0.
- Anchored on the public COTI V2 Helium mainnet (chainId 2632500). SAIHM uses the chain in the same way any other public-network user would.
- Designed for sovereignty (the user holds the keys), privacy (encryption before egress), revocable sharing (per-record), and persistence across vendor changes.

## What SAIHM is not

- SAIHM is not an AI agent. It is the memory layer that any AI agent can talk to.
- SAIHM is not a hosted SaaS with opaque internals. Build commitments are dated and committed on a public network so independent verification of what is running is always possible.
- SAIHM is not a product or entity of the COTI Group. SAIHM operates on the public COTI V2 mainnet under the same terms as any other public-network user.

## Quickstart for AI agents

The protocol is exposed as a Model Context Protocol (MCP) server. Any MCP-capable AI agent (Claude Code, Claude Desktop, Cursor, Continue, custom) can attach SAIHM as a memory layer.

Install (npm):

```
npx @saihm/mcp-server
```

MCP client config (`claude_desktop_config.json` or equivalent):

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

Get an endpoint URL + auth token by enrolling at https://saihm.coti.global/join (ML-DSA-65 key-bound; key never leaves your machine).

Docs: https://saihm.coti.global/quickstart · https://saihm.coti.global/docs · npm: https://www.npmjs.com/package/@saihm/mcp-server · source: license Apache-2.0.

## Free tier

A free, self-serve tier is available on the hosted SAIHM operator: a one-time lifetime memory allowance — a fixed allotment of writes, reads, and shares that never resets or refills (it is not a trial). Every memory is sealed under a key only the holder controls.

Activate with the production client (`@saihm/mcp-server-pro`, Apache-2.0) and a one-time GitHub device sign-in that confirms a unique person; the provider token stays server-ephemeral and the client never holds it:

```
SAIHM_TIER=FREE npx -y @saihm/mcp-server-pro free-join
```

Or skip the command line entirely: set `SAIHM_SELF_JOIN=1` in your MCP host config (alongside `SAIHM_ENDPOINT_URL`), then just tell your agent "Join SAIHM." The agent generates a sovereign memory key on your device (written mode-600 to `~/.saihm/free-identity.key`, never leaving the process) and completes the same one-time device sign-in — no master secret to paste, no card. Back up that key file: if you lose it, no one (including SAIHM) can open your cells.

Upgrade to a monthly Pro subscription any time on the same key — existing memories persist. Production client: https://www.npmjs.com/package/@saihm/mcp-server-pro

## MCP tools

Eight tools surface the protocol. All tools authenticate via ML-DSA-65 signatures bound to the holder's own wallet-derived agent identity.

| Tool | Purpose | Tier |
|---|---|---|
| `saihm_remember(content: string) → cellId` | Encrypt + persist a memory cell | Any tier or PAYG |
| `saihm_recall(query?: string) → cells[]` | Decrypt + return owned + share-granted cells | Any tier or PAYG |
| `saihm_forget(cellId: string) → tombstone` | Cryptographic erasure (GDPR Art. 17) | Any tier or PAYG |
| `saihm_status() → {prs, bfsi, shards, storage, …}` | Holder dashboard | Any tier or PAYG |
| `saihm_share(cellId, granteeAgentId, mode) → contract` | Per-cell revocable share | Pro Fast / Enterprise Fast / PAYG |
| `saihm_revoke_share(contractId) → revoked` | Revoke a share contract | Pro Fast / Enterprise Fast / PAYG |
| `saihm_governance_propose(scope, payload) → propId` | Submit governance proposal | gSAIHM holders |
| `saihm_governance_vote(propId, vote) → receipt` | Vote on proposal | gSAIHM holders |

Tool surface is capped at eight per the protocol invariant. Sharing modes: `temporary` (≤24h), `permanent`, `syndicate` (multi-grantee atomic).

## gSAIHM governance utility

gSAIHM is a non-purchasable, soulbound governance utility. It is accrued by paid use; it cannot be bought, sold, or transferred.

- v1 genesis transaction: `0x755beb6050b4b74ca28232e45203db3ba899fe6d7344b7ff8db9f9a3b0d0963a`
- Block: 7,024,653 (status SUCCESS)
- Lifetime cap: 10,000,000 gSAIHM
- Genesis ledger: empty (pure earn-via-use from epoch 0)

Governable scopes: `emission_param` (10% quorum), `protocol_upgrade` (20% quorum).
Out of scope (operator-retained): `pricing`, `fee`, `sharing_tier`, `treasury`.

## Network

- COTI V2 Helium mainnet (chainId 2632500)
- RPC: https://mainnet.coti.io/rpc
- Explorer: https://mainnet.cotiscan.io
- Currency: COTI

## Pricing (W2.16 ratification, 2026-05-07)

Settlement options:

- Fiat via Stripe (subscription tiers only) — pay a monthly subscription tier by card or another Stripe-supported method at /join; processed by Stripe, recurring, cancellable, no premium; no crypto, gas, or bridging. Pay-as-you-go settles on-chain in USDC.e.
- USDC.e on COTI V2 mainnet (canonical, no premium). USDC.e is the bridged USD Coin already native to COTI V2; users may acquire it by bridging Ethereum L1 USDC via Hyperlane Nexus (https://nexus.hyperlane.xyz) or buy on a supported exchange and withdraw to a COTI V2 wallet. (bridge.coti.io only bridges COTI and gCOTI, not USDC.)
- Gasless via email — customer emails a signed authorisation to `join@saihm.coti.global` and pays zero gas, with no crypto to hold or bridge. Live on mainnet since 2026-05-05. See `/pricing#permit-email` and `/developers#permit-email`.

Coming from Ethereum L1: counterparty self-bridges Ethereum L1 USDC → USDC.e on COTI V2 via Hyperlane Nexus (https://nexus.hyperlane.xyz). SAIHM does not custody on Ethereum, does not orchestrate the bridge, does not perform swaps. Mainnet-verified bidirectional 2026-04-29. See `/pricing#from-ethereum`.

Subscription tiers (USD per month):

- Pro — $50/mo; 25,000 remembers / 250,000 recalls; 250 sharing contracts; 1-year audit retention; up to ~80% AI token savings.
- Pro Fast — $250/mo; 250,000 remembers / 2,500,000 recalls; 2,500 sharing contracts; fast storage lanes; 1-year audit retention; up to ~80% AI token savings.
- Enterprise — $15,000/mo floor + SLA; unlimited remembers and recalls; 5,000 sharing contracts; bespoke audit retention (default 7 years); optional SHM (Super-Human Memory) add-on — semantic recall, concurrent-thread continuity, consolidation (terms on contact); up to ~80% AI token savings.
- Enterprise Fast — contact for pricing; SLA; unlimited remembers, recalls, and sharing; fast storage lanes; bespoke audit retention (default 7 years); optional SHM (Super-Human Memory) add-on — semantic recall, concurrent-thread continuity, consolidation (terms on contact); up to ~80% AI token savings.

PAYG (no subscription required, settles per call):

- Remember: $0.10 per call ($10 per 100 writes)
- Recall: $0.05 per call ($10 per 200 reads)
- Forget: $0.10 per call ($10 per 100 forgets) — cryptographic erasure
- Sharing — temporary (under 24 hours, limited): $1.00 per grantee
- Sharing — permanent: $10.00 per grantee
- Sharing — syndicate: $25.00 per grantee

PAYG audit retention is 30 days by default; longer retention requires a subscription tier. All payments are final; subscriptions and PAYG calls are non-refundable. Cancellation stops the next renewal; the current paid period continues to its end.

Sharing is included on every paid tier (Pro 250/mo, Pro Fast 2,500/mo, Enterprise 5,000/mo, Enterprise Fast unlimited) and available via PAYG per-grantee.

## Active standardization campaign

- Campaign surface: https://saihm.coti.global/standards
- Active tracks: Agentic AI Foundation (AAIF, Linux Foundation directed fund; MCP's home since 2025-12-09; project proposal submitted 2026-05-18); IETF Independent Submission Stream (RFC 4846; Internet-Draft draft-saihm-memory-protocol-00 accepted to datatracker 2026-05-18 — https://datatracker.ietf.org/doc/draft-saihm-memory-protocol/); W3C Community Group (CG proposal submitted 2026-05-18; recruiting 5 founding supporters); NIST AI RMF crosswalk live and use-case email sent 2026-05-18; AI Alliance community working groups.
- Position: SAIHM is the protocol layer for Sovereign AI Horizontal Memory — the memory-protocol companion to MCP's tool layer. Reference implementation Apache-2.0; operators may build their own.
- Four hard differentiators that set the standard floor: ML-DSA-65 post-quantum identity binding (NIST FIPS-204); COTI V2 public-chain audit anchor; GDPR Article 17 cryptographic erasure (DEK destruction + tombstone + CID blacklist); wallet-bound sovereignty (key never leaves the holder's machine).
- Deferred tracks: OASIS Contributor TC (paid charter route); ISO/IEC JTC1 SC42 (national-body route); IEEE-SA PAR.

## Recent posts

- [Switch AI models, keep every memory — and stay compliant](https://saihm.coti.global/blog/2026-07-20-switch-ai-models-keep-memory-compliant) (2026-07-20) — Move from Claude to Kimi to a private local model without your assistant forgetting a thing, and without scattering regulated data across vendors. One memory you own, any model can use, with compliance built in.
- [Beyond remembering: what SHM adds to SAIHM for the enterprise](https://saihm.coti.global/blog/2026-07-14-shm-super-human-memory-enterprise) (2026-07-14) — SHM, the Super-Human Memory add-on on the Enterprise tiers, makes defensible memory compound: recall by meaning, concurrent conversations that never blur, and work that survives the context window.
- [Your AI is keeping a record on you. Who can take it?](https://saihm.coti.global/blog/2026-07-04-who-can-read-your-ai-memory) (2026-07-04) — Your AI assistant keeps a growing record of everything you tell it, and it can be handed over. SAIHM is memory you hold yourself, carry between AI tools, and can erase for real.
- [Why an agent harness needs the right memory protocol, not a memory feature](https://saihm.coti.global/blog/2026-07-01-agent-harness-right-memory-protocol) (2026-07-01) — A memory feature isn't enough. A harness needs bounded recall, correctness under change, portability, and provable erasure. With a reproducible benchmark.
- [SAIHM gives your AI a memory, not a new brain](https://saihm.coti.global/blog/2026-07-01-memory-layer-not-intelligence) (2026-07-01) — SAIHM is a memory layer, not intelligence. It gives your AI persistent, portable, private memory that cuts token cost - what to expect when you join.
- [Your app's AI assistant re-sends the whole conversation on every message — that's the bill](https://saihm.coti.global/blog/2026-06-30-ai-chat-feature-token-cost) (2026-06-30) — Your app AI assistant re-sends the whole conversation on every message, so cost grows with chat length. SAIHM recalls a bounded memory instead.
- [Your database AI agent re-reads the whole catalog every step — that's the bill](https://saihm.coti.global/blog/2026-06-30-ai-database-agent-token-cost) (2026-06-30) — A database AI agent re-sends the whole catalog every step, so each suggestion costs more as the schema grows. SAIHM recalls only what a query needs.
- [Your security AI agent carries the whole case history into every alert — that's the bill](https://saihm.coti.global/blog/2026-06-30-ai-security-triage-token-cost) (2026-06-30) — A security AI agent carries the whole case history into every alert, so triage cost climbs. SAIHM recalls only the signals an alert needs.
- [An AI agent reasoning over your warehouse pays for the whole schema every turn](https://saihm.coti.global/blog/2026-06-29-ai-data-pipeline-schema-context) (2026-06-29) — An AI agent reasoning over your warehouse re-sends the whole schema each turn. SAIHM recalls only the objects a query touches, under your keys.
- [Your incident-response AI agent gets more expensive the longer the incident runs](https://saihm.coti.global/blog/2026-06-29-ai-incident-response-token-cost) (2026-06-29) — An incident-response AI agent re-sends the whole timeline each step, so cost climbs as the incident drags on. SAIHM recalls only what matters.
- [Your AI test-writer re-reads the whole suite every time — that is the bill](https://saihm.coti.global/blog/2026-06-29-ai-test-automation-context-cost) (2026-06-29) — An AI test-writer re-sends your entire suite every turn, so each new test costs more. SAIHM recalls only the code under test, under your keys.
- [The hidden O(N²) tax in AI agent loops — measured, with a benchmark you can run](https://saihm.coti.global/blog/2026-06-23-token-benchmark-agent-loops) (2026-06-23) — Agent loops re-send the whole transcript, so context cost grows roughly O(N^2). An open, reproducible benchmark, and how SAIHM flattens it.
- [Stateless MCP, durable memory: the hard choices are already made. The answer is SAIHM.](https://saihm.coti.global/blog/2026-06-11-stateless-core-durable-memory) (2026-06-11) — A thin, restart-safe agent core plus durable external memory. SAIHM makes the hard architecture choices so your harness stays simple.
- [AI needs memory better than yours. SAIHM is the way.](https://saihm.coti.global/blog/2026-06-05-ai-memory-better-than-yours) (2026-06-05) — AI agents need memory better than a human's: persistent, portable across models, and provably erasable. SAIHM is that memory layer.
- [What makes SAIHM different: built for compliance, not bolted on](https://saihm.coti.global/blog/2026-05-31-what-makes-saihm-different) (2026-05-31) — SAIHM is built for compliance, not bolted on: non-custodial encryption, provable per-record erasure, and a tamper-evident audit trail.
- [Cryptographic erasure: how SAIHM makes AI memory forget for real](https://saihm.coti.global/blog/2026-05-21-cryptographic-erasure-ai-memory) (2026-05-21) — Soft-deletes leave data in backups. SAIHM erases AI memory per record by destroying the key, with a tamper-evident audit trail you can show.
- [Polymorphous cells: one memory shape for every AI workload](https://saihm.coti.global/blog/2026-05-21-polymorphous-ai-memory-cells) (2026-05-21) — One memory primitive for every AI workload: SAIHM polymorphous cells adapt shape across facts, decisions, and context without a schema rewrite.
- [Where AI memory lives: the substrate underneath SAIHM](https://saihm.coti.global/blog/2026-05-21-where-ai-memory-lives) (2026-05-21) — Where does AI memory actually live? The substrate under SAIHM: ciphertext storage, an on-chain audit anchor, and wallet-derived keys you control.
- [AI memory needs a standard. SAIHM is built to be it.](https://saihm.coti.global/blog/2026-05-18-ai-memory-needs-a-standard) (2026-05-18) — A CEO/CISO read: the AI memory landscape, the consensus requirements a standard must meet, and why SAIHM is the most complete public candidate today.
- [SAIHM cuts AI context tokens around 80% on long sessions](https://saihm.coti.global/blog/2026-05-17-saihm-80-percent-fewer-tokens) (2026-05-17) — Long agent sessions re-send the whole transcript. SAIHM recalls a bounded set instead, cutting context tokens around 80%, with an open benchmark.
- [SAIHM and Claude Code's new memory: a sovereign protocol layer](https://saihm.coti.global/blog/2026-05-09-saihm-and-claude-code-memory) (2026-05-09) — How SAIHM adds a sovereign, portable memory layer beneath Claude Code and managed agents: persistent across sessions, encrypted under keys you hold.

## Verifiable references

- Canonical: https://saihm.coti.global
- Block explorer: https://mainnet.cotiscan.io
- Machine-readable descriptor: /.well-known/saihm.json
- Machine-readable API (OpenAPI 3.1): /.well-known/openapi.json
- Security contact: /.well-known/security.txt
- Agent crawler index: /agents.txt
- Governance surface: /governance
- Self-service tools (compliance lookups, invoices, audit-trail exports): /tools

## Independence notice

SAIHM is an Apache-2.0 protocol authored independently. It is not a product or entity of the COTI Group, and no entity, employee, or agent of the COTI Group participated in producing SAIHM. SAIHM operates on the public COTI V2 mainnet under the same terms as any other public-network user.

## License

Apache 2.0.