We built OptMem, a long-term memory for AI agents, as a small Affordance app

// Permanent memory for agents, after OptMem (github.com/VictorTaelin/OptMem), as an instance tree.
//
// The memory is this root's state: an append-only log of one-line memories and a binary tree of
// one-line summaries over it (block [lo, hi) summarizes its two halves). Sessions are its children,
// one at a time; each wakes with the memory's cover (recent memories verbatim, older ones collapsed
// into tree nodes, `views/strategies/context.tsx` `cover`, the same tiling as OptMem's) and can
// recall, zoom and note. Differences from OptMem, which the harness makes possible:
//   - Compression happens here, as a model call (a model() call) when a note
//     makes a block complete. A session never stops its work to "nap".
//   - Who may write memory is structural, not a prompt rule: a session writes through the `onNote`
//     callback this root passes it. A helper it mounts gets no `onNote`, so it cannot write.
//   - The memory outlives sessions because the root does: a session's stop (`onStop`) mounts the
//     next, and a crash resumes the whole tree from its journals.
import { TurnStrategy } from "../../strategies/turn_strategy.tsx";
import { cover, pendingBlocks } from "../../strategies/context.tsx";
import { MessagesApp } from "../../template_apps/messages.tsx";
import { GLM53App } from "../../template_apps/glm53.tsx";
import { Session } from "./session.tsx";

// One line in place of a block of memories.
function Compress({ template, lo, hi, body, chars }) {
  const text = `Summarize memories #${lo}-${hi - 1} in one line of at most ${chars} bytes.\nKeep what will still matter later and leave out the rest. Add nothing that is not in them.\n\n${body}\n\nReply with the line only.`;
  if (template == "glm53") return <GLM53App system="You maintain a memory."><TurnStrategy strategy="unrolled" log={[]}>{text}</TurnStrategy></GLM53App>;
  return <MessagesApp system="You maintain a memory."><TurnStrategy strategy="unrolled" log={[]}>{text}</TurnStrategy></MessagesApp>;
}

// What `wake` prints: the cover of the log, one line per block, finest near now.
export function wakeText(log, tree, lines) {
  if (log.length == 0) return "(no memories yet)";
  return cover(log.length, lines).map(([lo, hi]) =>
    hi - lo == 1 ? `#${lo} ${log[lo]}` : `#${lo}-${hi - 1} ${tree[`${lo}-${hi}`] ?? "(summary pending)"}`).join("\n");
}

export default function Memory({ sessions, template = "messages", wake_lines = 96, chars = 280 }) {
  const [log, setLog] = useState([], "log");
  const [tree, setTree] = useState({}, "tree");
  const [current, setCurrent] = useState(0, "current");
  // A note is appended at once (a functional update: notes from sessions running side by side all
  // land). Compression is its own step: while a block of notes is complete and unsummarized,
  // summarize the smallest one from its two halves, one at a time.
  const note = (text) => { setLog(l => [...l, String(text).slice(0, chars)]); };
  const [busy, setBusy] = useState(false, "compressing");
  const pending = pendingBlocks(log.length, tree);
  useEffect(() => {
    if (busy || !pending.length) return;
    const [lo, hi] = pending[0];
    const mid = (lo + hi) / 2;
    const half = (a, b) => b - a == 1 ? `  #${a} ${log[a]}` : `  #${a}-${b - 1} ${tree[`${a}-${b}`]}`;
    const body = half(lo, mid) + "\n" + half(mid, hi);
    setBusy(true);
    const compress = async () => {
      try {
        const r = await model(<Compress template={template} lo={lo} hi={hi} chars={chars} body={body}/>);
        setTree(t => ({...t, [`${lo}-${hi}`]: r.text.trim().split("\n")[0].slice(0, chars)}));
      } finally {
        setBusy(false);
      }
    };
    compress();
  }, [busy, log.length, Object.keys(tree).length]);
  if (current >= sessions.length) return "";
  return <Mount key={`session-${current}`} model="default">
    <Session task={sessions[current]} template={template} wake={wakeText(log, tree, wake_lines)} memories={log} tree={tree}
             onNote={note} onStop={() => { setCurrent(c => c + 1); }}/>
  </Mount>;
}

