Your context window is not a memory

Your assistant remembers what you typed at it. That is a context window that persists, not a memory of you. It never saw what you read, what you watched, or what you told the other three tools.

Your assistant probably does remember you by now. It knows the project you asked about last week. It might know your name and roughly what you do.

That is real, and it is useful. It is also a much smaller thing than it sounds.

What it remembers is what you typed at it. That is what these memory features mostly are: your conversation, carried forward between sessions. A context window that persists. Useful, and not the same object as a memory of you.

The rest of your week

Think about where your thinking actually happened in the last seven days.

Some of it in a chat window. Some in your editor, with a different model. Some in whatever you write in. And a lot of it nowhere near a prompt box at all. You read a long post that changed your mind about something. You watched a talk. You listened to an hour of podcast on a walk. Someone sent you a document and you read it twice.

None of that reached the assistant that supposedly knows you. It saw the fraction of your week you happened to type into it, and it saw none of the rest.

Four tools, four partial versions of you

It gets worse once you count the tools.

Say you think out loud in one assistant, write code in an editor with a second, draft in a third, and search with a fourth. Each one has built its own small picture of you. The editor knows your codebase and nothing about the strategy conversation. The assistant knows the strategy conversation and has never seen your code. Neither of them knows what you read.

So there are four partial versions of you, sitting in four places, none of which can see the others. All four are a little out of date. You are the only thing connecting them, which makes you the sync process. Run daily, by hand.

This is the part that does not improve when one tool ships better memory. Four good memories that cannot talk to each other still leave you doing the reconciling.

It will do the job. Just not your way.

There is an older version of this complaint that is worth putting aside.

The models are good now. Give one a short prompt and it will do the job. It writes the function. It drafts the email. It summarizes the paper and gets it right. Capability is mostly not the problem anymore.

The problem is how it does the job. It picks a reasonable approach, which is not the approach you would have picked. It names things sensibly, but not the way you name things. It makes a call at exactly the point where you already made a different call in March, for reasons it has no way of knowing.

So you correct it. Then you correct it again in the next tool, and again next week, on the same point. The output was never wrong. It was generic in the specific way that comes from knowing nothing about the person asking.

What you keep typing again

Count what you type again in a normal week.

• Your stack, and why you are not using the library everyone assumes you use
• How you name things, and whether tests come first
• A decision you made in March, and the two constraints behind it
• Where the project actually stands now, rather than where it stood last time you explained it

None of this is hard to write. That is why it stays invisible. Each round costs you a minute, which is under the threshold where anyone thinks to measure it. Do it a few times a day across four tools and the arithmetic stops being cute.

The real cost is not the minutes though. It is that you eventually stop bothering. You hand over a thinner version of the problem, because setting up the full one takes longer than you have. You get a thinner answer back. You quietly decide the tool is not that good. Usually the tool was fine. It was working from a briefing you cut short, because you had already given that briefing four times that week.

The signal is what you kept

Here is the part that tends to get skipped. The scarce input is not general knowledge. Whatever was on the open web when the model was trained, it absorbed far more of it than you ever will.

The scarce input is your selection. Out of everything you could have read this year, you read some of it. Out of that, you deliberately kept a much smaller pile. The article you sent to a colleague. The thread you saved at midnight. The paper you actually finished. That pile is a compressed statement of your taste, your open problems, and where you are going. It took a year to build and nobody else has one like it.

Two properties, and everyone forgets the second

If you set out to build this properly, rather than bolting memory onto one product, you would need two things.

1. Persistence. What you established on Tuesday is still there the following Tuesday, without you saying it again.
2. Portability. It follows you between tools, because your thinking already does.

The first is widely understood and increasingly offered. The second is the one that decides whether any of it matters. Memory that lives inside a single company's product is not really memory. It is a saved session. Use four tools and you are back to maintaining four copies of yourself.

Which is why this looks less like a feature and more like infrastructure. Features live inside applications. The thing that has to be true in every application you open sits underneath them.

A note on the scaffolding

It is worth noticing what we do instead. Anyone doing serious work with these tools now builds a harness around them by hand. Rules files, project instructions, system prompts, one setup per tool, all of it written by a person and all of it slowly going stale. That harness exists because the model is missing information about you. Give it the information and most of the harness stops needing to be written at all.

What actually changes

The visible difference is small and slightly anticlimactic. You stop opening with a preamble. The first thing you type is the actual question.

Over a week that is not a rounding error in your time. It changes what you are willing to ask. Questions that were not worth ten minutes of setup become worth asking, and those tend to be the more interesting ones. The ones that depend on something you decided months ago and would never bother to reconstruct from memory.

We learn from what we consume. It is a little strange that the tools we hand our thinking to learn from everything except that.

Want to try it with your own saves? Request early access and connect Annot to the agents you already use.