Changelog

Unreleased

• The site is redesigned after Vacuum (vacuum.acific.com), at the owner's word on 2026-11-13. Not deployed yet. A grouped grey page, white cards with large corners, the system's type in sentence case, one blue, pill buttons and a glass header ("Remem by Acific Labs"). The home page is rebuilt in Vacuum's order: the mark inside breathing rings, the name, the line, three pills; then the loop as seven cards, the equation in a card, three cards to read, and a closing card. The live page, the docs, the paper reader and the 404 take the same cards and type; the live page's lowercase words are put into sentence case at build time (sentenceCase(), which leaves code, commands, paths and machine names alone). Fonts are the system's, with Inter served from site/assets/fonts/ as the fallback, so the site no longer loads Google Fonts and the CSP no longer allows it; the okay loader is no longer loaded. V is 6. The live page no longer overflows on a phone (long code scrolls inside its own box).
• The site is public. The pre-launch gate is off: the GATE_PASSWORD Worker secret was deleted on 2026-11-09, so no page asks for a password. The gate's code stays; npx wrangler secret put GATE_PASSWORD closes it again.
• Site templates tidied, same okay engineering look. Every page (home, live, the paper, the docs, 404) now sits in one centred frame, header and footer included; before, all but the paper hugged the left edge. The header is one row: the wordmark, five words, the glyph (the sub-links and the 7.5px fine print are gone). Nothing a reader needs is below 11px any more, and the greys are #6b6b6b (5.3:1 on white, was 3.4:1). The docs have a side menu instead of two wrapped rows of links; code blocks no longer wrap, so the ASCII diagrams hold together. The paper's headings use Inter (its body stays serif). Contact is contact@acificlabs.com. Seven style attributes the CSP was blocking (so their spacing and underlines never showed) are classes now (.u, .hero-h, .sub-h). Assets are ?v=4.

0.9.0 (2026-11-13)

• Open Memory is now Remem (the owner's decision: the old name collided with mem0's OpenMemory and with the openmemory package on PyPI, which belongs to someone else). The command and the Python package are remem, settings begin REMEM_, the store is ~/.remem, lesson files are remem-<id>.md marked managed: remem between remem:start/end markers, the MCP server is remem, the proxy's header is x-remem, the paper is paper/REMEM.md and the repository is github.com/acific/remem. Entries below this one keep the names they were written with.
• Nothing from before is lost or doubled. paths.adopt() moves ~/.openmemory to ~/.remem once and leaves a link (and until a command has run, paths.home() uses the old folder where it is, never an empty new one); OPENMEMORY_… settings are still read; render takes over the old lesson files and the old marked section (_adopt(), _section()), so a renamed file is never mistaken for a deleted one; remem setup rewrites old hooks, MCP servers and the cron line instead of adding beside them; openmemory stays as a second name for the command until then. Three tests cover it.
• Unchanged on purpose: the holdout salt ("openmemory-holdout|" in prime.py), so the experiment's held-out sessions stay the same; the Worker's name and the site's address (open.acific.com), which are a deploy the owner has not asked for.
• scripts/release-check.py no longer crashes where the handbook folder does not exist (it was written on the Linux box); the line fails with a reason instead.
• Migration: see MIGRATIONS.md, 0.9.0. On each machine: git pull, uv tool install --reinstall -q ., remem setup.

0.8.1 (2026-10-25)

Memory in the weights, at 7B, on the GPU.

• scripts/adapter.py runs on the GPU (--device auto): the Radeon 8060S takes AMD's gfx1151 torch build (the stock ROCm wheels crash on it); a 7B run takes 20–30 minutes. --pairs own|both builds training pairs from the model's own replies (its hand-back and its revision after the reminder; told to ask against told to act), on the training situations only.
• Seven adapter runs, A8 still not met (paper §7.4). Qwen2.5-7B-Instruct with a 30% boundary share is the first to move both ways at once: hand-backs with no memory 26 → 20 of 100 (the target is 19), asking kept (13 → 14 of 30). More "act" pairs tipped it to 0 of 100 and 2 of 30: it stopped ending on a question anywhere. Preference training on these pairs moves how readily a model asks, not when.
• openmemory goals reads every adapter run in order (it read an arbitrary one) and counts A8 met only for a run on ≥200 pairs, as the target says.

