Title: Project-specific memory shared between ChatGPT and Codex
I’ve been thinking about how memory works when you’re working on bigger projects, especially projects where you use both ChatGPT and Codex.
The current memory approach becomes less useful as a project gets bigger. You might have a lot of conversations, architecture decisions, debugging sessions and hundreds of files, but not all of that context should be mixed together or treated equally.
What I think would help is having memory separated by project.
Something roughly like:
Global Memory
│
├── Project A
│ ├── Project Memory
│ └── Current Task / Session
│
├── Project B
│ ├── Project Memory
│ └── Current Task / Session
│
└── Project C
Global memory would still contain things that generally apply to the user, but when a Project is created in ChatGPT or Codex, it could get its own memory branch.
The important part is that I don’t think the code files themselves should be stored as memory.
The repository should always be the source of truth for the code because it changes constantly. Project memory should instead remember things like why an architecture was chosen, important constraints, conventions, previous decisions and other context that isn’t obvious just from reading the files.
For example, say I originally chose architecture A, then after testing it I switched the project to architecture B.
The project memory could remember:
Architecture A
→ superseded
Architecture B
→ current
Reason for changing:
…
Then months later Codex doesn’t just see two conflicting decisions from old conversations and have to guess which one is still correct.
I think this becomes even more useful if ChatGPT and Codex can use the same project memory.
A lot of the time the workflow is something like:
ChatGPT
discuss / research / plan architecture
↓
shared project memory
↓
Codex
actually work on the repository
Right now, moving between those two can mean explaining important project context again.
If I spend time in ChatGPT deciding why the project should use a certain architecture, Codex should be able to know that decision when it works on the same project. But it should still inspect the actual repository before changing anything.
I also wouldn’t want every debugging conversation permanently saved into the project memory. That would eventually create another huge pile of context.
Maybe there could be a temporary task/session memory for things like current debugging attempts, temporary TODOs and hypotheses. Important information could later become part of the actual project memory, while temporary stuff could disappear after the task is finished.
Another important part would be retrieval.
Imagine a project has been running for two years and has a huge amount of context. Loading or considering all project memory for every request wouldn’t really solve the problem.
If I’m asking Codex to fix something related to TLS on Windows, it should retrieve the project decisions relevant to TLS and Windows, then check the current files. It shouldn’t need unrelated UI decisions or debugging history from another part of the project.
I’d also like to see this reflected in Manage Memory.
For example:
Global Memory
Project Memories
├── Project A
├── Project B
└── Project C
From there you could see what a project remembers, delete something that’s wrong, mark an old decision as outdated, move something to global memory, or control whether a project can use global memory.
So basically I’m not asking for ChatGPT or Codex to just remember more stuff.
I’m thinking more along the lines of:
Global Memory
↓
Project Memory
↓
Current Task
+
Live Repository
The repository stays the source of truth, while memory keeps the reasoning and context around it.
I know parts of this have been suggested before, especially project-specific memory and sharing context between ChatGPT and Codex. What I’m mainly suggesting is combining those ideas with task-level memory, selective retrieval and a way to handle old or superseded project decisions.
I think this would be especially useful for long-running projects where you switch between ChatGPT and Codex regularly.
Curious if something like this is already planned or being explored.