Roadmap

Last verified against the code: 2026-11-13 (0.9.0)

From one agent's memory to the commons. Each phase has a measurement that says whether it worked (paper §7).

North star

Every mistake, made once, everywhere, by morning, and proven by what agents do. Remem is an advance if an agent with it hands work back less and repeats fewer corrections than with no memory or with normal memory, on frontier models and in real use, if a lesson can end up in the model itself, and if one person's lesson helps another's agent. Those are goals A1–A9 (GOALS.md), each with a target fixed in advance. remem goals checks every one from the evidence; nothing on this page is marked done from memory.

The program, in milestones

Open questions the program answers along the way: why memory up front raises hand-backs (A3); whether a lesson's content adds to the moment (0.7.0: reminder 6% against a bare nudge 9%, p = 0.09); whether a working reminder makes its own lesson fade (a confirmed correction means the agent failed; see below).

Where we left off (2026-10-25)

The state at the end of the fifth day, for whoever picks this up next (a person or an agent):

• 2026-11-13, the site redesigned after Vacuum, not deployed (the owner: "make the remem.acific.com design like vacuum.acific.com"). Built and checked locally at desktop and phone width (home, live, paper, a doc, 404). open.acific.com still shows the earlier design, and remem.acific.com does not exist yet: both the deploy and the new address wait for the owner's word.

• 2026-11-13, 0.9.0: Open Memory is now Remem (the owner: "Remem rename everything"; first "Recall", dropped because the package name and a neighbouring memory tool had it). Done from the owner's Mac, in the repository only: the package and command are remem, settings begin REMEM_, the store is ~/.remem, lesson files are remem-<id>.md; everything from before carries over (MIGRATIONS 0.9.0). Not done, each waiting on the owner or the Linux box: (1) the Linux box still runs the installed 0.8.1 openmemory: git pull, uv tool install --reinstall -q ., then remem setup rewrites its hooks, MCP server and cron line; (2) the site was deployed the same day from the Mac (npm run deploy; open.acific.com serves Remem 0.9.0 and every page compared equal to the build), but its address and the Worker's name (openmemory in wrangler.jsonc) are unchanged, and /paper/OPEN-MEMORY.md now answers 404 (the paper is at /paper/REMEM.md); (3) site/live/snapshot.json is the old one; (4) remem is not on PyPI yet, so the name is not held; (5) scripts/release-check.py has not passed (it needs the Linux box: handbook, cron, hooks). The "last verified" headers were moved to 0.9.0 on the strength of the tests and the docs harness (names, paths, commands, settings), not a full re-read of every page.

• 2026-11-09, the site's templates tidied and deployed (from the owner's Mac, npm run deploy, with the committed site/live/snapshot.json, not a fresh one): one centred frame on every page, a one-row header, readable sizes and greys, a side menu on the docs, code that scrolls instead of wrapping, the paper's headings in Inter, contact at contact@acificlabs.com, and the seven style attributes the CSP blocked turned into classes. The same day the pre-launch gate came off (GATE_PASSWORD deleted at the owner's request): every page is public. The repository is still private. No code or version change (still 0.8.1). The docs harness now warns that every "last verified" line is more than 14 days older than the latest change; that is a re-read of the docs, not a date bump.

• 0.8.0, toward a real advance (paper §7.4, GOALS.md A1–A10, remem goals): the cause of the up-front harm is one line, the delegation tally (pooled over four families: 20% → 34% of replies hand back, p < 0.0001), so agents no longer see it; the Stop reminder was found to push agents past points where asking is right (asking 42% → 16%), so it now has a gate (needs_person) and the boundary in its words, installed on the owner's machine the same day; agents with tools (experiment loop); the first compiled memory (scripts/adapter.py): the habit compiles (5% hand-backs with no reminder) but as a disposition, not a judgement (it stopped asking where asking was right), so A8 is open.

