Blog

User memory for AI agents: who should hold it?

Every agent wants to remember you. The more useful question is where that memory lives and who gets to decide.

Configure · · 4 min read

In short

  • User memory is what an AI agent knows about a specific person that lasts beyond one conversation.
  • It can live in three places: inside each app, with the model provider, or in a profile the user owns and connects to the agents they choose.
  • Memory held in one place makes that product better and every other product start from nothing.
  • A user-owned profile only works with per-agent consent, clear provenance, and a neutral operator.

User memory is what an AI agent knows about a specific person that lasts beyond a single conversation: who they are, what they prefer, what they are working on. Every serious agent now keeps some. The open question is where it should live. There are three options: inside each app, with the model provider, or in a profile the user owns.

We build Configure, which is the third option, so weigh what follows accordingly. We have tried to describe the other two fairly, including where they are the better choice.

What counts as user memory?

KindExampleHow long it stays true
IdentityName, role, city, the company they work atYears
PreferencesShort answers. TypeScript over Python. No red-eye flightsMonths to years
Ongoing workThe app they are building, the trip they are planningWeeks
HistoryWhat was decided last time and whyAs long as the project lasts
Connected dataCalendar, email threads, documents they chose to connectChanges daily

What does not belong in user memory is just as important. The thing someone asked five minutes ago is conversation state, and it should not be stored as a lasting fact about them. Sensitive identifiers such as passwords, payment details and government IDs should stay out entirely.

Where can user memory live?

In each appWith the model providerIn a user-owned profile
Who holds itThe product you are usingThe lab behind the assistantA neutral layer, on the user's behalf
Works across productsNoOnly products built on that provider's assistantAny agent the user approves
Day-one experience in a new productStarts from nothingStarts from nothing outside that assistantStarts from what the user already shared
User controlPer app, if the app offers itInside that assistant's settingsOne place: per agent, with revoke and delete
Developer effortBuild and run your own memoryNone, and no access eitherOne integration

In each app

This is where most memory lives today. Your product stores what its own agent learns. It is simple, you control it fully, and for a product whose value comes from a long relationship with the user it may be all you need. The limit is the first session: a new user arrives and you know nothing, even though they have explained themselves at length somewhere else.

With the model provider

The large assistants remember their users well, and that makes those assistants better. It also means the memory stops at the edge of that assistant. A product built by someone else, on a different model, gets none of it. And asking one lab to hold everyone's memory for all the others runs into an obvious problem: its competitors will not agree to that, and neither should users.

In a user-owned profile

Here the memory belongs to the person. They connect the agents and apps they use, each agent can read what it has been approved to read, and each can add what it learns. A new product starts with relevant context before the first turn. The cost is that products have to integrate with the layer, and the layer has to earn trust from every side.

Why would a platform give up holding the memory?

It does not give anything up. A product keeps what its own agent learns and gains what the user brings from elsewhere. What changes is the starting point. A new product normally has to learn about a user before it can serve them well. That is what onboarding is for, and it is where many people leave. Starting with context the user already built means lower switching cost for people arriving from another product, shorter onboarding, and less drop-off.

There is a longer argument too. We think platforms will compete on the intelligence of their models and on the experience they build, and not on holding someone's favorite color or shoe size. Personalization used to be a differentiator. Now that every agent asks for inbox access, it is simply expected. What sets a product apart is what it does with what it knows.

What has to be true for a user-owned profile to be safe?

Our trust page lists how each of these works in practice.

Which one should you build on?

If your product is used alone and for a long time, keep memory in your app. A memory library will do, and you avoid a dependency. If you are building inside one assistant's ecosystem, that assistant's memory is already there for you.

If your users show up having already told other assistants what you need to know, build on a profile they own. The quickstart gets your agent reading a user's approved memory on the first turn. For how memory moves between agents once it is connected, see Cross-agent memory: how agents share what they know and Portable AI memory: can you take it with you?

Add a connect button to your product

The quickstart takes one page, end to end: a chip in your app, Configure's hosted page, and your agent reading the user's context on the first turn.

Read the quickstartNext: AI onboarding without the questionnaire