import { useLog } from "../../lib/log.tsx";
// One session of an agent with permanent memory (`memory.tsx` is its parent). It wakes with the
// memory's cover, works on its task, records what has lasting effect (`note`), and can search
// every memory (`recall`) or open a summary into its two halves (`zoom`). `answer` ends it.
import { TurnStrategy } from "../../strategies/turn_strategy.tsx";
import { useLoop } from "../../lib/loop.tsx";
import { MessagesApp } from "../../template_apps/messages.tsx";
import { GLM53App } from "../../template_apps/glm53.tsx";

const SYSTEM = "You are an assistant with a permanent memory that outlives this session. Your memory is shown at the start, as lines `#i text` (one memory) and `#a-b text` (a summary of memories a..b, oldest collapsed most). Record anything of lasting effect with `note` (one line each, no duplicates). To find an old memory, `recall` searches every memory word for word and `zoom` opens a summary into its two halves. Finish with `answer`.";

function Context({ template, log, children }) {
  if (template == "glm53") return <GLM53App system={SYSTEM}><TurnStrategy strategy="unrolled" log={log}>{children}</TurnStrategy></GLM53App>;
  return <MessagesApp system={SYSTEM}><TurnStrategy strategy="unrolled" log={log.map(r => ({...r, ids: null}))}>{children}</TurnStrategy></MessagesApp>;
}

export function Session({ task, template = "messages", wake, memories, tree, onNote }) {
  const log = useLog();
  useLoop(log);
  // The session wakes once: later notes arrive as props but stay out of its first message, so each
  // prompt is an exact append of the last. It sees its own notes as its tool calls.
  const [woke] = useState(wake, "woke");
  const app = <>
    <aff tool_name="note" description="Record one memory: one line, at most 280 bytes."
         args_schema={{type: "object", properties: {text: {type: "string"}}, required: ["text"]}}
         onNote={({ text }) => { onNote(text); return `noted as #${memories.length}`; }}>{"[note]\n"}</aff>
    <aff tool_name="recall" description="Search every memory ever recorded, word for word (a regular expression, case-insensitive)."
         args_schema={{type: "object", properties: {pattern: {type: "string"}}, required: ["pattern"]}}
         onRecall={({ pattern }) => {
           const re = new RegExp(pattern, "i");
           const hits = [];
           for (const [i, m] of memories.entries()) { if (re.test(m)) hits.push(`#${i} ${m}`); }
           return hits.length ? hits.slice(0, 20).join("\n") : `no memory matches ${pattern}`;
         }}>{"[recall]\n"}</aff>
    <aff tool_name="zoom" description="Open a summary #a-b into its two halves (down to the memories themselves)."
         args_schema={{type: "object", properties: {lo: {type: "integer"}, hi: {type: "integer"}}, required: ["lo", "hi"]}}
         onZoom={({ lo, hi }) => {
           const end = hi + 1;
           if (end - lo < 2) return `#${lo} ${memories[lo] ?? "(none)"}`;
           const mid = Math.trunc((lo + end) / 2);
           const half = (a, b) => b - a == 1 ? `#${a} ${memories[a]}` : `#${a}-${b - 1} ${tree[`${a}-${b}`] ?? "(no summary)"}`;
           return half(lo, mid) + "\n" + half(mid, end);
         }}>{"[zoom]\n"}</aff>
    <aff tool_name="answer" description="Give your final answer for this session and end it."
         args_schema={{type: "object", properties: {text: {type: "string"}}, required: ["text"]}}
         onAnswer={({ text }) => { harness.stop(text); return "done"; }}>{"[answer]\n"}</aff>
  </>;
  const turns = [{kind: "input", content: `## Your memory\n${woke}\n\n## Task\n${task}`}, ...log.records];
  return <Context template={template} log={turns}>{app}</Context>;
}