Roadmap

Last verified against the code: 2026-11-14 (0.10.1)

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

North star

The relay between models, and, for the memory that runs overnight, proven by what agents do. The product a person uses is the handoff: one project, what was done, what they corrected, what was deployed. Neverest is also an advance on the memory 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. neverest goals checks every one from the evidence; nothing on this page is marked done from memory. A relay that is not measured is not yet one of them.

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-11-15)

The latest state, for whoever picks this up next (a person or an agent):

• 2026-11-15, 0.10.1: Everest is now Neverest (the owner, after reviewing the site's new idea of a relay for models: "I think Neverest is a better name for the software"; told that pimalaya/neverest, a mail and calendar sync CLI on crates.io and Homebrew, has the name: "Yes, rename it"). The same as the Everest rename, one name later: command, package, settings (NEVEREST_…), store (~/.neverest), lesson files and markers, MCP server, proxy header, paper (paper/NEVEREST.md), the site's address (neverest.acific.com; everest.acific.com joins the old addresses). A clean break again; what Everest or Everist left on disk is carried over once. neverest is free on PyPI and npm.

• 2026-11-15, 0.10.1: Everist is now Everest (the owner: "rename it to Everest", choosing to rename everything and to make a clean break). Command, package, settings (EVEREST_…), store (~/.everest), lesson files and markers, MCP server, proxy header, paper (EVEREST.md, now paper/NEVEREST.md), the site's address (everest.acific.com). Unlike the two renames before it, nothing under the Everist name is read any more: no everist command, no EVERIST_… settings, no x-everist header. What Everist left on disk (~/.everist, everist-*.md, hooks, MCP servers, the cron line) is still carried over once. everist.acific.com joins the old addresses that redirect pages and still answer the commons. Not checked this time: everest is taken on PyPI (an old 1.0b2dev from 2015) and on npm (an AuthZ package); no trademark search was made. The same day, in the dashboards: the repository is acific/everest, and the Worker was renamed in place to everest (its COMMONS_TOKEN and KV binding kept; the old addresses checked after). The Mac is wired with everest setup. Still open: the repository's homepage once everest.acific.com is live; the Linux box; the checkout folder.

• 2026-11-15, neverest model setup (the owner, pointing at the news of Apple's Harbor app for running models on a Mac: "I want Everist to do this as well"; asked what that meant, they chose "set up a model for you" over running models itself or a Mac app). One command picks a model that fits the machine, downloads it through Ollama and remembers it (neverest/models.py, ~/.neverest/model.json). Installed on both machines on 2026-11-15 as 0.10.1 in development (the owner: "Yes"), which also put the relay work into the box's hooks and nightly sleep; the store from before is at ~/.neverest/memory.db.before-0.10.1 there. Tried on the box's real Ollama from a scratch folder (it kept the Qwen3 model already there, and switched to gemma3:4b by name); the Mac has no Ollama and gets the how-to. Not tried: a fresh multi-GB download from the registry, Windows (memory unknown there, so the 4b default), an Ollama on another port.

• 2026-11-15, the site and docs are deployed with neverest model setup (the owner: "Update Everist site and documentation"), by hand with npm run deploy: the home page's lessons card, the user guide, architecture, implementation and operations, and a snapshot retaken on the box with 0.10.1 (50 memories shown; 36 memories, 4 lessons and 9 sessions withheld; read for private words and secrets, none). The deploy on every push (.github/workflows/deploy.yml) failed until then with "No access to the specified resource": the token lacked Workers Scripts: Edit. The owner made a new one from Cloudflare's Edit Cloudflare Workers template (account: theirs; zone: acific.com) and stored it as the CLOUDFLARE_API_TOKEN secret; the run passes, so a push to main now publishes the site.

• 2026-11-14, the site explains the relay. The home page is the program: one project, a handoff when the model changes, corrections in the person's words, and deploys kept on the record. The user guide leads with the same steps (neverest proxy, x-neverest-project, neverest relay). The memory (sleep, lessons, strength) is still in the product and in the paper. It is no longer the first thing the site says.

• 2026-11-14, the relay. The product claim is no longer "the memory layer." It is the handoff across models on one project: what was done, what the person corrected, and what was deployed. neverest relay, the proxy header x-neverest-project, and the MCP tool relay read and write ~/.neverest/relay/. A different model receives the recent thread; the same model receives only corrections and deploys. NEVEREST_ROUTES picks the server by model name. The site that says this is published. A push to main deploys it when the Actions secret CLOUDFLARE_API_TOKEN can upload Worker assets. The goals are unchanged: a relay that is not measured is not yet evidence that a repeated mistake stopped.

• 2026-11-14, 0.10.1 reliability work, not released. Four review findings are addressed on a separate branch: memory-off Anthropic routing, orphan lesson files after revocation, malformed shared records and malformed MCP input. Related fixes preserve unmanaged filename collisions and stop duplicate evidence inflating strength. Regression tests cover each case; a Python CI matrix now complements the docs harness. No production deployment, live snapshot refresh or change to the owner's running hooks and cron is part of this branch. Local validation: 51 tests pass on Python 3.12 and 3.15, the docs harness reports no findings, the site and installer wheel build, and the wheel imports from a clean environment and survives a malformed MCP request. The GitHub Python 3.11–3.15 matrix also passed for the reliability commit (d6b0405); newer main-branch copy changes are preserved on the pull request.

Next proof of value

The next milestone is one coding workflow that demonstrably repeats fewer mistakes, rather than more transports or a larger model. Keep the existing goal targets in GOALS.md fixed; do not relabel the present evidence as success.

1. Reliability before wider use. Merge only after the regression and docs checks pass. Check a clean install, a two-memory revoke/render cycle and the proxy with both API formats before preparing a release. Preserve the existing full release check as the gate for deployment and installation.
2. Make setup understandable. Add a read-only neverest doctor that reports the executable version, store, registered integrations, hook commands and last successful sleep, with concrete fixes. Acceptance: a new user can diagnose a missing integration without editing configuration by guesswork; the command changes no files.
3. Measure one real outcome. For one project, collect the existing shown/held-out samples until each arm meets A5's predeclared minimum, then report repeats, false alarms, reminder frequency and latency alongside the baseline. A confirmed prediction is a repeated mistake, not proof that the intervention prevented it.
4. Prove transfer before opening the commons. Run the two-machine A9 trial with a deliberately non-private error lesson; show local evidence, imported candidate, verification and revocation. Keep the privacy and trust boundaries visible. Broader federation and nightly adapters follow evidence, not precede it.

Earlier work

• 2026-11-14, the home page rewritten for a novice (the owner: "make this easier to understand a more useful explain everything like you're explaining it to a novice"): what an agent is, a Monday-to-Tuesday example, four steps in plain words, a list of six words, the equation kept but marked optional, plainer promises. The climb wording from earlier the same day is gone except in "The name". Deployed the same day on the owner's "Yes, deploy it" and checked live. Then, on "Yes, rewrite them": the live page's prose (every heading, hint and note; the data and commands untouched; "the owner" in place of "you") and the user guide (what it is, what you need, install, connect, first day, the words, then the reference; the FAQ no longer says sharing is not built). Deployed the same day on the owner's "Yes, deploy them" and checked live. The other docs are not rewritten.

• 2026-11-14, the tagline is "The memory layer for every agent." (the owner's choice of five, after "I hate this line" about the old one). It replaces the old line everywhere it stood: the home page, the footer, the page description, README, GOALS, this file's north star, the package and GitHub descriptions, the paper's title. The home page's copy was rewritten for Everist the same day (the climb; "kept for ever"). Deployed the same day on the owner's "Yes, deploy it", after they saw the page; checked live (the old line is on no page).

• 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 (EVERIST.md; paper/NEVEREST.md since 0.10.1). 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. Then, on "Update everything to everist": the site runs on a new Worker named everist (same commons store; the token copied; all three addresses moved and checked), the box's lesson files are everist-*.md, the repository's description and homepage say Everist. Still open: the old Worker openmemory is deleted (the owner: "Yes, delete it"; the site and commons checked after); the checkout folders are still openmemory (on the box a trusted-repository rule in Claude Code's settings names that path, and it is the owner's to change); 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 tagline of the time), 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. neverest 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 Neverest since 2026-11-15 (Everest for a few hours that day, Everist in 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).