“As we discussed last week…” — except ChatGPT has no idea what you discussed last week, because that was a different chat. How to make ChatGPT remember context across chats? Between the memory system, projects, and a few manual techniques, you can build genuine continuity. Here’s every method, ranked by reliability.
How to make ChatGPT remember context across chats
Method 1: Projects (most reliable)
For ongoing work, Projects are the answer — not memory. Create a project per OpenAI’s projects guide, add its files and custom instructions, and keep all related chats inside it. Every chat in the project shares the project’s context automatically. This is deliberate, complete context — not the lossy summaries of memory extraction. Organize with projects has the full setup. Rule: anything spanning more than 3 chats deserves a project. This single habit solves 80% of cross-chat context problems.
Method 2: Memory (automatic but lossy)
The built-in ChatGPT memory system saves facts across chats — preferences, project details, things you asked it to remember. Per the OpenAI memory FAQ, it works, with caveats: it extracts summaries, not full context — nuance is lost. It’s selective — it saves what it thinks matters. And it can misremember. Make it work better: be explicit (“remember this for our project: …”), correct errors when you spot them, and review stored memories periodically. Memory is great for facts and preferences; terrible for complex project state. Use accordingly.
Method 3: The summary carryover (manual but powerful)
The oldest trick and still one of the best: at the end of a long chat, ask “Summarize this conversation’s key context — decisions, facts, open items — as a briefing I can paste into a new chat.” Save that summary. Start the next chat by pasting it. You get exactly the context you choose, in your words, with nothing lost to extraction algorithms. For critical ongoing work, this beats memory’s automation — deliberate beats automatic when precision matters.
Method 4: Custom instructions (permanent background)
For context that never changes — who you are, your role, your standing preferences — custom instructions carry it into every chat automatically. This isn’t “remembering” so much as “always knowing” — and for stable background, it’s the right tool. Don’t stuff changing project details here; that’s what projects are for.
Method 5: The reference document
Maintain a living “project brief” document (in your notes, or as a project file): current status, key decisions, important facts, open questions. Update it after significant chats. New chat? The brief (or the project containing it) provides instant, complete, accurate context — because you wrote it. This is the professional-grade solution: human-curated context beats AI-extracted context every time for important work.
Putting it together: the continuity stack
- Permanent background → custom instructions (who you are, how to respond)
- Accumulating facts → memory (preferences, things learned — reviewed periodically)
- Active projects → projects with files + instructions (complete deliberate context)
- Critical handoffs → summary carryover or reference document (precision when it matters)
What not to expect
Context window management (the technical reality)
Here’s what’s actually happening under the hood, simplified: every chat has a context window — a maximum amount of text (your messages + AI responses + project files + instructions) the model can consider at once. Long conversations eventually exceed it, and the oldest content gets silently dropped — which is why the AI “forgets” things from 50 messages ago. Practical implications: long chats degrade — start fresh for new topics rather than running 200-message marathons. Project files consume budget — huge reference files leave less room for conversation; keep them focused. Summaries are compression — the summary-carryover technique works because a good summary preserves meaning in fewer tokens. Models differ — longer-context models handle bigger projects, but “can fit it” isn’t “uses it well” (attention dilutes). You don’t need the math — just the intuition: context is a budget, spend it on what matters, and refresh when the conversation gets unwieldy.
The future of AI memory (where this is heading)
Current memory is crude — extracted factoids, manual projects, user-managed context. The trajectory: richer automatic memory (understanding what’s important, not just what’s mentioned), cross-session reasoning (connecting insights across conversations over time), graceful forgetting (dropping the irrelevant, keeping the essential — like human memory), and user-controlled granularity (precise control over what’s remembered, for how long, visible to whom). The destination is an assistant with genuine continuity — less “clever chatbot,” more “colleague who knows you.” We’re partway there. Until the technology matures, the manual stack (projects, briefs, curated memory) is how you get continuity today. Build it now; the automation will catch up to your system, not replace it.
ChatGPT won’t spontaneously recall last month’s chat the way a colleague would — there’s no ambient awareness of your history, only these explicit mechanisms. And cross-service memory doesn’t exist (your ChatGPT context doesn’t follow you to other AIs). Design your workflow around explicit context management rather than hoping for magic recall. The users with the best “memory” experience aren’t lucky — they’re systematic: projects for work areas, curated briefs for important threads, memory for facts, instructions for background. Build the stack once; continuity follows.
