GUIDE

The complete guide to AI memory and context

What gets kept, who it belongs to, and what happens when it is wrong

By
David DanielThe complete guide to AI memory and context
QUICK ANSWER

Memory used to be the thing AI was missing. Now it is the thing that gets switched on by default, and a different set of questions arrives with it.

Not whether it should remember. What it should remember, which is a real choice with real consequences. Whether that memory belongs to you or to your business. How long it lasts. Who else can see it. And what happens when it has quietly got something wrong.

None of those feel urgent while memory is just a convenience. They all become urgent the moment something starts behaving differently because of what it remembers.

IN THIS GUIDE

The moment memory stops being a feature

For a while, memory is pleasant. The system recalls your name, your preferences, the project you mentioned last week. It saves you some typing.

Then something changes. It stops being a thing that recalls and becomes a thing that acts on what it recalls. It drafts differently for this client because of something you said in March. It surfaces a supplier before you thought of them. It flags a week as tight because of a commitment you made verbally three weeks ago.

That is the transition worth watching for, because everything about memory that seemed like housekeeping becomes consequential at that point. A wrong fact is no longer an annoyance. It is a decision made on a false premise.

Most people set up memory during the convenient phase and never revisit it. The questions below are much cheaper to answer then than afterwards.

What actually gets remembered

There are three different things people mean by memory, and treating them the same is where most problems start.

  • What happened. The client emailed on the twelfth. You agreed to Thursday. The invoice went out. These are records. They are verifiable, they came from somewhere, and they do not change.
  • What was concluded. This client is difficult about deadlines. That supplier is unreliable. You prefer mornings. These are inferences, drawn from records, and they can be wrong in a way a record cannot.
  • What was decided. We do not discount below this number. New clients get the longer onboarding. These are standing rules, and they hold until you change them.

The interesting failures come from collapsing these. A system that treats an inference like a record will defend it. One that treats a decision like an inference will quietly stop applying it. And one that cannot tell you which category something is in cannot be corrected sensibly, because you do not know whether you are arguing with a fact or an opinion.

The useful design is that conclusions stay attached to the records they came from, and decisions are marked as things you set rather than things the system noticed.

One person, several worlds

You are one person with a work life, a personal life, probably more than one business, and a household. Your obligations cross freely between them. A family commitment eats a work afternoon. A client deadline eats a weekend.

So a system that cannot see across them is blind to half of what constrains you. And a system that merges them is something you will not be comfortable using.

The principle that resolves it is the smallest piece of one world that does the job in another. Your work scheduling should know Friday afternoon is gone. It does not need to know it is a hospital appointment. One business should know the other is taking your Tuesday. It does not need the client list.

That is not a privacy setting bolted on afterwards. It is a structural question about whether memory has a notion of which world a thing belongs to, and most systems built for a single account do not.

One business, several people

Scope inside a business is a different problem from scope inside a life, and most systems only solve the first.

When a business remembers something, whose memory is it? Three people deal with the same client. Each learns different things. Some of what they learn should be shared, some should not, and some belongs to the person rather than the company.

Get this wrong in one direction and you have a system where everyone sees everything, which is uncomfortable and eventually unusable, because people stop putting real things into it.

Get it wrong the other way and the business learns nothing. Each person's understanding stays private, and when they leave it goes with them.

The model that works is the one businesses already run without naming it. There is a shared layer everyone draws on: client history, decisions, how things are done here. There is role-scoped material: the bookkeeper sees invoices, not everyone sees salaries. And there is genuinely personal space, including at work, because people need somewhere to think before they are ready to be quoted.

Which of those a given memory belongs in should be a decision, not an accident of who typed it.

What it remembers about other people

Your system does not only remember things about you. It remembers that this client escalates when things go quiet. That this supplier was evasive. That this employee struggles with deadlines.

Those are judgments about people, held in a system those people cannot see and cannot correct. Some of them will be wrong. Some were true once and are not now. All of them will influence how they get treated.

That is a meaningfully different category from remembering your own decisions, and it deserves different handling.

Three things help. Keep them attached to what they came from, so a judgment can be traced to the behaviour that produced it rather than floating free as a character assessment. Let them age, because a person who was unreliable in 2024 may not be now, and a system with no sense of staleness will hold it forever. And be careful about what gets shared, because a note that is fair as one person's working impression becomes something else when it is presented to the whole team as fact.

There is a simple test. If the person could see what your system holds about them, would you be comfortable, and would they say it was fair? Where the answer is no, you are holding something you should probably not be holding, or you should be holding it differently.

What it looks like when this is right

Nothing surfaces in the wrong context. Your work system never mentions the hospital appointment, and never needs to, because it knows Friday is unavailable without knowing why.

