Unforget: Engineering Notes

How a thought app that "answers back" works under the hood: semantic memory, local-first inference, and the order of operations as product design.

Recall before storethe core trick 2-tier inferencelocal first, cloud fallback Encrypted at restevery thought Installable PWAoffline shell

The idea

Most notes apps are write-only graveyards: capture is easy, resurfacing never happens. Unforget's bet is that a thought's value is what it connects to. So the signature moment runs the product backward: when you save a thought, the app answers with the prior thoughts it connects to, each with a short AI-written line explaining why. Saving feels like the app thinking with you rather than filing for you.

Unforget is the consumer surface of the CogmemAi memory engine: the same retrieval stack that posts benchmark results serves "3 of your thoughts connect" to someone typing on a phone.

Architecture

Recall before store, and why the order matters

The connection search runs against the user's memory corpus BEFORE the new thought is written. Store first and the top match for every save would be the thought itself. The ordering is one line of sequencing that is really product design: it guarantees every answer is about your past, not your present.

From the production save path, including the latency honesty:

/* The connection search is the slow part of a save (embeddings plus two
   vector queries, several seconds). A client that asks for async_conn gets
   the thought written and the id back straight away, then fetches the
   connections through ?a=conns while the "Saved" state is already on
   screen. Older cached clients still get them inline: recalled BEFORE the
   store so the new thought can never match itself. */
$async_conn = !empty($b['async_conn']);
$connections = array();
if (!$async_conn) {
    $connections = unf_connections($uid, $text, 0, 3);
}
$stored = store_memory($uid, array(
    'content'     => $text,
    'memory_type' => 'thought',
    ...
));

Local-first inference, and what it actually costs

The why-lines are generated by a small language model running on the same server (via Ollama), with a cloud model (Claude Haiku) as fallback. Local inference keeps the marginal cost of the signature feature near zero and keeps thought content on the box.
The lesson that came with it: a local model that silently dies does not error, it quietly degrades everything that depends on it. A watchdog now probes the model hourly and restarts it when needed.
Cold starts are real: the first generation after a restart takes 10 to 15 seconds while the model loads, so the product carries honest loading copy instead of a frozen spinner.

Local-first inference is an operations commitment, not a config flag. The model is another service that can die, go stale, or start cold, and the product has to be designed for all three.

In-process engine, no API hop

The API is a single front-door endpoint that calls the memory engine's classes directly in-process: no internal HTTP, no API keys in transit, one fewer failure surface. The front-door pattern itself is a real-world constraint made useful: the site's firewall blocks the public REST API, so the app's API lives at its own hardened entry point with method checks, input caps, and per-action auth.

Security posture

Every thought is encrypted at rest; decryption happens inside the engine on recall.
Auth tokens are random, and only their SHA-256 hashes are stored (newest ten per user kept, so old devices age out).
Per-user project isolation in the memory store; signup is IP-rate-limited; daily caps are enforced server-side per tier, never trusted to the client.

A task manager with no task system

Any thought can become a task: task state is a thin metadata overlay on the memory, not a second data model. The payoff shows up in connections, in the words of the production comment: whether a connection is itself a task, and whether that task is still open, is the difference between "here is a related thought" and "you already wrote this down and have not done it."

The client

A single-file installable PWA: inline CSS and JS, a service worker that caches the shell and never caches the API, voice capture, and offline-tolerant startup. One file is a constraint that keeps the whole surface reviewable at a sitting.

Try it

Unforget is live: five thoughts a day free, no install required, installable if you want it on your home screen. It is part of the HiFriendbot product family, built on the same engine as CogmemAi.

More engineering notes: HiHiredBot Sniper.