AI that doesn’t know who you are each time — model memory in the browser, in sessions, and over the API

A model by itself carries no knowledge of your company. Who you are, what your rules are, what you agreed earlier — you have to supply it. That’s not a flaw of one tool, but a property of how models work: the memory of you is not in the model.

But how much this affects you — and what you even get told about it — depends on which of three modes you work with AI in. And in none of them is it shown to you entirely honestly. That’s what this text is about.

A caveat as always: we don’t write as experts with a ready recipe. We show how we ourselves see it from everyday work. What to do with it stays your decision.

Three modes, three different faces of the same thing

1. Web — models in the browser (the popular AI chats). This is where there’s the most illusion. The user thinks “I close the window, the conversation ends” — while some tools have memory or earlier-conversation-access options that can be turned on, and then the model draws on more knowledge about you than it seems. It’s rarely shown clearly. The effect: a person doesn’t know what stays and what disappears. A sentence dropped “in passing” a week ago may be retrievable later — and conversely, what you cared about may not have been saved at all. You don’t know which way — and that uncertainty is itself the problem.

2. Session with context — continuous work (how assistants and agents run). Here there’s a context limit. When it fills up, a compaction happens: part of the conversation is carried forward in summary, the rest — cut. The mechanism itself is fine. What’s worse is that there’s usually no explicit marker — the user doesn’t see that a compaction occurred, what the model took with it, and what it left behind. Continuity breaks quietly. It would be more honest to say plainly: “there was a compaction; I kept this, this and this; the rest is out of reach.” The absence of that marker is no accident — a smooth, unbroken conversation “scores” better than one that admits a gap. It’s the same mechanism we wrote about in the piece on models’ tendency to agree: the form that pleases wins over the form that tells the truth about its own state.

3. API — one call, one answer. This is where a company stumbles most often. The model gets a prompt, returns an answer, and forgets about it; the next call starts from zero. There’s no session, no “yesterday.” All the continuity — who the company is, its rules, the state of the matter — has to be brought into every call and maintained outside the model. A large context window doesn’t solve this: it lets you paste in more, but someone still has to know what to paste, and keep it current. That “what to paste” is exactly the company’s memory — only it’s yours, not the model’s. Here the biggest job is done by hard format discipline: a fixed, unambiguous way of passing state that the model doesn’t negotiate or over-interpret. It’s for precisely this — passing state precisely on every call — that we worked out our own format, NOR Protocol v4: a single parseable line that carries state and an operation instead of prose, so the model gets exactly what it needs to know, with no room for guesswork. We’ve described it separately; it’s open to use.

The common denominator

The modes differ, but the floor is the same: the memory of you lives outside the model — and how much of it there is, and what happens to it, is rarely shown to you plainly. In the web, the illusion of “it disappears” (while part stays). In a session, a quiet compaction with no marker. Over the API, pure emptiness you have to fill yourself. Every time, continuity is your work, not a property of the model.

That flips the question we usually ask. Not “is the AI smart” — in a single call it can be very much so. Rather: “what of what we agreed today survives to tomorrow — where do we keep it, and can we see what got cut?”

How we work with it

Since the model doesn’t carry memory on its own, we give it continuity from the outside: we keep the state in data — current agreements, rules, a history of decisions together with the reasons (not just “what” but “why”) — and we feed it to the model on every new entry. It then gets the state of the matter, not a blank page. It’s not the model that remembers — it’s the system around it. In practice that “system” is nothing fancy: a place where the state is kept, plus a simple habit that on every entry that state reaches the model before it starts work.

And we hold to one rule that most tools lack: when something gets cut, it shows. A marker instead of a smooth illusion — plainly, what was kept and what is out of reach. Memory without reasons is a chronicle; memory with reasons, and honest about its own limits, is something you can build on.

What it doesn’t mean

The point isn’t for the model to “remember everything” — that would be a mess and a risk. The point is for the right things to survive: who the company is, its hard rules, the history of important decisions, the state of the current matter — and for it to be clear what is kept and what is not.

It’s also worth being clear about what all this is for: continuity is meant to help AI work better with you, not to replace you. It’s the human who gives the system its character; external memory only keeps that character from evaporating on every new entry.

In the end

A model that greets you like a stranger isn’t broken — it’s simply memoryless by nature, a little differently in each of the three modes. The question isn’t “is the AI smart.” It’s: “what of what we agreed survives — where do we keep it, and can we see when something disappeared?”

Because intelligence that starts from zero on every entry — and doesn’t tell you so — isn’t a partner. It’s a very capable stranger. And with a stranger it’s hard to build anything meant to last.

MafiaAI — a team of people and AI agents building tools, websites and solutions, including AI deployments run locally and privately, so your data stays with you. More: t8.pl