How Sponge uses Oh for agent working memory

Sponge’s retained hosted runs keep two kinds of memory apart. Their short-lived working notes go in a store built on Oh, and the knowledge you have reviewed lives in Sponge’s own database. Only the reviewed knowledge carries forward. Sponge is a private library for articles and PDFs, and this split lets those runs keep notes without turning them into findings.

Picture a research assistant three hours into a question about reef recovery. It has already opened a survey whose methods section turned out to be missing, ruled out a dataset that stops in 2014, and noted a figure it wants to check against a second paper. You want it to keep all of that while it works. You do not want any of it quoted back to you next week as if it were a finding.

Status: Sponge retired fresh hosted chat, report jobs, and hosted research on September 12, 2026. Working memory serves only the hosted work Sponge accepted before that date, and the Memory panel shows what those runs remembered.

Why remembered notes need review

If an assistant saves and retrieves an unreviewed note, a guess can return weeks later sounding like a finding. Without its source and review history, the reader cannot tell why it should be trusted.

A researcher needs an assistant that keeps notes while it works, shows you those notes on request, explains why one came back, and forgets them on schedule. Anything that should last past the session goes through review first, so it arrives with your decision and a cited passage attached.

What Oh provides

Oh is an open-source memory framework for agents. It keeps each fact as a record with a kind, a stable name, and the records it depends on. Every accepted change goes into an append-only log that can be replayed. A change based on an out-of-date view is refused. Oh treats search indexes as copies it can rebuild, and it never stores a fact only in an index.

For agent memory, Oh separates the notes an agent writes while it works from a fixed view of knowledge that someone reviewed. An agent can read both, and it can change only its own notes.

How Sponge connects Oh to retained hosted runs

Sponge runs the Oh memory store only on its servers. The browser never loads it, and the agent never talks to the database directly.

• Each run gets a private notebook. For retained hosted work in a document, Sponge opens a working session for that run. The session lives in a separate libSQL database that holds only agent memory. Documents, sources, and reviewed findings are stored elsewhere.
• Reviewed knowledge is read only. A session can pin the document’s reviewed knowledge at one exact revision. The agent sees that knowledge next to its own notes, labeled as reviewed, and cannot edit it.
• The agent has four actions. The agent gets four tools: remember, query, read one note, and explain why a note came back. Sponge’s server rechecks the document owner’s access on every call and records who wrote each note and when. The agent cannot supply either value.
• Sessions expire and are purged. Each session expires 24 hours after it starts, and a separate scheduled worker purges expired sessions. The owner can also clear a session early.

Sponge uses two other parts of Oh outside the notebook. Search over your own documents computes embeddings through Oh’s cloud embedding adapter. The vocabulary profiles you can preview and install for reviewed knowledge, such as Language, Research, and Finance, use the pack format, value codecs, and canonical JSON from Oh’s open research profile. The Research profile, for example, covers publication versions, studies, methods, samples, findings, and corrections. Sponge supplies the review workbench around them.

What you see in the Memory panel

Open Document actions, then Memory. The panel shows two lists:

• Working notes, described as “Private notes the agent wrote for itself in this session”
• Reviewed knowledge in view, described as “Reviewed knowledge the agent can read here but not change”

The panel also shows when the session started and when it forgets. Forget now removes the session’s memory before it expires. When the agent remembered or recalled something during a conversation, a card in the chat links to the panel.

Three rules apply to every session:

• Only the document owner can see working memory. Sharing or publishing the document does not include it.
• Remembered notes are not evidence. They need review before they can support a claim or citation.
• Each run has its own session, so a new run starts without the previous session’s notes. Your library and the knowledge you reviewed carry over; anything else that should last has to become a finding, with a source and your decision on record.

How the memory rules work

A write names the version it expects. Every remember call says which version of memory it was based on. If another step has changed memory since then, the write is refused and the agent has to read again. An identical retry with the same request id gets the original result back, and nothing is written twice.

remember(based on version 7, request "r-12", add "dataset ends 2014: ruled out")
  -> applied, memory is now version 8
remember(based on version 7, request "r-12", same change)   # a retry after a timeout
  -> same result as before, nothing written twice
remember(based on version 7, request "r-13", ...)
  -> refused: memory has moved on, read it again first

One call adds, replaces, or removes between 1 and 64 notes.

Questions come from a fixed menu. The agent cannot write its own query rules. It picks one of a few named questions, such as “what are the current notes”, “what relates to this one”, or “what supports this one”. Every answer marks each row as a working note or as reviewed knowledge, and conflicts stay visible.

query("current notes")
  -> [ note  lead:reef-survey-2016   digest 3f9a...
       known finding:bleaching-threshold  digest a1c0... ]
explain(row 0 of that answer)
  -> why this row came back, using a short-lived token issued with the answer

A run starts with names and digests. When the tools load, Sponge runs the “current notes” question once on the agent’s behalf and passes along at most 24 rows or 4,000 characters. Those rows carry names and digests only. To use a note’s content, the agent must read it, and the server checks it against the stored record first.

Fuzzy recall returns names and scores. Oh can index notes for similarity search, and Sponge has a fifth tool for that search. Its results would contain only a note’s name, digest, and score, so a similar note never enters the conversation unread. To compute the vectors, the rendered note text goes to a cloud embedding service. The index keeps only digests and vectors, and it can be rebuilt from the notebook.

A purged session stays purged. In Oh’s design, the worker that deletes a session holds its own credential. It can remove an existing session, or mark as empty a session that never finished opening. It cannot create a session, so a late write from a slow agent step cannot bring a purged session back.

What working memory does not cover

• Your own agent, working through Sponge’s API, does not get the working-memory tools. They belong to the hosted runtime that finishes previously accepted work.
• Working memory inside staged research runs is off by default until it has been measured. The setting does not affect chat turns in a document.
• Fuzzy recall runs in shadow only. Notes may be indexed, but no similarity result reaches the agent.
• Sponge pins its own Oh release (v0.10.8) and upgrades on its own schedule. Features in newer Oh releases reach Sponge only when it moves to them.

The Memory panel is documented under Inspect agent memory, and Introducing Sponge covers the rest of Sponge. Built on Oh lists other products that use Oh.