Once I had finally found better words for the problem, the answer seemed obvious.

Memory.

My AI kept losing context between conversations, so I needed to give it a better memory.

Simple.

Except by this point, I had already built one.

Not the little box in an app where you tell it your job title and how you like your answers written. A proper memory system behind the agents I had been building.

Thousands of pieces of information. Searchable by meaning. Available after the original conversation had ended.

It was one of the more technically impressive things I had managed to create.

It also taught me that remembering something and understanding what it means are not the same thing.

Thirteen thousand memories

The system had started in ChromaDB, a database designed to help AI find information that is similar in meaning rather than only matching the exact words.

Later, I moved it into Postgres and pgvector so it could live alongside the rest of the system instead of becoming another disconnected island.

By the end of that work, 2,558 memory items had been broken into 12,307 smaller chunks. There were 13,318 searchable embeddings behind them.

That is a technical way of saying the AI had a library containing thousands of things I had previously told it, written or recorded.

I could ask a question without remembering the exact phrase used six weeks earlier, and the system could find material with a similar meaning.

That was a huge improvement.

Before, forgetting the wording often meant losing the information.

Now the information could come back.

I thought that was the problem solved.

The wrong thing came back beautifully

The difficulty was not whether the system could retrieve something relevant.

It could.

The difficulty was that relevant is not the same as current, true or important.

A rejected idea can look very similar to the decision that replaced it.

An early plan can contain almost the same language as the final version.

A confident answer from three months ago can be a perfect match for today's question and still be completely wrong because something changed yesterday.

The memory system did not naturally know the difference.

It could bring back the paragraph.

It could not always bring back its status.

Was this a fact or a suggestion? Had I agreed it? Had it been superseded? Was it still waiting for somebody else? Which later discovery had changed it?

The words were stored.

The life around the words was missing.

A library is not a case file

I had built something very good at finding books in a library.

What I actually needed was closer to a case file.

A case file does not only keep every document. It tells you which one is evidence, which one is an allegation, which decision is active, what changed, who decided it and what remains unresolved.

If a new fact arrives, it does not merely sit beside the old conclusion because the two contain similar words.

It can reopen the conclusion.

That was the part my memory system could not do by itself.

Embeddings could tell me that two pieces of text were related.

They could not tell me what that relationship meant.

The difference sounds small until you let an AI act on what it retrieves.

Then it becomes the difference between useful context and a very well-informed mistake.

More memory created a new problem

There was another uncomfortable lesson.

The better the memory became, the more convincing the answers could sound.

An AI with no context is obviously limited. You can see it guessing.

An AI that retrieves five detailed notes, an old plan and a previous decision looks informed. It can quote dates. It can use the right language. It can sound as though it knows the entire history.

But if it cannot distinguish the live decision from the dead branch, all that context can make the wrong answer more persuasive.

I had assumed more memory would mean less hallucination.

Sometimes it just produced better-supported confusion.

That was not a reason to abandon memory. The system genuinely needed it.

It was a reason to stop asking memory to do a job it was never designed to do.

What I actually needed

I still needed the library.

But I also needed the connections around it.

This came from that conversation. It created these three branches. This branch became a proposal. That proposal was rejected for this reason. A later fact changed the decision. This is the version that is active now.

Not just what was said.

What happened to it afterwards.

That is the difference between remembering information and preserving understanding.

The first gives an AI more material to answer from.

The second gives it a chance of knowing which answer still matters.

I had given my AI a memory.

It could remember thousands of things.

It still needed somewhere for the mess between them to live.