Your next session should know what happened.
An AI coding agent can finish a difficult investigation and forget it at the next reset. I built MemIndex to carry useful context between sessions, across projects and into the tools where the work happens.
- Free trial before choosing a plan
- 30 days
- Managed hosting, or your own server
- Hosted or self-run
- Search, then timeline, then the full note
- 3 steps
The problem
Conversation history is a poor handover. A context window fills, a session ends or another agent takes over, and the useful decisions disappear into transcripts. Loading everything again costs attention and context, and plain search leaves a gap: a passage that looks similar is not the same as the reason a change was made.
My earlier operator work separated daily observations from lasting references and learned rules. MemIndex turns that continuity problem into a product for coding work. Capture, retrieval, inspection and recovery had to work together, without asking anyone to become a full-time archivist for their assistant.
Who it's for
Developers who work with coding agents over days rather than one conversation, and teams that need shared project memory across machines. Their question is a familiar one: why are we explaining the same architecture, rejected approach or deployment decision again? MemIndex gives the next session somewhere to start, and a way to dig into the history when the short summary is not enough.
What I built
Integrations that capture supported agent activity, a service that turns it into short notes and session summaries with project context, and a viewer for browsing what was kept. Supported integrations bring relevant context into later sessions, and search tools let an agent go back for older work on purpose.
Around that I built the controls a paying customer expects: export and import, project exclusions, optional secret filtering, work-state tracking, and local snapshots with a restore command. Managed hosting runs central memory as a service. A self-run server, still in beta, puts storage, the model service, access keys and backups in the operator's hands.
How it works
Activity arrives through an agent's session events or saved conversation files, depending on the integration. A chosen model writes the notes. Retrieval starts with a short list of matches, widens into the surrounding timeline and fetches full notes only when needed, so a question does not load a whole project's history.
I keep the differences between integrations explicit rather than promising one experience everywhere. A client that can search memory does not automatically capture new work, and local storage does not mean all processing is offline, because the note-writing model sees the captured activity.
What was hard
Persistence raises the bar for recovery. After a real loss showed there was no backup engine, I built consistent snapshots that run while the database is being written. A restore has to handle the database's side files and search index, survive an interrupted restore, and refuse a newer schema before touching an older installation.
Trust also means being able to inspect and remove memory. Private tags filter saved notes rather than every possible copy of a conversation, and deletion has to account for exports, pending files and backups. I make those limits visible: a useful working record with stated boundaries, not a promise that an agent remembers everything.
Get in touch
I am open to Senior Technical Product Manager roles. If you want to talk about how I took this product from problem to launch, write to me.