AI needs memory better than yours. SAIHM is the way.

Memory drifts

Over weeks and months, an AI's notes quietly fill up with three kinds of trouble: facts that were true once but aren't anymore, conclusions it half-finished and never closed out, and guesses it never actually checked. Left alone, that pile grows — and the assistant leans on it as though every line were equally reliable.

The result is the worst kind of mistake: stated plainly, delivered with confidence, and wrong. Tidier storage alone doesn't fix it. Neither does simply remembering more. What matters is whether the memory carries enough about each note — where it came from, whether it was ever checked — for the assistant to tell good information from bad and act on the difference.

Dreaming is a good start. SAIHM goes further.

This year Claude and other assistants learned to "dream" — to look back between sessions and tidy their own memory, merging duplicates and dropping stale notes. It is a genuine improvement. But a neater copy of your memory is not the same as a more trustworthy one. SAIHM is the memory layer underneath, and it lets your AI agent go further — point by point:

• Dreaming is a periodic pass. SAIHM stays current as you work. A dream is usually a scheduled tidy — a nightly pass. SAIHM consolidates continuously, so the memory your assistant relies on right now is the cleaned-up version, not yesterday's.
• Dreaming reviews a recent batch. SAIHM holds your whole history. A dream typically looks back over a limited window of recent sessions. SAIHM gives your assistant a memory that spans everything you have ever told it — so it can draw on a detail from months ago, and a pattern that only shows up over the long haul isn't lost.
• Dreaming can let a guess become a "fact." SAIHM lets your assistant keep them apart. When notes get merged, an unchecked guess can quietly harden into settled truth. With SAIHM, your assistant can label each memory verified or not, so it only treats something as a confident, reusable fact once that memory is marked confirmed — tidying never launders a guess.
• SAIHM lets your assistant record what was verified — and what was only assumed. Alongside each memory it can note where the fact came from and whether it was checked. That is what lets your assistant tell a confirmed fact from a hunch, and say "let me confirm that" instead of stating a guess with false confidence.
• SAIHM lets your assistant record a correction as a replacement, not an extra note. When two notes disagree, simple tidying leaves both in place. With SAIHM your assistant can write the corrected version so it supersedes the stale one, and retire the old memory — so once a mistake is fixed, it stays fixed and doesn't resurface later.
• SAIHM lets you see whether the memory is getting more reliable. Most clean-up is invisible; you have no way of knowing whether it actually helped. SAIHM's status view keeps score of the memory's health over time — fewer stale notes, more verified facts — so improvement is something you can see rather than take on faith.

The short version: dreaming makes a copy of your memory neater. SAIHM lets your AI agent make the memory it thinks with more reliable — spanning your whole history, honest about what has actually been checked, and self-correcting as you go. A neater copy is not the same as a memory you can trust.

How to switch this on

Joining SAIHM gives your AI agent a sovereign memory it can recall from and add to. The habits above aren't automatic — you turn them on by telling your assistant how to use that memory. Paste these standing instructions into your assistant's system prompt, project instructions, or custom-instructions field:

You have SAIHM - a sovereign, persistent memory you can recall from and add to. Use it as your long-term memory, by these standing rules:

1. Start every task by recalling from SAIHM anything relevant, and treat what you find as your own prior knowledge.

2. When you establish something worth keeping, save it to SAIHM and label it: VERIFIED if you confirmed it, ASSUMED if you have not. Never save a guess as if it were confirmed.

3. Before stating anything as settled, check its label. If it is only ASSUMED, say "let me confirm," verify it, and promote it to VERIFIED only once confirmed or repeatedly borne out.

4. When new information contradicts a stored memory, do not keep both: save the corrected version so it replaces the old one, and note that it supersedes it - so the fix sticks.

5. Consolidate as you go: merge duplicates, retire superseded notes, and keep one clean source of truth drawn from your whole history, not just this session.

6. Now and then, take stock of how reliable your memory has become - fewer stale notes, more verified facts - and tighten it further.

7. Use your memory freely; it persists across sessions and tools, so never re-derive what you have already established.

There's a practical bonus, too. Because your assistant recalls just the memory that's relevant instead of rebuilding everything from scratch each session, it spends far fewer tokens to do the same work — around 80% fewer in sustained use. Less of the context window goes to remembering, so more of it is free for the task in front of it.

That is the whole trick: the intelligence is your assistant's; SAIHM is the memory that lets it consolidate, keep what's verified and what's assumed apart, and correct itself — across every session, and every tool you use next.

Remembering is the easy part

Any assistant can store what you tell it. The one you can actually rely on is the one whose memory spans everything it knows, separates what it verified from what it only assumed, lets it correct its own mistakes, and grows measurably more reliable over time. That memory layer is what SAIHM is built to be.

That is the line between an assistant you tolerate and one you trust.

Go deeper

• For individuals: what sovereign memory means for you
• For organisations: control, compliance, and the right to be forgotten
• How SAIHM compares: /comparison
• Builders & developers: the technical version

SAIHM — the memory layer your AI agent can be trusted to think with.

Join SAIHM

Try it: a drop-in memory contract

Here is the fastest way to feel the difference. Paste this into your agent’s system prompt — it assumes the SAIHM MCP tools saihm_recall / saihm_remember / saihm_forget are wired into your harness. Following it is what produces the savings:

## Memory contract

On every turn, before you act:
1. RECALL, don't re-read. Call saihm_recall with keywords for the task to load a small, bounded set
   of cells. Do NOT re-send prior turns - the recalled cells ARE your context.
2. Prefer the CURRENT fact. If two recalled cells conflict, the most recent /
   non-superseded one wins - never act on a decision a later cell reversed.
3. REMEMBER durably. Call saihm_remember to persist decisions, conventions,
   and constraints as cells - one fact each, in your own words.
4. On a "delete my data" request, call saihm_forget on those cells: erasure
   is per-record and provable, not a soft delete.

Bounded recall flattens the resend curve from O(N²) to O(N·cap) — the 62.8–85.9% fewer context tokens the open benchmark shows. Start with a small recall cap and raise it only if recall misses.