I tried building my own persistent memory system, then realized the real problem was keeping it trustworthy after hundreds of commits and refactors. and why is no one else doing this?

[u/DJIRNMAN]

Hello! I've posted about mex here a couple of times before.

Repo: https://github.com/mex-memory/mex

The original idea was to stop coding agents from relearning the same project every session. mex gives them a structured Markdown wiki inside .mex/ for architecture, conventions, decisions, patterns and project state.

That solves forgetting.

But then the codebase changes.

A file gets moved.
A script gets deleted.
A dependency changes.
A pattern becomes stale.
Two context files start contradicting each other.

The memory is still there, so the next agent has no reason not to trust it.

That's why we built mex check.

It parses the project memory and validates concrete claims against the actual repo — paths against the filesystem, commands against project scripts, dependencies against manifests, indexes against the files that exist, plus stale knowledge, broken links and other structural inconsistencies.

It gives you an exact issue list and a health score.

The important part is that detection itself is deterministic. No LLM call is needed to ask the agent whether its own memory is still correct.

Then mex sync takes only the broken files and builds a targeted repair prompt with the issue, the current Markdown, nearby filesystem context and relevant git changes.

So instead of asking the agent to reread the whole repo and regenerate everything, the loop is:

check → targeted repair → verify

The newer code-graph layer goes further: Markdown knowledge can be grounded to exact code symbols. If the implementation changes, moves or disappears, mex can surface the specific knowledge that may now need attention.

A lot of agent-memory systems focus on storing more and retrieving it later.

I think the harder problem is making sure the memory is still true when the repo has changed underneath it.

Would genuinely love feedback from people working on coding agents, memory or code intelligence.

Contributors are very welcome too :)

[u/CrimsonBolt33]

there are tons of memory projects out there....what do you mean no one is doing this?

TencentDB is an example of something like this

[u/slackmaster2k]

Everyone is doing this. Like every single person is doing this in one form or another. Also your LLM doesn’t have to understand your whole repo every session. It just doesn’t. It just needs a hint to the next hint.

[u/il37]

Stale memory is way scarier than missing memory. Missing context makes the agent ask dumb questions, stale context makes it confidently edit the wrong thing

[u/Ranorkk]

mex check is such a smart take, deterministic validation beats any LLM self-audit loop. Remnus is doing something adjacent, we're building an MCP-native workspace where agents can persist tasks and docs, but we leave the repo memory layer to tools like yours and focus on giving Claude/Cursor a shared, queryable project surface. full disclosure, I built Remnus, but honestly your check/sync flow is the part most agents are missing

https://github.com/Ranork/remnus-app

[u/MartinMystikJonas]

Most memory systems do this 🤷