Recall — see what the assistant remembers, and decide what it keeps
Attribute every fact. Scope it to a context. Revoke it on your terms.
Personalization is supposed to help, but it accumulates in the dark. The assistant quietly builds a picture of you from things you said once and things it inferred, and you never see the picture — so you can't tell what it knows, where a belief came from, which project it's bleeding into, or how to take it back. Recall is an exploration of making that memory legible: every remembered fact rendered as a card you can read, attributed to its source, scoped to where it applies, edited when it's wrong, and forgotten — precisely — when you want it gone.
Fully interactive — switch the context, change a memory's scope, edit a fact, or forget one, and watch “Used right now” recalculate live. Built on the Minia design system. Opens in desktop by default; use the toggle for the mobile layout. Data is synthetic.
The problem: memory you can't see
Personalization is invisible by default. You can't manage what you can't see — and right now there's nothing to see.
A helpful assistant remembers. But memory without a surface becomes a quiet dossier: facts you stated, guesses it made, preferences from one project leaking into another, all accumulating with no way to inspect or correct them. The fix isn't to remember less — it's to make memory legible. Four capabilities turn an invisible store into something you actually control.
See it
Every remembered fact is a card you can read — no hidden dossier, no guessing what it knows.
Attribute it
Each fact shows its source — “you told me directly” versus “inferred from 3 chats” with a confidence read.
Scope it
Decide where a memory applies — this project, everywhere, or off — so one context never bleeds into another.
Revoke it
Forget a fact precisely — from one project or from everywhere — named explicitly, never a vague wipe.
The thesis: a memory is an object, not an ambient mood
If the assistant remembers something about you, that something should be a thing you can point at — with a source, a scope, and an off switch.
Recall treats each remembered fact as a first-class object: the claim itself, where it came from, how confident the inference was, and exactly where it's allowed to apply. Rendered that way, memory stops being an ambient sense that the assistant “kind of knows you” and becomes a list of discrete, inspectable cards — each one editable, scopable, and revocable on its own. Legibility is the precondition for control.
A single memory card — rendered live in the Minia design system, the same theme as the prototype above.
Scope is the real control
The question isn't only what the assistant remembers — it's where that memory is allowed to act. Context is the dial.
A fact that's helpful in your work project can be irrelevant or unwelcome in a personal chat. Recall makes scope explicit: a memory can apply everywhere, stay pinned to one project, or be switched off. As you move between contexts, a live panel shows exactly what's being used right now and what's being held back — so personalization never silently follows you somewhere it doesn't belong.
What's used versus withheld, by context — rendered live in the Minia design system, the same theme as the prototype above.
Revocation should be precise, and it should be honest
“Clear all memory” is a blunt instrument. Forgetting should name exactly what's leaving and from where — so you can remove one thing without nuking everything.
The right to be forgotten only means something if it's specific. Recall's forget flow states the exact fact in plain language and offers a real choice: remove it from just this project, or forget it everywhere. No silent deletion, no all-or-nothing wipe, no ambiguity about what the assistant will and won't carry forward. Revocation is treated as a deliberate, legible act — the natural endpoint of memory you can actually see.
Forgetting, named and scoped — rendered live in the Minia design system, the same theme as the prototype above.
The payoff is personalization you consent to
When memory is legible, personalization becomes a negotiation instead of a surveillance by-product — you keep what helps, scope what's situational, and drop what you never wanted kept.
Try it in the live prototype above: switch from the Marketing project to a personal context and watch which memories quietly drop out of “Used right now.” Pin an inferred fact to a single project, correct one that's wrong, and forget the noisy inference for good. The activity log records every change, so what the assistant knows is always a ledger you can read — not a black box you have to trust.
How it got here: v1 → v6
Legible memory didn't start as a manager. Each version exposed one more layer — from an opaque on/off switch to provenance, scope, and precise revocation.
It began as a single toggle that hid everything behind it and ended as a surface you can read and steer. Each step closed a gap between what the assistant remembered and what you could see and decide — until memory was attributable, scopable, and revocable, fact by fact.
-
1
A single “memory: on/off” switch
All or nothing. You could disable memory entirely, but never see or touch a single thing it held.
-
2
+ A readable list of memories
Surfaced the facts as text. Finally visible — but flat, with no sense of where any of it came from.
-
3
+ Provenance & confidence
Tagged each fact “you told me” vs “inferred,” with a confidence hint — so a guess no longer looked like a quote.
-
4
+ Edit in place
Made memories correctable. A wrong inference became a quick fix instead of a thing you had to wipe and re-teach.
-
5
+ Scope by context
Added this-project / everywhere / off, with a live read of what's used where — so contexts stopped bleeding together.
-
6
+ Precise revocation · current
Forgetting that names exactly what leaves and from where — remove from one project, or everywhere, on purpose.
Explore more work
More explorations from the AI Product Design Lab — each a different facet of making AI products people can direct, verify, supervise, and trust.
Steer — intent before generation
Turn an under-specified prompt into a negotiated brief: surface the assumptions, name the ambiguity, and decide before the model commits.
View exploration
Ground — verify what AI claims
Every claim traceable to a source with confidence and freshness; unsupported claims flagged; source conflicts shown, not smoothed over.
View exploration
Oversee — safe agent autonomy
A control surface for agents that take real actions: scope it, preview it with a dry run, interrupt it mid-task, and undo what's reversible.
View exploration