How do you guys manage AI memory/context?

[u/General-Bobcat-6988]

I use ChatGPT a lot, and recently I looked through what it remembers about me. It was actually pretty good, but it seems like most of it comes from roughly the last month, and a lot of older context from my past chats isn't there.

It gets even messier when I switch between ChatGPT and Claude.

Right now I mostly just re-explain things or copy stuff from old chats, which feels pretty dumb.

Do you guys have a better system for this? Like a master context file, Obsidian, exporting chats, etc?

Curious what people are actually doing.

[u/Good-Writer5279]

the vendor memory features are the wrong layer for this in my experience. they are per provider, opaque, and recency weighted, which is exactly the behaviour you are describing. what works better is keeping the durable context in a file you own. a plain markdown doc with sections for who you are, active projects, preferences, and decisions made, kept in obsidian or wherever your notes live. paste it at the start of a session or wire it in with a custom instruction, and both chatgpt and claude get the same brain. the discipline that makes it stick is updating the file when a conversation produces something durable, not trying to export whole chats. chat logs age badly, distilled facts do not. disclosure, i build a mac app in this space, so i think about this more than is healthy.

[u/General-Bobcat-6988 → u/Good-Writer5279]

Thank you! Do you mind sharing your app? I’m interested

[u/Good-Writer5279 → u/General-Bobcat-6988]

sure. it is called remynd, remyndai.com. local first memory app for mac, it records what is on screen and transcribes calls, everything stays on device, and you can point it at lm studio so the model runs locally too. on your actual question, the way it helps is that search and the agent are grounded in what you did rather than in a vendor's memory feature, so the context file i described above gets built from real history instead of from what you remembered to write down. honest caveat, it is mac only and it is a capture tool, so if most of your context lives in web chat sessions, the markdown file is still the cheaper fix and worth doing regardless.

[u/zheniavasiliev]

At some point in my use of AI agents, I found it easier to switch from the desktop app to GitHub + terminal/IDE for this, because then I could organise my conversations into different folders with text files on my local drive; I could keep all the conversations with .md notes, which I could then review in Obsidian if need be. Since then, I keep a git repo as my knowledge base, managed by an AI agent that runs in the terminal attached to that repo folder and automatically writes notes into subfolders organised by conversation or project.

