On this page
When AI Memory Doesn't Follow You Between Tools
Ammar Najjar
AI-generated imageI use several AI tools regularly, each for a different purpose. ChatGPT helps with developing ideas, writing articles, reviewing texts, and reflecting on experiences. Claude Code supports my technical work, from investigating problems to planning implementations and reviewing architectural decisions. Local AI models handle personal material I prefer to process on my own machine.
As these tools became embedded in my workflow, a limitation emerged. Each can become familiar with certain aspects of my work, preferences, and previous discussions, but that familiarity rarely extends beyond the tool where it developed. Exploring a topic with one assistant and later re-explaining the same background to another creates a gap that makes tools feel siloed rather than connected.
This problem was encountered before in a different form. My Obsidian vault grew past 1,000 notes, and in Keeping Knowledge Useful I wrote about how organizing and retrieving information affects its usefulness over time. That experience shaped how I began thinking about knowledge accumulating across AI tools.
What Is Expected from AI Memory
Expectations of AI memory developed through using these tools rather than through a particular technical definition. When I return to a topic, I expect the assistant to understand the relevant background, remember established preferences, and consider decisions or observations from earlier conversations.
Several mechanisms contribute to what feels like memory. Chat history preserves earlier conversations, although their contents are not necessarily available in a new session. Some tools add a persistent memory that carries selected information between conversations. The working context determines what the model can actually use during the current interaction, and I lean on project files, instructions, and documentation to preserve information between sessions.
Different kinds of information remain useful for different lengths of time. Writing preferences may remain useful for months, while implementation details change frequently. An architectural decision may remain relevant throughout a project, while a personal observation might become useful only when a similar situation arises later.
Different Tools, Different Knowledge
ChatGPT has accumulated considerable information about my professional background and interests through conversations. Claude Code develops a different kind of understanding while working with repositories, investigating technical problems, and following implementation decisions.
Local models depend on the context and files I make available to them. Personal tasks including reflecting on experiences, planning family and household matters, tracking health and habits, exploring personal interests, and processing sensitive documents I want to keep on my own machine. The local setup is described in more detail in My Local AI Setup, Six Months Later.
This division reflects how I work, and the specialization is useful. However, topics do not always remain within the boundaries of a single tool. An architectural discussion may influence implementation work, and a technical experience may later become material for an article or a leadership reflection.
When that happens, information available in one environment does not automatically carry over to another. Recognizing which parts are relevant and bringing them into the next conversation is necessary.
Where Memory Has Been Useful
Asking ChatGPT to bring together previous discussions about a particular topic. Exploring an idea over several conversations allows me to request a summary of observations, decisions, and conclusions that emerged, providing a useful starting point for continuing the work.
Another example involves asking for recommendations based on a personal profile. Because ChatGPT can take my professional background, responsibilities, and interests into account, the answers are more relevant to my situation. I can explore questions without repeatedly explaining the circumstances behind them.
These experiences showed how useful remembered information could be. The most dependable results came when I explicitly asked ChatGPT to use earlier information, particularly when knowing which background mattered. This approach is useful for deliberate reflection and research. Sometimes the assistant carries a relevant detail forward without being asked, but I cannot count on it.
Where Memory Failed
The unreliability became most apparent in two situations: when I did not ask for prior context, and when the relevant context lived inside a conversation rather than in a separate file.
Without explicit prompting, ChatGPT might understand a general professional situation while overlooking details from earlier discussions that would have changed how I framed a recommendation. The result could still be useful, but it requires additional clarification. Predicting which prior conversations might matter is impossible, and there is no way for me to check what the assistant has stored in its memory.
Claude Code presents a related difficulty in a different setting. During a substantial technical task, I rely on investigation and discussion to develop important context. Constraints are established, alternatives evaluated, decisions made, and an understanding of the problem gradually developed.
Some of that information becomes part of the code or documentation. Other details remain in the conversation, particularly the reasoning behind decisions and the alternatives considered. Starting a fresh session without restoring the relevant context means I must reconstruct parts of that reasoning. Claude Code provides ways to continue sessions and maintain project instructions, but the workflow does not always make the needed information available at the right moment.
The failure mode is not the tools’ fault. Recognizing which information is relevant, selecting it, and making it available is my responsibility. That works when a task is narrow and the relevant material is obvious. It breaks down when the conversation covers multiple topics, or when what I need was discussed weeks ago and never saved outside the chat.
Using Obsidian as a Shared Knowledge Source
A substantial collection of notes already maintained in my Obsidian vault, covering technical knowledge, decisions, meetings, books, and observations from professional experiences. Since much of this material is organized and connected, using it to provide context to AI tools is a natural extension of my system.
AI-generated imageWhen working with ChatGPT, I select relevant notes from Obsidian and copy their contents into the conversation. A single note can provide background for a decision, an idea from a book, or reflection on a past experience. I choose what to share and when, giving me control over what each assistant can access.
With Claude Code, I use an Obsidian MCP integration that allows the agent to read and update notes. Instead of copying content manually, I ask it to retrieve a particular note or record the outcome of a discussion. In practice, I direct Claude Code to specific notes rather than asking it to explore the entire vault.
Both approaches are useful. The same underlying knowledge can be used in different environments, retaining control over what information I share. This matters particularly when my personal background is relevant to the task, where I must decide what can be processed by a hosted model. Some notes can support work with hosted assistants, while others belong entirely in my local environment.
The manual approach works when I am deliberate about these steps. It becomes harder to maintain consistently as the number of conversations and topics increases. I must recognize which notes might be useful for the current task and make sure the assistant has access to them. When a conversation produces a useful observation or decision, I must remember to preserve it. Claude Code can interact with the vault directly, but that does not mean it will independently identify everything worth retrieving or recording.
Choosing the information manually gives control, which I value. But I want to spend less attention managing that exchange and more attention on the work itself.
What Needs to Be Improved
The problem is not the tools themselves, but the way information is scattered across them. Each tool develops its own memory, but there is no shared place to store the knowledge I can move between them. I must manually select, copy, and paste notes into conversations, or direct Claude Code to specific files already identified.
Two things need to change. First, a system that can retrieve relevant information more consistently without requiring me to know which notes are relevant before starting a conversation. Second, reducing the manual effort of moving context between tools while keeping clear control over what each assistant can access.
Where does continuity break most often when you move between AI tools, and how much of that context management would you want to delegate?
I’d be interested to hear how each of you balances comfort and control.