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 builds a picture of you from things you said once and things it inferred, and you never see the picture. 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 makes that memory legible. Every remembered fact is 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. Built on the Minia design system. Opens in desktop by default; use the toggle for mobile. 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 piling up 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 control.
Drag the handle. The opaque store is on the left, the same memory rendered legible on the right. State colors follow the memory palette: indigo in use, slate scoped, coral withheld, rose forgotten.
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” or “inferred from 3 chats,” with a confidence read.
Scope it
Decide where a memory applies: this project, everywhere, or off. 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, where it came from, how confident the inference was, and exactly where it's allowed to apply. Rendered that way, memory stops being a vague sense that the assistant “kind of knows you” and becomes a list of discrete 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 helps 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 what's in use right now and what's being held back, so personalization never 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 wiping 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 this project, or forget it everywhere. No silent deletion, no all-or-nothing wipe, no ambiguity about what the assistant will carry forward. Revocation is a deliberate, legible act, which is the natural endpoint of memory you can 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 byproduct. You keep what helps, scope what's situational, and drop what you never wanted kept.
Try it in the prototype above. Switch from the Marketing project to a personal context and watch which memories drop out of “Used right now.” Pin an inferred fact to one 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 a ledger you can read, not a 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 one 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 switch memory off, but never see or touch a single thing it held.
-
2
+ A readable list of memories
Surfaced the facts as text. Visible at last, but flat, with no sense of where any of it came from.
-
3
+ Provenance & confidence
Tagged each fact “you told me” or “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 something you had to wipe and re-teach.
-
5
+ Scope by context
Added this project, everywhere, or 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: 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