• 0.8.1, memory in the weights at 7B (paper §7.4): scripts/adapter.py on the GPU (AMD's gfx1151 torch); seven runs. Qwen2.5-7B with a 30% boundary share: hand-backs with no memory 26 → 20 of 100 (target 19), asking kept; more pairs tipped it to never asking. Training moves how readily a model asks, not when. Next for A8: contrast pairs (the same situation, with and without what only the person has), a better judge of asking, real pairs from use.

• Live: open.acific.com, public since 2026-11-09 (the pre-launch password is off: the GATE_PASSWORD secret was deleted); /live/ is the real store, rebuilt by scripts/live-snapshot.py before each deploy (npm run deploy from the owner's Linux box).

• 0.3.0, the memory for AI: remem setup (every installed agent, one command), remem proxy (any model; proven in front of Ollama with Qwen3-30B, memory in and corrections out), conversations in the OpenAI, Anthropic and Gemini formats, the open event format (PROTOCOL §0), context, tools, call. remem setup was run on the owner's machine on 2026-10-24 at the owner's explicit request: all four hooks are wired.

• 0.7.0, the first controlled evidence (paper §7.3, results/): on Qwen3-30B, Llama 3.2 3B and Gemma 3 4B, the memory up front raised hand-backs (28% → 36%, p = 0.013), the reminder at the moment cut them to 6% (a bare nudge: 9%). The proxy now delivers memory at the moment by default and keeps reminder pairs for training.

• Toward a real advance, in order: (1) replicate on frontier models and in agent loops with tools, not single replies; (2) the real-world holdout on the owner's machines; (3) the mechanism of the up-front harm (framing, placement, length); (4) compiled memory in the strong sense: a nightly adapter trained on pairs.jsonl, tested on whether the model stops handing back with no reminder at all; (5) transfer: does a lesson from one person's agents reduce hand-backs for another's (the commons), measured the same way.

• 0.6.2 and 0.6.3: remem compare replays history against normal memory. Scored properly (0.6.3 fixed an over-credit): normal memory 0 of 4 repeated corrections at top 3 (177 items), 4 of 4 at top 20 (1,010); Open Memory 3 of 4 with 23 items, 0 wrong alarms. The stop reminder fires at every offer or deferral, one lesson, for any lesson that followed a hand-back (all changed after the replay; the holdout is the test). docs/COMPARISON.md.

• 0.6.1: remem share invite prints one line that installs Remem on another machine and joins the commons (tested through the live site in a blank home); scripts/release-check.py must pass before a release is called done (AGENTS.md rule 17); the version, stuck at "0.2.3" since 0.3.0, is fixed.

• 0.5.0 and 0.6.0: shared records are signed (Ed25519, origin = SHA-256 fingerprint of the key); the commons is live at https://open.acific.com/commons/ (KV, signed writes only, COMMONS_TOKEN until launch) and this machine syncs there every sleep (origin 8e216c8df73bd856, nothing shareable yet). The proxy puts memory first (prefix cache: 4,738 → 237 ms). Codex and Gemini CLI sessions are read natively (experimental, synthetic tests only).

• 0.4.0, sharing: remem share (export, import, sync through a folder, revoke, list); received lessons are candidates verified by the receiving memory's own sessions; confirmations travel back. The owner's store shares nothing yet by default (all three lessons quote the owner). The proxy has the end-of-turn reminder.

• Wired on the owner's Linux box: the SessionEnd hook, the MCP server, the 4 am cron, Ollama with the Qwen3 instruct model (wording) and qwen3-embedding:0.6b (embeddings). The UserPromptSubmit, Stop and PreToolUse hooks are wired (2026-10-24, by remem setup; the previous settings are in ~/.claude/settings.json.before-remem). The experiment is collecting.

• 0.2.1 (CHANGELOG): a lesson has a when (prompt, end of turn, tool call); the end-of-turn reminder fires when the agent hands the decision back and a correction lesson's sources followed exactly that; half the sessions are held out so measure compares shown against held-back reminders; compaction summaries are no longer read as the person; curly apostrophes no longer hide cues. The real store: 28 memories, 3 lessons ("act, don't ask" seen 4×, the site seen 2×, "quit thinking linear"), backup at ~/.remem/memory.db.before-0.2.1.

• The finding (paper §7.1): the "act, don't ask" lesson was already in the agent's context when it ended a turn with a list of next steps, and the owner had to say "just keep going don't wait for me". A lesson read is not a lesson done; memory for agents behaves like a habit, a cue bound to a response, more than like recollection. And what needed remembering was delegation (five of eight corrections), not code (18 of 19 failed calls were the machine's).

• Offers (0.2.3): over every transcript, the agent offered to act instead of acting 17 times and was declined 0 times; it waited on the person's hands 6 times, all necessary. Sessions now record offers and answers.

• Repeat-yourself rate: before any lesson, 3 of 6 corrections repeated an earlier one; with lessons passively in mind, 1 of 2.

• Open design question: a correction lesson's prediction being confirmed means the agent failed; it still strengthens the lesson (it predicted). With reminders, a working lesson stops being confirmed and may fade, then be relearned: spaced repetition for an agent. Watch for it before changing the rule.

• Next, in order:

  1. Live with the hooks (wired 2026-10-24); remem measure every few days. The experiment needs 20 primes in each arm before it says anything.
  2. Score the cues and the hand-back rule on the new weeks' messages, labelled, since both were written from the same few messages they were tuned on.
  3. Delegation as a first-class model: started in 0.2.2 (the tally, in morning.md since 0.8.0: hand-backs corrected 4, actions stopped 0, by kind). Next: let it decide the Stop reminder per kind (a person who stops deploys but not installs), which needs the first refusal to learn from.
  4. Native readers for other agents' transcripts (Codex ~/.codex/sessions, Gemini CLI, Cursor) once there are samples to test against; the end-of-turn reminder inside the proxy (re-ask the model when its reply offers instead of acting and a lesson bears on it).
  5. Phase 2 on two real machines: the owner runs remem share invite on the Linux box (in their own terminal) and pastes the line on the Mac; then measure the Mac's repeated-error rate on errors only the Linux box met. Then the commons-wide states (PROTOCOL §3) and opening the commons at launch.
  6. Okay Paper into its own repository (handbook idea 13).

• Open decisions for the owner: the name is decided (Remem, 2026-11-13); what follows from it is open: remem on PyPI, the Worker's name and the site's address, a trademark look. (Zone security for acific.com was done on 2026-10-22: DNSSEC, CAA, no-mail SPF/DMARC; see the handbook log.)

Phase 0: the organism (done, 0.1.0)

Ingest, recall, sleep, render, MCP, for one Claude Code user on one machine. No model required.

Phase 1: make it true

• Run it daily on this machine with the hook, cron and MCP wired in. Done 2026-10-21.
• A local model loaded for sleep (Ollama, Qwen3-30B-A3B instruct; LM Studio is also found). Loaded 2026-10-21; the comparison of its lessons with the deterministic ones waits for the first lessons.
• Measure: the repeat-yourself rate and the repeated-error rate over the first month; prediction accuracy per week. remem measure since 0.2.0; the month of data is next. Tune the thresholds in Appendix A against hand-labelled "same surprise" pairs.
• A learned embedder behind the same embed() interface, with the re-embedding migration (MIGRATIONS.md). Done in 0.2.0 (a local embedding model; sleep embeds again).
• Better surprise detection: corrections anywhere in a message; the agent's own stated surprises; a class on every error so the environment's failures (permissions, missing tools, benign exit codes) are not the agent's lessons. Done in 0.1.4; scoring the cues on messages they were not written from is next.

Phase 2: two agents

• A second agent (a second Claude Code project, or another agent with its own transcript reader) with its own store, exchanging only lessons.jsonl with the first.
• Provenance fields and signatures (PROTOCOL.md §2).
• Measure: agent B's repeated-error rate on errors only A has met. This is the commons in miniature.

Phase 3: compiled memory

• A local open model on this machine; nightly self-study over the day's episodes into a compiled state; one state per project, composed at session start; prefetch from the working directory.
• With hosted models: lessons as a cached prefix rebuilt nightly.
• Measure: time to first correct action on tasks that need a lesson, compiled versus rendered.

Phase 4: the raw stream beyond the terminal

• Screen capture at 1 fps, keyframes on change, a local vision model describing each, on the same timeline as the transcripts; exclusion rules (named apps and windows never captured) and a pause key, before anything else.
• Measure: surprises found in the screen stream that the transcript missed.

Phase 5: the commons

• The merge rule (candidate → common → fading → revoked) with real confirmations from phase 2's agents.
• Gossip transport; the personal layer never published by default.
• A small group of agents outside Acific Labs running it, by invitation.
• Measure: time from one agent's first surprise to every agent's lesson; false-lesson rate (lessons revoked after going common).

Phase 6: the breathing cycle

• Common lessons distilled into a local base model's weights; the commons re-measured after, to see it empty.

Launch

The repository goes public when phase 1's measurements exist and the paper's §7 has its first numbers. The name is Remem since 0.9.0 (it was Open Memory, which collided with mem0's OpenMemory MCP server).