When something is wrong, you fix it in thirty seconds. You can see what the system thought, where it got it, and what it concluded from it. The correction sticks, and it does not come back next month because a different part of the system rediscovered the original.

New people arrive into a business that already knows things, rather than into a set of colleagues who each know different things. And when somebody leaves, the client history stays.

And a year in, the system is more useful than it was at the start rather than more cluttered, because things that stopped being true have quietly aged out instead of accumulating.

You cannot govern what you cannot trace

If a system cannot tell you where a piece of memory came from, none of the other questions have answers. You cannot set a retention period on something with no origin. You cannot scope it, because you do not know which world it came from. You cannot correct it properly, because you cannot tell whether you are fixing a fact or an inference built on one. And you cannot honour a request to delete something, because you cannot find everything derived from it.

So the practical question to ask of any system holding memory is not how much it remembers. It is whether it can show you why it believes something.

That sounds like an engineering concern. It is the thing that decides whether you can trust the system at all, because a memory you cannot inspect is a memory you have to take on faith, and you will not take much on faith once it starts making decisions.

Forgetting is four different things

People say delete and mean at least four operations, which is why so many systems handle it badly.

  • Remove a fact. It was recorded and should not have been. Straightforward, provided you can find everything that used it.
  • Retire something that stopped being true. The fact was correct and no longer applies. You want it gone from current reasoning without losing the historical record of it having been true.
  • Withdraw a conclusion while keeping what it came from. The calendar entry is accurate. The inference drawn from it is wrong. Deleting the entry to fix the conclusion is the wrong repair and loses real information.
  • Forget on somebody else's behalf. A client or an employee asks you to remove what you hold about them. This is the one most systems have no answer to at all, and it is the one with legal weight.

A system that only supports the first is a system where your only tool is a hammer. The second and third are what keep memory accurate over years, and the fourth is what makes it defensible.

How long, and who decides

Some things should be permanent. What you decided and why. The history of a client relationship. Those get more valuable with age.

Some should expire. Working context about a project that finished. An inference about someone's availability. A note about a tool you no longer use.

And some should expire on a schedule you did not choose, because a client contract or a regulation says so.

The useful default is that records persist, inferences decay unless reinforced, and anything about a third party has a shorter life than anything about you. That is a more careful default than most products ship with, and it is the one you would choose if you thought about it in advance.

What leaves with you

You will put years into this. Correcting it, confirming things, telling it how you work. That accumulates into something genuinely valuable, and the value is precisely that it compounds.

So the thing worth asking before you commit: if you left, what comes with you? The records, probably. The conclusions drawn from them, less likely. The structure that made any of it useful, almost certainly not.

A memory system that cannot be taken anywhere is a relationship with a switching cost that grows every month you use it. That is not automatically a reason to avoid one. It is a reason to know which one you are signing up for.

Why we built EverydayOS this way

We treat memory as something the operating layer owns rather than something each tool keeps privately, because every question in this guide becomes unanswerable otherwise.

If your context lives inside one AI product, you cannot set a retention policy across your business, cannot scope what one part sees, cannot trace where a conclusion came from, and cannot take any of it with you.

So EverydayOS is built so records, conclusions and decisions are held separately and stay connected to where they came from, so every memory belongs to a scope, so corrections outrank inference without destroying the source, and so what accumulates belongs to you rather than to whichever model is currently serving you.

What that is for is being able to let a system remember a great deal about your work and your life without that becoming something you feel uneasy about. The point is not maximum memory. It is memory you would be comfortable showing someone.

Where to start

  1. Find out what your current tools already remember. Most people have not looked. It is usually more than they expected and harder to inspect than they hoped.
  2. Separate records from conclusions in your own head. Then check whether the system can tell them apart.
  3. Decide the worlds before you connect the second account. Retrofitting a boundary is much harder than setting one.
  4. Write down what should never be remembered. It is a short list and it is worth having explicitly.
  5. Test a correction. Fix something wrong and see whether it stays fixed, and whether you can see why it was wrong.
  6. Ask the exit question before you are committed. What would leave with you.

What actually changes

The measure is not how much it knows about you.

It is whether you can explain why it believes something, fix it when it is wrong, and be comfortable with what it holds about the people you work with.

You notice it as a kind of ease. You stop hedging what you tell it. You stop maintaining a private mental list of things the system has got wrong that you have given up correcting. And you stop worrying, in the back of your mind, about what would surface in front of whom.

That is what good memory feels like. Not a system that knows everything. A system you are not quietly managing.

Put AI to work around what matters most

Join early access to EverydayOS and help shape an AI operating system that can coordinate the essential things across your work and everyday life, without making you manage another pile of disconnected AI tools.

Join Early Access