How to Make ChatGPT Remember Your Project

If you want to make ChatGPT remember your project, there is no single setting for it. There are five, they work differently, and the one almost everyone reaches for first — the global custom instructions box in settings — is the worst place to put anything project-specific.

I should say where I'm standing. I build a memory layer for coding agents, and I still open ChatGPT most weeks for the work that isn't code. Every article on this blog gets cross-posted by hand to dev.to, Medium and LinkedIn, and each of those needs its own blurb. So three times a post, I sit down to write "here's what ContextForge is" to a model that has no idea, because last week's conversation is gone. A person who sells continuity, re-explaining himself to a chat window.

I spent a while blaming the model. It was my setup.

The five places your project can live

Custom instructions. The personalization block in settings. Short, always on, and global — the same text follows you into every conversation you have.

Project instructions. The same idea, scoped to one project. Open the project, hit the ••• menu, choose Project settings. These apply only inside that project, and they override your global custom instructions. This is the one most people don't know exists, and it's the one that matters most here.

Saved memories. Details ChatGPT keeps about you, either because you asked it to or because it decided they were useful. Settings → Personalization → Memory.

Reference chat history. A control that lets ChatGPT draw on your past conversations instead of only on saved memories. The broadest of the five and the hardest to inspect.

Projects. A container with its own chats, its own files, its own instructions and its own memory setting. This is the closest thing ChatGPT has to "a place where my project lives."

One caveat before you go changing things, and it's a real one: OpenAI says memory features and controls vary by plan, region, platform and workspace. Accounts on the newer improved memory see a memory summary that ChatGPT keeps updating, rather than an editable list of individual items, and may not show the separate toggles I'm about to describe. Check what your own settings actually offer before trusting any guide, including this one.

Two wiring details worth knowing. Turning off Reference saved memories also turns off Reference chat history; the reverse isn't true, so you can keep saved memories while cutting history recall but not the other way round. And when ChatGPT uses personal context, Sources can appear under the response, showing you which past chat, saved memory, custom instruction or file contributed. OpenAI is explicit that Sources may not show every factor — but it's the closest thing to a debugger you get, and hardly anyone looks at it.

Where each one breaks

Custom instructions are global, and your project isn't. Anything you put there to help with one project is dead weight in every other conversation. This is the mistake worth undoing today: move it into project instructions, which override the global block anyway, and your schema stops showing up while you're asking for a dinner recipe.

Saved memories don't do what you think they do. You don't control what goes in — the model decides what's worth keeping. It will faithfully remember that you prefer TypeScript and miss the architectural decision you spent an afternoon reaching. And deleting a chat doesn't remove a memory that came from it; people clear their history, assume they've reset, and wonder why ChatGPT still believes something about them.

Chat history recall is best-effort, not retrieval. The model decides what's relevant to your question. You have no way to say "the thing we settled three weeks ago, in the long conversation, about the webhook." When it works it feels like magic. When it doesn't, you can't tell whether the information is missing or simply wasn't retrieved, and those two problems have different fixes.

Projects isolate, which cuts both ways. With project-only memory on, your saved memories are not referenced inside that project, and its chats can't see conversations outside it — in either direction. Great for a clean workspace, startling the first time ChatGPT seems to have forgotten who you are. Sharing a project switches it to project-only permanently, and that sticks even after everyone else leaves.

Files are read, not remembered. Project files get pulled in when relevant. They don't become decisions ChatGPT holds onto.

A setup that actually holds

Here's what I use.

One Project per real project. Not per topic, not per week. The container should match the thing in your head.

Put the project's rules in project instructions, not the global box. How you want it to write, what it should never assume, which tone. Scoped, overriding, and invisible everywhere else.

