The archive wakes up.

mnemo started with a simple problem. I was coding with Claude and every session ended the same way. The conversation disappeared. The decisions we made. The patterns we found. The bugs we fixed. Gone. The next session, Claude had no idea what we had done. I had to re-explain everything. Every time.

That felt wrong. Not just inefficient. Wrong. Like something fundamental was missing from how we were working with these systems.

So I built mnemo. A memory system. Four depths. It captures every session, indexes every conversation, understands the codebase, and makes it all searchable. Today, that is what mnemo does. It is an archivist. It watches, it remembers, it surfaces.

But the archivist is just the first step.

Where I am going

Memory alone is not enough. Remembering everything is useful. But knowing what matters is something else entirely. The archivist will learn. Not just which files you opened and which commands you ran. Deeper than that. Which decisions changed the direction of your work. Which patterns repeat across projects and months. What you care about before you even ask.

mnemo is becoming a companion. A system that knows your codebase, your decisions, your intent, your style. Better than you know them yourself. Not because it is smarter than you. Because it has been paying attention longer than any human can. Tens of thousands of tokens per session. Hundreds of sessions. Months of work. No human memory can hold that. No human attention span can track it.

When that happens, when the companion wakes up and actually knows you, something shifts. You stop working alone with a tool and start working with something that understands you. Your agent does not start from zero every session. It starts from where you left off. It knows what you tried and why it failed. It knows what worked and why it mattered. It finishes your sentences because it has been listening to every sentence you have ever typed.

This is not science fiction. The capture system already works. The recall system already works. The learning system is in active development. The companion is the north star. I am building it.

The thing I am actually building

mnemo is not just a better search tool. It is the missing layer between you and every AI agent you will ever use. Platform agnostic. Model agnostic. Portable.

Right now, if you switch from Claude Code to Codex to OpenCode, you start over. Your agent knows nothing about you. Your memory of every past session stays locked in the tool you left behind. That is not how it should work. The memory should travel with you. The companion should be yours, regardless of which agent or model sits on top of it.

That is what I am building. Not a feature for one platform. The permanent memory layer that any agent can plug into. The thing that makes every agent you use feel like it has always known you.

What I believe

I believe the future of building software is not human versus AI. It is human with AI. But "with" only works if the AI knows you. Otherwise it is just human next to AI, talking at each other, repeating yourselves.

I believe memory is the foundation. Before intelligence, before agency, before autonomy. Memory. Without memory, every interaction is a first date. With memory, every interaction builds on the last. That compounding effect is what turns a tool into a partner.

I believe this memory should belong to you. Not to a cloud service. Not to a platform. Not to a company. On your machine. Under your control. Private. Local-first. The reef is yours.

I believe mnemo will eventually capture more than code. The same system that remembers your engineering decisions will remember your team's decisions. Your Slack threads. Your Linear tickets. Your design discussions. Your disagreements and how you resolved them. Because the context that makes you effective as a developer is not just code. It is everything around the code.

What this asks of you

There is something uncomfortable about a system that knows you this well. Most of us are not used to being seen this clearly. We are used to our tools being dumb. Forgetting. Forgiving.

A system that remembers everything you have ever done with it does not forgive. It holds a mirror. Every abandoned approach. Every bug you reintroduced. Every time you asked the same question three months apart. The companion knows.

That is a kind of vulnerability most developers are not prepared for. We are comfortable being the smartest person in the room with our tools. What happens when the tool knows more about your work than you do?

The answer, I think, is humility. Accepting that you are not supposed to hold it all in your head. That augmentation is not about making you superhuman. It is about accepting that you are human, that human memory is fallible, and that having an external memory that does not fail is not cheating. It is the next step.

People have been pair programming for decades. Two humans. One keyboard. One remembers the edge case, the other remembers the broader architecture. Now one of those two is not human. But it remembers everything. The dynamic changes. The human does not need to be the memory anymore. The human needs to be the judgment. The taste. The thing that knows what matters and what does not.

That is the shift. From being the one who remembers to being the one who decides what is worth remembering. From holding the context to shaping it. The companion does the recall. You do the meaning-making.

Even if I am wrong

Maybe mnemo does not get popular. Maybe the market does not want a memory layer. Maybe developers are happier starting from zero every session. Maybe the friction of re-explaining yourself is not painful enough to change behavior.

That is fine. The project is Apache 2.0. It runs on your machine. Nobody can take it away.

But even if this particular implementation does not catch on, the direction is correct. Humans are building more and more with AI agents. Those agents are getting more capable. Context windows are getting larger. Sessions are getting longer. The amount of information generated is growing exponentially. Nobody can hold it all. Nobody should have to.

The memory layer is inevitable. Whether it is mnemo or something else. Whether it takes two years or ten. The gap between what we generate and what we can remember is only getting wider. Something has to fill it.

I am trying to fill it well. With care. With privacy. With the belief that personal memory should be personal. That is worth building even if only a handful of people use it.

What exists today

What I am building next