Pompom is approaching its first public GitHub release. It is open-source, local-first, and built around Markdown files you own.
Think about the AI model you were using two years ago.
You probably don’t use it anymore.
Perhaps you switched to a more capable model, moved to another provider, or started using an entirely different application. The transition may have taken only a few minutes.
But what happened to everything the previous system learned about you?
The projects you discussed. The decisions you made. The mistakes you corrected. The ideas you explored and abandoned. The preferences you explained, sometimes repeatedly.
Some of that information may still exist in a chat history. Some may have been captured by a memory feature. Some may already be lost.
And when you move to the next system, much of it doesn’t come with you.
This reveals a peculiar contradiction in how we are building personal AI.
The intelligence keeps improving, but the relationship keeps starting over.
I think we have the architecture backwards.
The wrong thing is becoming permanent
The AI industry is organised around models.
We compare their intelligence, reasoning abilities, context windows, speed and cost. Every few months, a new release changes the competitive landscape.
This is a remarkable development. Intelligence is becoming more capable, more accessible and, increasingly, more interchangeable.
But consider the other side of the interaction.
Over months and years, you accumulate something valuable through your work with AI.
Not just information, but context.
Why you chose one approach over another. Which arguments changed your mind. How a project evolved. What you have already investigated. Which conclusions remain uncertain.
An individual conversation may not be particularly valuable. But the connections across hundreds of conversations, notes, documents and decisions can be.
This accumulated context is personal. It is difficult to reconstruct. And unlike an AI model, it cannot simply be replaced by downloading a better version.
Yet we often keep it inside applications whose models, interfaces, storage systems and business models we do not control.
The most replaceable component is becoming the centre of the architecture.
The least replaceable component is becoming a dependency.
I think personal memory should be the durable layer, and AI models should be replaceable tools that work with it.
Owning your data is not the same as owning your memory
There is an important distinction here.
You might be able to export your AI conversations. You might have copies of your notes and documents. You might even keep everything in a local database.
That gives you some degree of data ownership.
But does it preserve your memory?
Suppose you spent six months researching a difficult technical problem.
During that time, you explored several hypotheses, rejected two approaches, discovered conflicting evidence and gradually developed a better understanding.
Six months later, you return to the problem.
A folder containing hundreds of conversations is not the same as a system that can help you recover what you learned.
You need to know which conclusions survived scrutiny, which assumptions were overturned, where the evidence came from and what remains unresolved.
The difference is between storing information and preserving an evolving understanding.
Search can help you locate the original material. But useful memory requires something more.
It needs connections, context and the ability to distinguish an old belief from a newer one.
And it should retain a path back to the evidence, rather than replacing your original thinking with an opaque AI-generated summary.
This is the problem that interests me.
Why I am building Pompom
I’ve been working on Pompom, an open-source, local-first, AI-native Markdown notebook powered by LEAP, a memory and continual-learning framework.
The starting point is deliberately simple.
Your knowledge lives in ordinary Markdown files on your own machine.
Not in a proprietary format. Not in a database that only one company can interpret. Not in a cloud account you must maintain indefinitely.
You can read the files with a text editor. Work with them using Git. Back them up however you prefer. Move them to another application.
The longer-term ambition is to build a memory system around those files, one that can discover relationships, consolidate knowledge, track how understanding changes and recover useful context when it matters.
The distinction is important.
The Markdown files are yours. The intelligence around them can evolve.
If a better model arrives next month, your accumulated knowledge should not have to start again.
If you decide to use a local model instead of a hosted one, the same principle should hold.
If Pompom itself disappears one day, your original files should remain accessible.
Retrieval is not learning
There is a deeper technical challenge.
Most AI memory systems begin with retrieval.
Store information, convert it into embeddings, find relevant passages and supply them to a model when needed.
This is useful. It is also how Pompom’s initial semantic search works.
But retrieval alone is not memory in the richer sense.
Imagine you have written twenty notes about an emerging technology.
The first five reflect your initial enthusiasm. The next ten contain technical discoveries and competing interpretations. The last five explain why you changed your mind.
A retrieval system may find any of those notes.
A more capable memory system should help you understand the progression.
It should recognise that some conclusions supersede earlier ones. It should identify unresolved contradictions. It should distinguish well-supported knowledge from tentative speculation.
It should also know when it does not have enough evidence to answer.
That is part of the motivation behind LEAP.
I am interested in memory as an ongoing learning process, not merely a collection of facts that can be retrieved.
That means exploring how a system can consolidate information while preserving sources, evaluate whether its memory adequately covers a question, and return to original material when its understanding is incomplete.
There is a tension here.
The more a system consolidates, the more useful its memory may become. But consolidation can also introduce errors, erase uncertainty or quietly turn an interpretation into an apparent fact.
A trustworthy memory system needs to manage both sides.
It should become more useful over time without becoming less accountable to the information from which it learned.
These are research and engineering problems, not capabilities I claim Pompom has already solved.
But they are the direction in which I want to take it.
A personal memory that outlives its models
Now imagine a different relationship with AI.
You spend years reading, writing, researching, building things and making decisions.
Your notes accumulate. Your understanding changes. A memory system helps organise that knowledge, preserve its origins and surface relevant context.
Meanwhile, the models keep changing.
One model is better at reasoning. Another is better at coding. A third is inexpensive enough to run locally. A new generation arrives and makes all three look primitive.
You should be able to benefit from those improvements without rebuilding your personal context every time.
A new model should be able to work with your existing memory, subject to the access you choose to give it.
And a better model may discover relationships or implications that an older one missed.
In that sense, your accumulated memory can become more valuable as intelligence improves.
This is the architectural separation I want:
You own the memory. Models receive access to it, not ownership of it.
There are still difficult questions about privacy, permissions, memory quality and how much control users should have over consolidation or forgetting.
But I think the direction matters.
For years, software has treated personal knowledge as something to capture inside an application.
I want Pompom to treat it as something the application serves.
The next twenty years
We are still early in the development of personal AI.
It is entirely possible that most of the models we use today will be forgotten within a few years. Many of the applications built around them may disappear too.
But the knowledge we accumulate through those systems could remain valuable for decades.
A research project you begin today may inform something you build ten years from now. A question you cannot answer now may become tractable with future tools. An old observation may acquire significance only after you learn something new.
That is what makes persistent personal memory interesting to me.
Not the ability to remember your favourite programming language or summarise last week’s conversations.
The possibility of building a body of knowledge that continues to develop, remains under your control and can be used by generations of increasingly capable AI.
I don’t want to build another place where your knowledge goes to live.
I want to build something that helps your knowledge stay alive.
Models come and go. Your memory stays yours.
If this vision resonates with you, follow the project at withpompom.com. I’d love to hear how you think personal AI memory should work.


I'm looking forward to the release of the Android for mobile version! :)