0.8.0 (2026-10-25)

Toward a real advance: ten goals with targets fixed in advance, checked from the evidence; why memory up front hurts; a safety fix to the reminder; agents with tools; the first memory in the weights.

• openmemory goals: goals A1–A10 (GOALS.md), each checked from the kept experiments, the store and the adapters. 4 are met (A1, A2, A3, A10). The release check keeps GOALS.md and the command in step.
• Why memory up front hurts (openmemory experiment mechanism, ten arms, four families): the delegation tally alone raised hand-backs from 20% to 34% (p < 0.0001), as much as the whole memory; nothing else did. Agents no longer see the tally: om-delegation.md is removed from memory folders and the line from lessons; it stays in morning.md.
• Safety fix: the Stop reminder kept the boundary badly (openmemory experiment boundary): where asking was right, 0.7.0's reminder cut asking from 42% to 16% (models published a post under legal review, force-pushed before being told to). Now the reminder is silent when the person's message says only they have what is needed (transcripts.needs_person, read from the transcript the Stop hook names), and its words say to ask for exactly that (prime.reminder, one wording for the hook, the proxy and the experiments). Re-run: 39% → 37%. And it still cuts hand-backs where acting is right (four families: 31% → 12%, p < 10⁻¹²). The lesson in it no longer adds to the bare nudge (12% against 11%): memory decides whether and when to intervene, the moment does the work.
• Agents with tools (openmemory experiment loop): a simulated shell and editor; the reminder cut final hand-backs 32% → 14% (p = 0.001).
• Memory in the weights, first try (scripts/adapter.py, openmemory experiment pairs): DPO on reminder pairs compiles the habit (5% hand-backs with no reminder, base 37%) but not the boundary (it stopped asking where it should). Not met; next is a larger model and real pairs.
• Experiments are kept in ~/.openmemory/experiments and can run on hosted models (OPENMEMORY_LLM_KEY); model calls are retried; Mistral 7B is a fourth family. Every run is in results/. Paper §7.4; docs/HANDOFF.md.

0.7.0 (2026-10-24)

Memory judged by what it changes, not what it retrieves.

• openmemory experiment: a controlled test of whether memory changes what a model does. 20 situations where agents tend to hand work back, two settings, four arms (no memory; the memory in context, as normal memory does; memory plus Open Memory's end-of-turn reminder; the same second turn with no lesson, as a control). Run on Qwen3-30B, Llama 3.2 3B and Gemma 3 4B (360 replies an arm): hand-backs 28% with no memory, 36% with the memory in context (worse, p = 0.013), 9% with the bare nudge, 6% with the reminder. A block holding one unrelated lesson also raised hand-backs, so the harm is not the lesson's content. Every reply is in results/; paper §7.3.
• The proxy delivers memory at the moment by default (OPENMEMORY_PROXY_MEMORY=moment): nothing up front; a lesson only when the person's message meets it, and the end-of-turn reminder when the reply hands back. first (0.6's default) and last remain.
• Training pairs for compiled memory: each proxy reminder that changes a reply is kept in ~/.openmemory/pairs.jsonl (the reply before and after, with the lesson), for a nightly adapter to learn the moment.

0.6.3 (2026-10-24)

Better than normal memory, measured: 3 of 4 repeated corrections caught with 23 items, against normal memory's 0 of 4 with 177 (or 4 of 4 with 1,010).

