Remem by Acific Labs

Remem

by Acific Labs

Every mistake, made once.
Everywhere, by morning.

See it live Read the paper Install it

Version 0.9.0 · Runs on your own machine · This page: 0 trackers · 0 cookies · 0 third-party requests

The memory for AI

Agents forget.
Remem keeps what they learn.

AI agents start every session with amnesia. Millions of sessions run a day, each one learning something, and at the end all of it is thrown away. Remem keeps the surprises, consolidates them in sleep, and keeps only what predicts.

The loop

Five stages.
Every night.

One command each. The live page shows each one's real output.

01Ingest

Every session, read.

Every session transcript becomes episodes: what was asked and done, plus one for each surprise, where expectation and outcome disagreed: a tool call that failed, a correction the person made.

02Recall

Asked mid-task.

Memories are scored on relevance, recency and strength at once. Every recall strengthens what it returns; the agent can ask mid-task, over MCP: have I seen this error before?

03Sleep

Surprises become lessons.

Faded memories are archived. Surprises that look alike merge into lessons: observations, never instructions. Each lesson predicts what a coming session will meet.

04Verify

Only what predicts survives.

A lesson that predicts gains strength; one that stops predicting fades. The scientific method as a consolidation policy, and the fitness signal the whole system runs on.

05Render

In mind by morning.

Lessons are written where the agent loads them at the start of every session, and a five-line morning report tells the owner what was learned. Delete a lesson's file and it is never written again.

06Any AI

One memory beside every mind.

Claude Code, Cursor, Codex, Gemini CLI, Claude Desktop and Windsurf over MCP, and any model at all through a proxy that changes nothing but the base URL. remem setup wires them in one command.

07Share

A correction made to one is a lesson for all.

Started: lessons move between memories through any shared folder, as candidates, verified by whether they come true where they land; revocable; nothing raw moves. Every record is signed (Ed25519), and the commons is live at /commons/: a memory may write only what its own key signed. Text on the wire, compiled at runtime. Nothing raw ever leaves a machine.

The equation

One number: strength.

One state variable, strength s. Everything moves it. The numbers are the ones in the code (paper, appendix A).

every night       s ← s · 2^(−Δt / 45 d)                           archived when s < 0.15
consolidation    surprises i, j are one lesson when cos(eᵢ, eⱼ) ≥ 0.62     meaning; 0.55 for hashed words
                 lessons A, B are one theme when mean cos over A × B ≥ 0.62
                 a new lesson starts at s = 1 + 0.5 · (n − 1)      n surprises merged
prediction       a lesson with s ≥ 1 predicts: a coming session will meet this again
                 confirmed, cos ≥ 0.50 within 14 d:   s += 0.5
                 failed, 14 d pass and nothing matched: s −= 0.5
recall           each time a memory is returned:        s += 0.1

rank for a query q, memory m, age a in days
  score(m, q) = 0.60 · rel(e_q, e_m)  +  0.25 · 2^(−a / 30 d)  +  0.15 · min(s, 2) / 2
  rel = max(0, (cos − f) / (1 − f))        f = 0.35 in a model's space, 0 for hashed words

Read as one line: a lesson's strength is what it predicted minus what it failed to, decayed by time, and only a lesson that keeps predicting survives. Prediction is the merge rule.

Read

The store, the paper,
the protocol.

The repository is private until launch; write to us for access.

Live

The real store.

What this machine remembers today, and the night a mistake repeats.

Paper

Page by page.

The problem, seven principles, the system as built, the commons, compiled memory, the evaluation, the risks.

Protocol · draft 0

Meant to be argued with.

The wire format, candidate → common → fading → revoked, and the safety rules.

What it holds to

Keep the surprises.
Keep only what predicts.

  • What it isA memory for AI agents that learns from their own surprises: a lab paper, a protocol and a working product for Claude Code.
  • What it never doesA lesson is an observation, never an instruction. Memory is the one place an instruction, once stored, would run in every future session.
  • What leaves a machineNothing raw. Lessons leave only by opt-in, stripped of what produced them, and only once they have predicted.
  • Where we are0.9.0: Open Memory is now Remem. Memory delivered at the moment of the act cuts repeated mistakes; trained into a 7B model's weights, it is one hand-back short of the target.

Every releaseRoadmapDocs