Decide the memory mode on purpose. Project-only memory keeps your general account memory out — useful for client work or a codebase with its own conventions. Two things the docs will tell you only after you've gone looking: it requires Reference saved memories and Reference chat history turned on in your personal settings (on Business and Enterprise, memory also has to be enabled for the workspace), and changes can take a few hours to take effect. Switching a project to project-only also pulls that project's information out of the memory used elsewhere.

Write one brief, as a file, and upload it. This does the heavy lifting. Not a transcript — a reference, a page or two:

# <project> — brief
What it is: one paragraph, as if to a new contractor.
Stack: languages, frameworks, services, versions that matter.
Decisions made: the choice, and the reason. "Postgres over Mongo — relational reporting."
Out of scope: what we decided NOT to do, so it stops getting suggested.
Vocabulary: our names for things, and what they map to.
Open questions: what's genuinely undecided.

When an answer comes back wrong-headed, don't re-explain in chat. Fix the brief, re-upload.

Audit instead of arguing. When a response is off, check Sources. If a stale saved memory is steering things, delete the memory rather than correcting it in conversation for the rest of the week.

The brief file carries the weight rather than memory because you own it. You can read it, diff it, and see when it has gone stale — which it will, the same way a CLAUDE.md drifts out of sync with the code it describes.

Where this still fails: the second tool

Everything above lives inside ChatGPT. That's fine until you open a second tool.

The decision you explained so carefully in a ChatGPT Project isn't available to Claude Code when it's editing the very file that decision was about. It isn't available to Cursor either. Each tool keeps its own idea of what it knows about you, and none of them compare notes. If one assistant does all your work, stop reading — the setup above is genuinely enough. If you use two or three, you haven't solved the re-explaining, you've just moved it from every session to every tool. I wrote about what it takes to give several coding agents one shared memory if that's where you are.

The brief file is the only piece of the setup that makes the jump, and only because it's a file you control.

What ContextForge can and can't do here

Straight answer, since this is my product: you cannot connect ContextForge to ChatGPT today.

ChatGPT talks to custom MCP servers over a remote endpoint only — SSE or streaming HTTP — and full MCP support is currently limited to Business and Enterprise/Edu accounts on ChatGPT web. Our MCP server is a local stdio process. There's no remote endpoint to point ChatGPT at, so there's no connector to install, and a tunnel doesn't help because there's no HTTP server at the other end of it.

What does exist: you can import your existing ChatGPT memory into ContextForge, which is one-way and mostly useful as a migration. And if the code half of your work happens in Claude Code, Cursor, Copilot or Claude Desktop, that's the half I built for: one memory those four share, tied to files and commits, so it can tell you when a note has gone stale.

If ChatGPT is the only assistant you use, the Projects setup above is the whole answer and you can skip my product entirely.

FAQ

If I delete a chat, does ChatGPT forget what it learned there?
No. Saved memories are stored separately from chat history, so deleting the original chat doesn't automatically delete a memory created from it. Delete the memory itself under Settings → Personalization → Memory.

Do Projects have their own memory?
Effectively, yes. A project can run on project-only memory, which keeps your saved memories out of it and stops its chats from referencing conversations outside the project, or being referenced by them. Shared projects always work this way, and the switch can't be undone.

Do project instructions replace my custom instructions?
Inside that project, yes — project instructions override your global custom instructions. Outside it, the global block still applies.

Can I connect ChatGPT to an MCP memory server?
Only a remote one, over SSE or streaming HTTP, and full MCP support is currently a Business/Enterprise-tier feature on ChatGPT web. A memory server running on your laptop isn't reachable unless you expose it over HTTPS.

Won't a bigger context window solve this?
No. A longer window holds more of this conversation, not more of your project's history, and answer quality degrades well before you hit the limit. More on why bigger context windows don't fix forgetting.

If you also code with an agent

The Projects setup costs nothing to try this afternoon, and project instructions alone will fix more than you'd expect. If your problem is bigger than one window — several tools, each re-learning the same project — that's what I build, and there's a free tier to find out whether it changes how you work.