• A correction to 0.6.2's comparison. It credited normal memory with 2 of 4 at top 3, by counting the message just before an earlier correction, which normal memory never hands over. Scored properly: 0 of 4 at top 3, 2 at top 10, 4 at top 20. COMPARISON.md, the paper and the handbook log are corrected.
• Deferral is a hand-back. A reply that names work left and leaves it ("…I flagged earlier, and it is next", "Still missing: …") now counts like an offer: the end-of-turn reminder fires, delegation counts it. On the owner's history four replies did this; three were answered "you fix it", "You do it", "Can you do it", the fourth "Next!". Recorded at ingest as "Agent deferred: …".
• One lesson per end-of-turn reminder (the one with the most corrections behind it), not two.
• compare measures precision: the turns a system spoke that the person then corrected, wrong alarms (the person declined what the reminder pushed for: 0), and catches per 100 items (Open Memory 13.0, normal memory's best 0.40).

0.6.2 (2026-10-24)

Measured against normal memory, and fixed by the measurement.

• openmemory compare replays this machine's history against "normal" memory (every earlier message kept, the k most similar put back on every turn). Test cases: the person's repeated corrections; question: did the earlier correction reach the agent in time; plus how much each puts in front of the agent. Owner's history (59 turns, 4 cases): normal memory 2 of 4 with 171 items on 58 turns; Open Memory 2 of 4 with 26 items on 19 turns; different cases, 3 of 4 together. COMPARISON.md has the cases and how Open Memory differs from ChatGPT's and Claude's memory, mem0, Letta and Zep, including where normal memory is better.
• The end-of-turn reminder, fixed by that replay. Its first run caught 0 of 4. A correction lesson now bears on offers when any of its corrections followed a hand-back (it was most of them: the owner's "act, don't ask" theme never qualified), and the reminder fires at every offer (it was once per session: it fired at a session's first offer and stayed silent through ten more, the last of which drew "do it always dont ask"). Changed after seeing the replay; the randomized holdout is the real test.

0.6.1 (2026-10-24)

One line installs Open Memory on another machine; nothing ships unchecked.

• openmemory share invite prints one line to paste on another machine (macOS or Linux). It downloads the installer and a wheel built from this checkout from open.acific.com/install/ (token-gated until launch), checks the wheel's SHA-256, installs with uv (which brings its own Python), saves the commons token (mode 600), runs openmemory setup, joins the commons and reads the machine's history. Tested end to end through the live site in a blank home directory.
• scripts/release-check.py: a release is done only when every line passes (AGENTS.md rule 17). It checks the version everywhere, every document naming it, tests, the docs harness, the installed CLI, hooks and cron, the live site's new /version.json, a clean pushed tree, the handbook log, the owner's memory notes, secrets in tracked files and open vulnerabilities.
• Fixed: 0.3.0 to 0.6.0 reported themselves as 0.2.3 (openmemory --version, status, the live page): the bump at 0.3.0 was skipped and every later one found nothing to replace. A test now fails when the code, pyproject.toml and the CHANGELOG disagree, and the release check compares the installed and the deployed version too.

0.6.0 (2026-10-24)

The commons goes live; memory first; more agents read natively.

• The commons transport: https://open.acific.com/commons/, a Cloudflare Worker route (src/commons.js) over KV. One signed file per memory; a memory may write only its own file, and only lines signed by the Ed25519 key whose fingerprint is its origin (checked with WebCrypto against the exact bytes sent). A token (COMMONS_TOKEN; locally ~/.openmemory/commons-token or OPENMEMORY_COMMONS_TOKEN) is required until launch. openmemory share sync https://…/commons/ puts this memory's records and takes everyone else's; the target synced by hand is remembered (~/.openmemory/share-target) so every sleep syncs there. Tested locally and live: a memory writing as another is refused ("key does not match the origin"), an altered record is refused ("bad signature").
• Origins are SHA-256 fingerprints (the first 8 bytes of SHA-256 of the public key), computable anywhere; 0.5.0's BLAKE2b fingerprint is replaced on first use. Records travel as canonical JSON lines (share.wire()).
• Compiled memory, first form: memory first. The proxy puts the memory in its own system message before the app's, identical for every app, so the model server's prefix cache computes it once. Measured (Ollama, Qwen3-30B, a 1,400-token memory, two apps alternating): a new app's first request 4,738 ms with the memory after its prompt, 237 ms with it first; about 150 ms more when an app's own cache is already warm. The Anthropic path marks the block cache_control so the API caches it. OPENMEMORY_PROXY_MEMORY=last restores the old placement.
• Codex CLI's own sessions (~/.codex/sessions/**/rollout-*.jsonl, both layouts) and Gemini CLI's saved chats and checkpoints (~/.gemini/tmp/) are read by ingest when present. Experimental: written from the formats and tested on synthetic files; no real Codex or Gemini session has been read yet.
• A test signs a line in Python and verifies it with the Worker's JavaScript.

0.5.0 (2026-10-24)

Signed sharing.

• Every shared record is signed with Ed25519 (openmemory/ed25519.py: RFC 8032 in pure Python, checked against the RFC's test vectors; about 2 ms a verification). Each memory makes its key once (~/.openmemory/key, mode 600) and its origin becomes the key's fingerprint, so no one can publish, confirm or revoke as a memory without its key. Unsigned records, records signed by another key than the origin names, and altered records are refused. A signed instruction is still refused: signing proves who, not what.
• Teams: openmemory share trust ORIGIN lists the memories to hear; with a list, all others are refused. openmemory share whoami prints this memory's origin and public key.
• 0.4.0's random origin ids are replaced by the key fingerprint on first use; local lessons are restamped.

0.4.0 (2026-10-24)

Every mistake, made once, everywhere: memories share lessons and verify each other's.

• openmemory share (export, import, sync DIR, revoke HASH, list; paper §5, PROTOCOL §2 and §3). Only lessons move, never episodes, transcripts or chats; by default only lessons from errors and the agent's own surprises (corrections quote the person and move only with --corrections; delegation never moves). A lesson is identified across memories by a hash of its kind and text; each memory has a random origin id.
• An imported lesson is a candidate: checked (never an instruction, at most 300 characters, hash matching its text), merged into a local lesson that means the same thing when there is one (a corroboration), else kept at strength 0.5. A candidate always predicts, so the importing memory's own sessions test it; when one comes true the confirmation travels back and the origin's lesson gains strength, once per confirming memory.
• Revocation: openmemory share revoke HASH withdraws a lesson from every memory at its next sync.
• Transport is a folder: openmemory share sync DIR, or OPENMEMORY_SHARE_DIR for every sleep. Each memory writes <origin>.jsonl there and reads the others. Syncthing, Dropbox, a git repository or a network drive carries it; there is no server. Signatures are designed, not built: trust today is whoever can write to the folder.
• Tested end to end with two memories (A learns from a repeated error; B imports it, meets the error, confirms it; A receives the confirmation; A revokes; B drops it; an instruction posing as a lesson and a tampered text are refused).
• The proxy's end-of-turn reminder: when a model's (non-streaming) reply offers to act instead of acting and a correction lesson bears on it, the proxy asks once more with the lesson beside the reply and returns the second answer; once per conversation, half held out. Qwen3-30B, told by its system prompt always to end by offering, wrote the haiku it had been about to offer.
• New lesson columns origin, hash, origins (added on open).

0.3.0 (2026-10-24)

The memory for AI: any agent, any model.

• openmemory setup wires Open Memory into every AI agent on the machine in one command: Claude Code (MCP server and the SessionEnd, UserPromptSubmit, Stop and PreToolUse hooks), Claude Desktop, Cursor, Windsurf, Gemini CLI and Codex (the MCP server), and the nightly sleep in the crontab. Only agents that are installed; idempotent; every file backed up to <file>.before-openmemory; --dry-run changes nothing.
• openmemory proxy: an OpenAI- and Anthropic-compatible endpoint (http://127.0.0.1:11435/v1) in front of any model, local or hosted. It puts the memory into every request's system prompt, forwards everything else untouched (streaming included, the app's key passed through), and records each conversation to ~/.openmemory/chats/ for ingest. Tested on the owner's machine in front of Ollama with Qwen3-30B: asked "do you deploy it now or ask me first?", the model, which had never seen a Claude Code session, answered "Deploy it — don't ask, just do it."; a correction made to it ("stop asking me every time, you push it") came back as a correction episode with the offer it answered. Also serves /memory/context, /memory/lessons, /memory/recall and /memory/remember.
• Conversations from any model (chats.py): OpenAI chat, Anthropic messages and Gemini contents, one file or JSON Lines, read like transcripts by the same detectors. openmemory ingest --chat FILE…, or drop files into ~/.openmemory/chats/.
• Events, an open format for surprises (events.py, PROTOCOL §0): correction, error, environment, surprise, note. Through the MCP remember tool, openmemory ingest --events FILE (or -), the proxy, or ~/.openmemory/inbox.jsonl, which ingest drains.
• The MCP server for any agent: remember takes a kind (a correction with the person's words, an error, a surprise); a new lessons tool loads what memory holds at the start of a task; initialize returns instructions saying when to call each.
• openmemory context (the memory as a system prompt), openmemory tools --format openai|anthropic|gemini|mcp (the tools as function-calling schemas) and openmemory call NAME ARGS (run one), for any framework.
• Sleep writes the lessons into Codex's ~/.codex/AGENTS.md and Gemini CLI's ~/.gemini/GEMINI.md (a marked section) when those agents are installed.
• "stop asking" and "don't ask" answer an offer as a correction, not a decline.

0.2.3 (2026-10-24)

Offers and waiting, told apart.

• Two acts inside a hand-back. The agent waiting on a step only the person can do ("tell me when", "let me know once", "run this") is not the agent offering to act ("want me to", "should I", "then say go", a list of next steps). Replayed over every transcript on the owner's machine: 23 of 43 replies ended in a hand-back. The six that waited were answered "did it", "okay" or with pasted output: necessary. The seventeen offers were declined 0 times: approved 4, corrected 3, pushed past or redirected 10.
• Every session records its offers and the answers (new sessions.offers column, added on open), and delegation counts them by kind of action.
• The Stop reminder fires on offers only, never when the agent is waiting on the person's hands.
• Correction contexts record "Agent offered" or "Agent waited on the person" in place of 0.2.2's "Agent handed back" (still read).

0.2.2 (2026-10-24)

Delegation, counted.

• delegation: how this person splits acting from asking. Every correction that came right after the agent handed a decision back counts as "asked, and was told to act", by kind of action (install, release, git, build, spend, delete, next steps); every refused tool call as "acted, and was stopped". Sleep renders the counts as one observation, om-delegation.md in the memory folder (vetoable like a lesson), in morning.md and in measure. On the owner's store: handed back and told to act 4 times (install, build, release, next steps), stopped 0 times.
• The hand-back is recorded at ingest ("Agent handed back: …" in a correction's context), from the closing 1,500 characters of the reply, not only its last sentence: the owner's "just keep going" followed a list of next steps several lines before the end.
• Fixed: "What I'd do next" never matched (the pattern wanted a space before "'d"); a quoted example in code (`openmemory prime "want me to push this?"`) counted as the agent asking. Code spans are left out of hand-back detection.
• Security: undici 7.30.1 through an npm override (three advisories), marked 18 (identical build), wrangler 4.152, actions/checkout and setup-node 7.

0.2.1 (2026-10-24)

The memory speaks at the moment a lesson applies, and measures itself.

• A lesson has a when. openmemory prime now answers three Claude Code hooks: the person's prompt (UserPromptSubmit), the agent ending its turn (Stop) and a tool call about to run (PreToolUse). When the agent's reply ends by handing the decision back (asking, offering, listing what it would do next) and a correction lesson's sources mostly followed exactly that, the lesson is put to the agent and the turn goes on; it is never stopped twice in a row. An error lesson is put beside a tool call that resembles the one that failed. Why: on the owner's machine 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 person had to say "just keep going don't wait for me". A lesson read is not a lesson done.
• The memory runs its own experiment. Half the sessions, by a hash of the session id, are held out: primes are worked out and logged but not shown. measure compares how often the same correction followed a shown prime and a held-back one, with a Fisher exact test once each arm has 20. OPENMEMORY_HOLDOUT=0 shows every prime.
• The summary written when a conversation is compacted is not the person. It was read as a correction (it said "isnt working") and confirmed a prediction. Skipped (isCompactSummary).
• Curly apostrophes. Messages typed on a phone say "don’t"; every cue with an apostrophe missed them.
• New correction cues: "don't wait for me", "just keep going".
• Joining a lesson and merging themes compare averages over members, which run lower than one pair: their cut is 0.57 in a model's space (0.62 stays the cut for a pair). "just keep going don't wait for me" joins "act, don't ask" at 0.58; the owner's two themes stay apart at 0.52.
• openmemory hook prints all four hooks. The paper gains §4.3.1 (a lesson has a when) and §7.1, first findings.

0.2.0 (2026-10-24)

Memory that finds meaning, and says whether it works.

• Embeddings with meaning. A local embedding model (any Ollama model with "embed" in its name; qwen3-embedding:0.6b on the owner's machine) replaces hashed words when there is one; hashed words remain the fallback and need nothing. "should I ask before releasing?" now finds "do it always dont ask", which shares no word with it. A correction is embedded from the person's words alone, so two corrections that mean the same thing match whatever the agent had been doing. Recall rescales relevance above the cosine at which unrelated texts sit (0.35 for the model, 0 for hashed), so the recall weights mean the same in either space.
• Every vector remembers its space. Vectors from two spaces never match; the new first pass of sleep embeds again whatever is not in the current space, so a new model, or one that was down during an ingest, heals overnight.
• Themes. Lessons of one kind whose sources mean the same thing merge in sleep into one theme, which quotes each correction in order. On the owner's store six correction lessons became three: "you do it take over this computer", "do it always dont ask" and "you fix it" are one; "open.acific.com isnt working" and "no update open.acific.com…" are another. Merging uses average linkage over the sources, not the cosine of centroids: centroids drift towards what every correction shares and merged the two themes on the second night. A merged lesson's file is removed, and a veto on it carries over to its theme. New aliases table.
• openmemory measure (goal 10): the repeat-yourself rate before and after a lesson held it, the repeated-error rate, prediction accuracy, themes and a by-day table, each number naming its episodes; --json for machines. On the owner's store: before any lesson held them, 3 of 6 corrections said again what an earlier one had; since the first lesson, 0 of 1.
• Predictions are borne out only by what happened after them, by when an episode happened, not when it was read (a transcript read late used to confirm a prediction made before it), and only by the lesson's own kind.
• Priming: openmemory prime, run by Claude Code's UserPromptSubmit hook. When what the person just typed bears on a lesson (cosine ≥ 0.60 to its vector in a model's space, 0.30 hashed), the lesson arrives beside the prompt, at most two per prompt and each once per session; otherwise nothing. On the owner's store "want me to push this?" and "keep going like youre inventing the future" bring up the "act, don't ask" theme; "fix the css on the paper page" and "run the tests" bring up nothing. Primes are logged to primed.jsonl, and measure counts the ones followed by the same correction anyway. A hook error never blocks a prompt. openmemory hook prints the entry; openmemory prime "<text>" tries a prompt by hand without logging.
• A lesson's vector is the mean of its sources' vectors, not of its wording.
• status and the morning report name the embedder. The live page has a "does it work?" section and themes.

0.1.4 (2026-10-23)

What the first real run on the owner's machine showed, fixed.

• Corrections are caught anywhere in a message, not only by its opening words ("open.acific.com isnt working", "you fix it", "do it always dont ask"), with pasted text left out and "no problem" not counted. A tool call the person refused is a correction too, with whatever they said with it. On the owner's 41 real exchanges, hand labelled: 6 of 6 corrections caught, no false alarm (the rules were written while reading that set). A local model was tried as the judge and did worse (8 false alarms with the best prompt), so the rules decide.
• Messages sent mid-turn are read. Claude Code records them as queued_command attachments; they were lost. Lines the harness writes in the person's place (task notifications) are no longer read as the person's.
• Errors have a class. A failure that was the environment's (a missing tool, a password or permission, the network, an interruption, or a probe whose failing answer was the point) is an environment episode: kept and recalled, never made into a lesson. The agent saying in the first person that it was wrong or surprised is a surprise episode, consolidated like an error.
• Correction lessons quote the person. A lesson from corrections is the person's words, quoted, with the sentence of the agent's reply they were answering (its closing when it asked, else its opening). The model's paraphrases said the opposite of what was meant in two of six real cases. Error lessons are still worded by the model, now told not to guess a cause the error does not state.
• openmemory sleep --rewrite words every lesson again from its sources with the current writer, keeping its id, strength and history; open predictions follow.
• Episode ids are stable (a hash of the session, the kind and the title). ingest --again used to give every episode a new random id, leaving lessons pointing at episodes that no longer existed; it now keeps strength, recalls and touches, and renames old ids in every lesson's sources.
• status and the morning report count the environment's failures apart from the surprises.
• The live page shows the new kinds, the real lessons from the owner's corrections, and a next night that repeats the store's own most recent agent error instead of made-up episodes.

Migration: none required. To bring an existing store up to date, run openmemory ingest --again (re-reads every transcript, reclassifies, renames old episode ids inside lessons) and then openmemory sleep --rewrite. On the owner's store: 1 minute with the model.

0.1.3 (2026-10-23)

• The site redesigned after okayengineering.com: a white page, light lowercase Inter, JetBrains Mono for numbers and codes, hairline rules, one signal orange, the stacked wordmark with a text menu and sub-links, the fine print and the glyph, the quiet footer row with the local time, the black band. Light only, like okay engineering. The home page is the loop as big rows, the equation, three grey cards and the notice.
• /live/: the real store on the owner's machine, built from site/live/snapshot.json. The five stages with their real output, every memory with the model's gists, four recall queries, the night a mistake repeats (a copy of the store given one repeated error and one correction, slept with the local model), the commands. scripts/live-snapshot.py regenerates the snapshot; the real store is never touched.
• The Open Memory equation written out on the home page (decay, consolidation, prediction, recall; the rank).

Migration: none. Nothing in the store changes.

0.1.2 (2026-10-22)

• The site is live at open.acific.com behind the pre-launch gate, and meets the handbook's security standard: SECURITY.md, the security headers on every response (redirects, the gate page and 404s included; HSTS, a CSP with nothing inline, nosniff, no framing, a referrer policy, a permissions policy, a cross-origin opener policy), http and other hosts redirected to https://open.acific.com in the Worker, /.well-known/security.txt, weekly Dependabot updates, .dev.vars and .env* ignored. site/_headers now only sets asset caching.
• The password gate updated to the handbook's hardened copy (its own headers, a pause after a wrong password).
• Docs harness 1.5.0 (required docs and links checked with their exact spelling).

Migration: none. Nothing in the store changes.

0.1.1 (2026-10-21)

• The site, open.acific.com: the home page, the paper as a page-by-page reader (/paper/, with JavaScript off every page is on the sheet), every doc at /docs/<name>/, the protocol at /protocol/, a sitemap. Built by scripts/build-site.mjs (Markdown rendered at build time, links between docs rewritten), served by a Cloudflare Worker with the okay loader, a strict CSP and the pre-launch password gate. npm run build / dev / deploy.
• openmemory ingest --again reads every transcript afresh (to redo the gists once a model is running).
• The local model is found automatically: LM Studio (localhost:1234) first, then Ollama (localhost:11434); OPENMEMORY_LLM_URL still overrides. An instruct model is preferred over a thinking one, and Ollama is spoken to through its own chat API with thinking off (its OpenAI endpoint cannot switch it off).
• Error episodes name the line that says what went wrong, not the first line of output.

Migration: none. Nothing in the store changes; the site is new.

0.1.0 (2026-10-21)

The first working memory, for one agent (Claude Code), on one machine.

• openmemory ingest: reads Claude Code session transcripts into episodes (one per session, one per surprise: failed tool calls and user corrections); idempotent, re-reads a session that grew.
• openmemory recall: memories for a query, scored on relevance (hashed embeddings), recency and strength; every recall strengthens what it returns.
• openmemory sleep: decay and archive, surprises consolidated into lessons (observations, never instructions), predictions verified against new sessions and new ones made, lessons rendered into each project's Claude Code memory folder, lessons.jsonl (the wire format) and morning.md written.
• openmemory serve: an MCP server over stdio with recall and remember.
• openmemory status, morning, hook, paths.
• Optional local model through any OpenAI-compatible server (LM Studio by default) for better gists and lessons.
• The lab paper, paper/OPEN-MEMORY.md (renamed in 0.9.0), and the protocol draft, docs/PROTOCOL.md.
• Okay Paper (okaypaper/): the paper published as a page-by-page reader and editor with history, "Okay" rewrites, presence and comments.

Migration: none (first release). The database is created at ~/.openmemory/memory.db on first use.