Roadmap

Last verified against the code: 2026-11-14 (0.10.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. Everist 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. everist 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-14, 0.10.0: Remem is now Everist (the owner: "Let's call it everist", after trying Everis and Everon and asking for a name that feels huge but technical). Command, package, settings (EVERIST_…), store (~/.everist), lesson files and markers, MCP server, paper (paper/EVERIST.md). What Remem and Open Memory left on a machine is carried over (docs/MIGRATIONS.md); both old commands remain as second names. Checked first: everist free on PyPI, npm, crates.io, Homebrew; the US register has one live EVERIST application (a Canadian beauty brand, cosmetics and wellness only); everist.ai is a health app with no filing. Not a lawyer's opinion. The same day, on the owner's word ("Everist", asked whether to move the site and rename the repository): the site is deployed at everist.acific.com with 0.10.0 and a snapshot taken with it (36 of 86 memories, 4 of 7 lessons and 9 of 19 sessions left out as private; read before deploying, no private word on the page); remem.acific.com and open.acific.com redirect pages and still answer the commons, the installer and version.json; the repository is acific/everist; both machines run 0.10.0. Still open: the Worker is still named openmemory; nothing is on PyPI (the owner's account); the Linux box's checkout has an untracked extension/ folder and no npm, the two lines the release check fails there.

• 2026-11-14, a first look at the name, and a decision open for the owner. A web search (not a trademark-office search) found no filing for "Remem", but the name is crowded in this same field: two open-source memories for coding agents called remem (remem-io/remem; majiayu000/remem, which holds remem-ai on crates.io and is on npm and Homebrew), @darksol/remem on npm, RIA-Spec/remem, a hosted "Remem" memory API (remem.online) and a consumer app of the name on the App Store. remem on PyPI was free when checked on 2026-11-13. This is the collision the rename was meant to end; whether to keep the name is the owner's call, and publishing to PyPI should wait for it.

• 2026-11-14, the owner asked for a clearer name; a shortlist, nothing renamed. Thirty-five candidates were checked against PyPI, npm, crates.io, Homebrew, GitHub repository names and App Store titles, and the cleanest against a web search. Free everywhere and with no product of the name found: madeonce (from the line "Every mistake, made once."), sleptonit, secondnight, lessoned, learnedonce, dawnwise, mistook. Ruled out: twiceshy (an MCP server of that name already sells experience memory for coding agents), hindsight, errata, flinch, heed, unforget, onceover, nevertwice (taken on at least one registry). Not a trademark-office search. The choice is the owner's.

• 2026-11-14, 0.9.1; the Linux box runs Remem (the owner: "Do it!" to the list that began with it). From the Mac over ssh: the store and ~/.claude/settings.json backed up first (~/.remem/memory.db.before-0.9.0, settings.json.before-remem, ~/.remem/crontab.before-0.9.0), the remote set to acific/remem, pulled, the old openmemory tool uninstalled (uv refused to install over its executable) and the checkout installed. The first run moved ~/.openmemory to ~/.remem and left the link; remem setup renamed the four hooks, the MCP server and the cron line. One ingest (18 new memories from 10 sessions, most of them other projects' daily docs audits) and one sleep ran: 63 memories, 7 lessons, the lesson files taken over as remem-*.md. A7 is met on the box's own evidence: 10 repeated corrections, 19.1 catches per 100 items against normal memory's 0.45 (42×), no wrong alarms. A6 reads badly and is recorded as it is: 7 of 10 corrections since a lesson held them repeated one. The fresh live snapshot is filtered and deployed. The store now holds sessions from the owner's other, unreleased projects, mixed into the same sessions as this one, so the snapshot script leaves out what names a word in ~/.remem/snapshot-private.txt (written on the box that day: nine words) and refuses to write if one still shows; 36 of 86 memories, 4 of 7 lessons and 9 of 19 sessions are left out, and the file no longer carries the word-for-word offers behind the delegation sentence. The owner chose this over publishing the whole store, saw the page and said "Do it": deployed from the Mac the same day and checked live (the page and /live/snapshot.json carry none of the listed words). Found on the way and fixed in 0.9.1 (the owner: "Yes" to fixing it): decay() took a memory's whole age off its strength on every sleep, so nightly sleeps compounded and a memory nobody recalled was archived after about 16 nights, not the 123 days a 45-day half-life gives (20 of 63 were archived within three weeks). Decay now counts each day once, and the next sleep works old memories' strengths out again and brings back what was archived too soon. On the box the next sleep brought all 23 archived memories back (86 memories, none archived; backup ~/.remem/memory.db.before-0.9.1). 0.9.1 is installed on both machines, pushed and deployed (the owner: "Yes"; the live site and /version.json say 0.9.1, with the snapshot taken with it). The release check on the box passes 24 of 26; the two left are the untracked extension/ folder there and npm not being installed on the box (the audit is clean on the Mac). An untracked extension/ folder in the box's checkout is someone else's work and was left alone. The box's hostname is now a-halo001 (the ssh name on the Mac is still amd-halo).

• 2026-11-13, the site redesigned after Vacuum and moved to remem.acific.com (the owner: "make the remem.acific.com design like vacuum.acific.com", then "Yes, both" to deploying it and creating the address). Deployed from the Mac; every page compared equal to the build. remem.acific.com is the address; open.acific.com redirects its pages there and still answers /commons/, /install/ and /version.json, because a memory that saved the old commons address posts to it (MACHINE in src/worker.js). The Worker is still named openmemory. The live page still shows the old snapshot. The mark's animation was then made Remem's own and deployed the same day. Cloudflare adds its Web Analytics beacon to pages on the new address; the CSP blocks it (one console error, nothing loaded): turn the automatic beacon off for the hostname in the Cloudflare dashboard, or allow it on purpose.

• 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 (see the entry above; the Worker's name, openmemory in wrangler.jsonc, is 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 (the package is built and checked for it: uv build, twine check, a clean install; publishing needs the owner's PyPI account, uv publish); (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: remem.acific.com (open.acific.com until 2026-11-13), 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://remem.acific.com/commons/ (and still at the old 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. everist 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 Everist since 0.10.0 (it was Open Memory until 0.9.0, which collided with mem0's OpenMemory MCP server, and Remem in 0.9.x, a name several other memories for coding agents use).