How the assistant remembers you
Most AI starts from zero every conversation. This one doesn't. It carries forward what it's learned about you, your projects, your preferences, the decisions you've made, across every conversation and every channel. And it's yours alone: no other client can ever read it.
A look under the hood: how a fact gets remembered and recalled, how the assistant gets to know you over time, and the wall that keeps your memory yours.
The short version
As you work with it, the assistant quietly keeps the things worth keeping: facts, preferences, how you like things done, where your projects stand. Those memories are stored so they can be found by meaning, not just exact words, so later, on any channel, the relevant ones are pulled up and woven into its thinking before it answers. The result is an assistant that responds already knowing you, instead of one you have to re-explain yourself to every time. And every client's memory is walled off in its own space that no one else can reach.
That's the whole idea. The rest of this page is how a memory travels from a conversation into long-term recall, how it sharpens over time, and how it stays private.
The loop that makes it feel like it knows you. It keeps what matters (green), can recall it by meaning later, and answers already holding your context, no re-explaining.
From a passing remark to lasting memory
When something durable comes up, a preference, a fact, a decision, the assistant commits it to long-term memory. Later, whatever channel you're on, the memories relevant to what you're doing are retrieved and folded into its context before it replies, so it answers with your history already in mind.
The memories are stored by meaning, not just by keyword, so the assistant can recall the right thing even when you phrase it differently than you did the first time. Newer facts cleanly replace older ones, so its picture of you stays current instead of piling up contradictions, if you change your mind, the new preference takes the old one's place. The always-relevant memories surface on their own, and the assistant can also search back through the full history when it needs something older. You feel the effect as continuity: it doesn't forget what you told it last week, and it doesn't make you say it again.
It gets to know you over time
Memory isn't just a filing cabinet; it improves. On a regular quiet pass, usually overnight, the assistant reviews recent activity, promotes what genuinely matters into lasting memory, settles what changed, and lets go of what's no longer relevant. Every conversation makes the next one a little sharper.
This is the part that turns a tool into something that feels like it's learning you. In the background, it reflects on the recent work the way you might think back over your week: deciding what's worth remembering, reconciling anything that shifted, clearing out what's gone stale. So a month in, it fits you better than it did on day one, not because anyone retrained it, but because it's been quietly consolidating what it learns from working with you. Good memory tonight means fewer things to re-explain tomorrow.
Your memory is yours alone
This is non-negotiable. Every client's memory lives in its own namespace, enforced at the platform boundary. One client's assistant fundamentally cannot read another's memory. A request for the wrong space isn't just discouraged, it's rejected outright.
The separation is stamped in when your environment starts and checked on every single memory operation, and it's fail-closed: if a memory request can't prove it belongs to your space, it's denied rather than allowed through. Private notes stay private, surfacing only in the right context, and anything without a clear, valid visibility is dropped rather than risked. On larger setups, clients' memories live in entirely separate stores, so the data doesn't cross even at the lowest level. Your memory of working with the assistant is exactly that, yours, and there is no path by which another client could reach it.
The wall around your memory. It lives in a namespace of its own; a request from any other client is rejected outright, fail-closed. Never shared, by construction.
An assistant that remembers you is only worth trusting if that memory can't leak. So it's built to know you deeply, and to keep what it knows sealed to you.