You Are The Integration Layer
Your AI remembers now. Are you still the one holding it together? It does not have to be that way
The AI remembers me now. Holding it together was always my job. Not anymore.
For most of the time I have been writing this book, the AI cost me the same tax every day. Not a wall. I had learned to set up a project well. The instructions were tight, the knowledge files were clean, the system worked and none of it was guesswork anymore. The cost was smaller than that and harder to see. It was scattered. A minute at the top of every window while the AI found its footing. Then, all through the work, the small repeated nudges. Search the chat for what we said earlier. Go look in the project files for that. It would not reach for the right thing on its own, so I reached for it, again and again, a handful of seconds at a time, all day. Add it up across a month and the tax is not small. It just never arrives in one piece.
This is part of a book I’m writing in public.
Subscribe to read the rest as it comes
Somewhere in March it got a feature that should have helped. I noticed the AI starting to carry things across chats inside a project. Open a new window and it would already have a rough sense of where we had been. That was welcome, and I want to be fair to it. But it did not remove the tax. I still manage the recall by hand, still tell it to search the chat, still point it at the files, because what it carries on its own is small and I do not control what makes the cut. It remembers what it decides to remember, in the shape it decides, and I take what I am given. It is real. It is just not mine.
That distinction turns out to be the whole subject.
Three things you don’t get to decide
The first is what gets kept. The memory works by extraction. After a conversation, a background process reads it and pulls out what it judges worth holding. Routine exchange is dropped. It leans toward the recent, so older context fades on its own. You do not set the rule for what survives. You find out what survived by reading it later.
The second is who writes it down. The summary that loads into your next chat is rebuilt by an automated pass on a schedule. You can open it, read it, delete lines that drifted. What you cannot do is author it. Editing a summary after a machine has written it is not the same as writing it. The shape is the model’s. The phrasing is the model’s. You are correcting a draft you did not get to compose.
The third is that it stays in the room it was born in. Memory is scoped per project, which is mostly right. The context for one project should not bleed into another. But the wall runs one direction only. A summary built in one project never reaches the next, even when the next project is yours, about you, and would be better for knowing what the first one knows. There is no layer underneath the rooms connecting them.
None of these are bugs. They are reasonable design choices. Extraction keeps the memory small. An automated pass keeps it current without your effort. Per-project scoping keeps your work separated. The choices are sound. They just leave you, the person, doing a particular kind of work by hand.
You are the integration layer
Here is what the scattered tax actually is, once you look at it straight.
To keep one AI’s context straight, you maintain three separate stores, and they do not talk to each other. There is the memory the platform synthesizes, which you prune in Settings. There are the project instructions, which you hand-write, and re-write, for each project. There are the knowledge files, which you upload and name and file. Three stores, three different screens, three different mental models. The synthesis is something you correct. The instructions are something you author. The knowledge is something you file. They never meet on a single surface. You are the surface. The record of the work lives in places you have to leave the conversation to reach, and you are the one keeping all of it current, moving between the rooms yourself, holding in your head what connects to what. The tax is you being the thing that connects the parts.
The instructions are the clearest case. Everything about how the AI should show up, its voice, how direct it is, when to push back, lives in the project instructions. Which means it lives in that project. Start a second project and you write it again. A third, again. And then the worse part, which is not the writing but the keeping. Now there are three copies of who the AI is, and the day you change your mind about one rule you have to find it in all three and change it the same way, or they drift. One project ends up a little more formal than the others and you cannot remember why. There is no shared place to put the parts that should never differ, so you become the place, and staying consistent across the boxes is a job that never ends.
The knowledge files, which are the closest thing to a real archive, are harder to live with than they look. They crowd quickly. They are awkward to manage past a handful. They do not carry across projects, so three related writing projects cannot share a single source. When the AI searches them it sees fragments ranked by similarity, not the documents whole. Most days the retrieval is fine. Some days the passage you needed sat just below the cutoff, and no rephrasing reaches it.
I built the map below to stay honest about all of this. It is not a list of failures. Every “yes” in it is a real yes. It is a map of where the work still falls to the person.
Capability What native Claude memory does The seam Remember you across separate chats Yes, within a project. Carries a rough sense of prior chats. Small, and you don’t control what it carries. Keep separate contexts per project Yes. Each project has its own memory. The wall runs one way. One project’s memory never reaches another. Decide what gets written down The model decides. It extracts what it judges worth keeping. You don’t set the rule. It’s recency-biased. Old context fades. Author the summary in your words No. A background pass rebuilds it on a schedule. Editing after the fact isn’t authoring. The wording is the model’s. Hold who the AI is, across projects No. Identity and voice live in each project’s instructions. You re-write it per box. Nothing shared underneath. Read the actual record of what you said No. What persists is a derived summary. You get the model’s reading of the conversation, not the conversation. Carry context across projects No. Memory stays in the project it was born in. Nothing connects the rooms underneath. Load itself without being asked Partly. The platform injects the project summary on its terms. You don’t control when it fires or what it pulls.
I built my own rail for the bottom of those columns, and the part that earns its keep every day is the one most people would not expect.
One ground, many voices, no re-typing
The thing I wanted was simple to say and missing everywhere. I wanted a single place to hold who the AI is, underneath everything, so I would never write it twice. And I wanted to set a different voice for a different room without rebuilding that foundation each time.
Those are two different layers, and the platform collapses them into one. Project instructions are the only place to put both the unchanging core and the per-room voice, so the two get tangled, and you maintain the whole stack in every project whether it changed or not.
Pulling them apart is the entire trick. Underneath sits the ground: who the AI is to me, the rules that hold regardless of what I am working on, the things that should never be re-stated because they are never different. That layer loads under every room on its own. I do not write it again. It is simply true everywhere.
On top of it sits voice, declared per room. A writing project can have one register. A different kind of work can have another. I set that for the room I am in, and the ground does not move. The core entity stays intact while the voice changes over it. I am not maintaining a copy of the foundation inside each project and praying the copies stay in sync. There is one foundation, and a thin layer of voice I choose per room.
That is the usefulness. Not that the AI remembers more. That I stopped re-typing the parts that should have been permanent, and gained the ability to change the parts that should be local, without those two things fighting each other inside one box of instructions.
Continuity does not care what it carries
Something I did not expect came out of building it.
I made the thing to hold a book. Chapters, drafts, the state of the work, the people I have worked ideas out with, the ones I brought something new to or argued a position against. But the rail underneath turned out to be indifferent to all of that. The same mechanism that carries a chapter’s history carries a sales thread, or a piece of code, or a conversation with nothing to do with writing. It is just continuity, and continuity does not care what domain it is carrying. The context follows me from a writing window into a coding tool with no seam. It could follow a team the same way, if I wanted it to.
I am not going to make a claim about what that becomes. Most memory tools are built from the developer side, for agents and pipelines, and they reach the person almost as an afterthought. I came at it from the other direction. I wanted the AI I actually talk to, across months, to know who it is and remember where we were. The infrastructure was a side effect of that wish, not the goal. I notice the side effect is general. I am leaving it at noticing.
What I built
For a year I was the integration layer. I built the thing that took the job.
I call it Muninn. It gives me a memory I can read in full instead of a summary, that I author instead of correct, that runs underneath every project instead of inside one, and a voice I can set per room without re-laying the foundation each time. It loads itself when a conversation opens. I do not spend the first two minutes telling the AI who it is, and I spend far fewer of the scattered seconds through the day pointing it at the right room. The tax is mostly gone.
I have written about the pieces of it elsewhere, and I will keep writing about it here, because I am still finding out what it is. This was never a product I set out to make. It was a thing I wanted for the AI I actually talk to, and it turned into something I think other people might want too.
So I will end on a question instead of an answer, and it is the one in the title, turned around to face you. Your AI remembers you now too. But the record of who it is and what you told it lives in screens away from the conversation, and you are the one keeping those screens current by hand. You are the one holding the copies in sync, carrying what matters from one room to the next, being the thing underneath because nothing else is.
I did not make that work disappear. I still direct my AI, still point it at things. But far less of it, and the parts I do are mine to control, and the record now lives inside the conversation instead of in rooms I have to leave to maintain. The difference is not that the work ended. It is that I stopped being the only thing holding it together.
Are you still the integration layer?
The comments are open and an invitation always stands. If you want what I wanted, an AI that knows who it is and holds what you told it in your own words, say so. I would like to know how many of us there are.
I am writing this book one chapter at a time.
If you want to read it as it happens, subscribe below
If this made you think, share it with someone who needs to read it.
BØY (Chaiharan) has spent 30 years in tech — building products, recovering disasters, and turning around the things nobody else wanted to touch. Based in Bangkok. Writing a book in public about what AI reveals about the humans who use it.