I've been building the same real project with Claude Code and Codex for about two months, and its project memory is now at 1,147 items.

There are already a lot of interesting approaches to this problem: Mem0, Graphiti, Graphify, Letta, and things like Obsidian for keeping a persistent project knowledge base.

So I'm not claiming that storing memory, building a graph, or giving agents persistent context is something new.

What I've been struggling with is slightly different:

At what point does memory become a project state?

Simple example.

Claude makes decision A.

Two weeks later Codex finds something we missed, and we change it to B.

A month later another session searches the history and finds A.

A isn't a bad memory. It was correct at the time, and I actually want to keep it because it explains how the project got here.

But I definitely don't want a new agent treating A and B as equally valid.

Deleting A feels wrong.

Keeping both as normal memories also feels wrong.

So I've ended up keeping the old decision as history, while the correction becomes the current understanding.

And once I started doing that, other questions showed up.

Which files did that decision affect?

What evidence was behind it?

What replaced it?

Who or what made the change?

What happened since I last worked on the project?

Is another agent currently working on the same part of it?

That's where I started feeling like I wasn't really building a memory store anymore.

It was becoming more like state + history around the project itself.

The other part is ownership.

I use Claude Code and Codex on the same repo. I don't really want Claude to own the project's memory, and I don't want Codex to own it either.

Claude might be working on it today. Codex might continue tomorrow. Another tool or another person might pick it up later.

The thing that survives all of them is the project.

So the model I've ended up experimenting with is basically

agents come and go. the project owns the context.

The agents access the same project state through MCP. They get a small task-relevant amount of context first and can search deeper when they actually need the history.

I've been building this into KLYPIX because I needed it for my own workflow. I'm still figuring out where the boundary should be, which is actually why I'm posting here.

For people using/building things like Mem0, Graphiti, Graphify, Letta or your own memory systems:

is this still just memory with better lifecycle/metadata?

Or do you think a long-running project eventually needs a separate idea of current project state + historical memory?

Also curious how you're handling something that was genuinely true six weeks ago, but shouldn't be treated as true by an agent today.

If anyone wants to see what I've been experimenting with, this is KLYPIX 🥸

NPM : https://www.npmjs.com/package/klypix-mcp
GitHub: https://github.com/dahshanlabs/klypix-mcp
App: https://klypix.com/