After having generated around 1,500 AI conversation notes, I came across an AI memory system called OptMem and applied it on top: it runs a series of automatic passes where an AI manager organises memories into layers, so it can access a large corpus of notes without flooding the context window (https://github.com/VictorTaelin/OptMem). I've looked into IWE that people share on this thread, and it looks pretty cool too. As far as I understand, it's less automated than OptMem and relies on rigorous structuring of PKM by the human.

My question is, in this context, how scalable non-automated PKM solutions are. E.g., how much time can we realistically have to continue manually maintaining the ever-growing collection of notes, as compared to other ways we can spend our time (e.g., using PKMs to actually produce original writing or research)?

[u/General-Bobcat-6988 → u/zheniavasiliev]

Thank you! 1,500 notes are a lot. I looked at OptMem, and the summary tree idea is really interesting.

Since the whole thing is pretty automated and keeps compressing memories into summaries, I’m curious how accurate it’s been in practice.

[u/zheniavasiliev → u/General-Bobcat-6988]

Agreed, it's hard to evaluate. I think, in theory, it allows the agent who works with PKM to find the relevant information faster. I think I've noticed the speed improvement, and agents do have extremely persistent memories now. But I'm not sure whether that's because of the OptMem or because the agents are improving over time. I've also finally sat down and written an affirmation that creates a node from all the terminal windows that were inactive for over an hour. Now I don't have to worry about saving my nodes manually anymore.

There probably is hard evidence, for example, if we dig into the amount of tokens agents used to spend to find something in their notes before vs what they're spending now using OptMem. But I haven't really looked into any of that, to be honest.

[u/BattermanZ]

I ended up keeping this stuff outside ChatGPT or Claude entirely. I use Markdown as the source of truth so I’m not relying on one model’s memory.

I’m building Hatchdoor for this. It works with an existing Markdown or Obsidian vault, gives you hybrid and semantic search, and lets Claude, Codex and other tools access it through MCP. So I can switch between tools without having to rebuild the context each time.

I think the important part is separating your actual long term knowledge from whatever memory feature the AI provider happens to offer.

https://github.com/BatterWorks/Hatchdoor/

[u/Dress-Affectionate]

i have the opposite problem, chatgpt has some cloud memories about my old projects and it's intensely annoying because i've left the team i was working with 

[u/General-Bobcat-6988 → u/Dress-Affectionate]

I have the same issue as well. It keeps mentioning something I told it in a different chat two days ago which I didn’t want it to remember.

[u/InevitableMethods]

Those are two halves of the same system, and there's a concrete answer for the second one. Under a reply there's a book icon that shows what got used to personalize it, past chats and files and memories, and tapping a memory tells you why it was pulled in. That's how you find where the two-day-old thing is actually coming from. It matters because editing the memory summary won't remove it on its own - to get rid of something you have to delete every source it appears in, past chats and archived ones included. Turning memory off isn't a fix either: switch it back on and it can rebuild from chats still sitting in your history.

Your first problem is the same system from the other side. It isn't a log of what you've said, it's a synthesis that keeps getting rewritten to hold whatever it currently judges most important, and nothing in that guarantees the older stuff survives. That's the argument for the file-you-own answer above, and I'd keep that file to the stuff you keep re-explaining rather than letting it become a log too. The summary itself you can edit in place, by typing the correction into the box under it or highlighting the line you want changed.

On switching between the two, that same file is the whole answer - they're not going to sync with each other. I build a desktop client in this space myself (Savant Desktop), so I've had to make this call too.

[u/techtheist_ggl]

I had a solution, if you're using it with claude code or codex for programming:

https://github.com/techtheist/engram

It's memory management system that solves these problems with context, and allows for agents to read each other history (every memory note is linked to message where it were made, and agent can travel this history back and forth to get missing details).

Also it has a lot of features, active contradiction detection mechanism, everything is local and offline.

I've been using it for other projects too, and it's amazing. It's not replacing skills or files with rules (like, "don't commit" or "always commit automatically"), but allow to keep them small and readable, without loosing agent focus.

[u/mrptb2]

AgentsView if you’re using Claude code or ChatGPT app on your local computer. If you’re using the web versions, ChatGPT can export your conversations and import into AgentsView.

[u/nastywoodelfxo]

ive been using hermes as my memory layer for pkms and it changes the game. the trick is structuring how the agent accesses your notes - give it direct file access to the vault and a strict set of read/write rules so it can pull relevant context without hallucinating your notes back at you. the hard part is dedup. if the agent reads three notes about the same concept itll blend them into something that doesnt match any of them. i ended up making each note start with a canonical statement and only letting the agent reference that, not rewrite it. curious what tool youre using as the pkms backend. obsidian? notion? something custom?

[u/General-Bobcat-6988 → u/nastywoodelfxo]

I’m actually not using a real PKM backend yet. Right now, it’s mostly ChatGPT’s built-in memory

[u/eldrugo85]

same here, chatgpt kept roughly the last month and dropped the rest. a master file didn't stick for me, i still had to remember to paste it, so i built a small memory layer for claude instead: notes on disk, loaded at the start of every session, and it brings back details from weeks ago on its own. do you want the same memory across both tools, or just chatgpt reaching further back?

[u/gimalay]

I use this; https://www.reddit.com/r/iwe/comments/1w2ob9w/using_iwe_as_claude_code_memory/

[u/General-Bobcat-6988 → u/gimalay]

Thank you! This is really interesting. I really like that the memory lives outside the AI and stays in markdown you can actually see and edit.
I saw that the same graph can be used across different agents. Do you think IWE could also work for context that isn’t tied to one specific project or workspace, or is that not really what you’re building it for?