Context vs Memory vs Custom Instructions (What Goes Where)

TL;DR: Custom instructions are preferences you write once that apply to every new chat. Context is information scoped to one place, usually a project, that only chats inside it can see. Memory is different from both: the model writes it itself, from what you've discussed, without you typing anything. All three get called "context" in casual conversation, and mixing them up is why the same setup works in one chat and vanishes in the next.

If you've ever set up a ChatGPT project, turned on Claude's memory, and still found yourself re-explaining who you are in a third chat, you've already run into the problem this post is about. These are three different mechanisms, not three names for one feature, and each has its own scope, its own persistence, and its own rules about what it's actually allowed to hold. Anthropic's own support documentation contradicts itself on some of this, twice, which tells you something about how new and unsettled the terminology still is.

This post is the taxonomy: what each mechanism is, how long it lives, who can see it, and where the boundaries actually fall on ChatGPT and Claude. For the practical side, actually setting up a project context once so you stop re-explaining your work, see Project Contexts: Stop Re-Explaining Your Project. If what you actually want is a single-chat trick rather than a whole system, How to Give ChatGPT Context Without Repeating Yourself covers that lighter case.

What actually separates context, memory, and custom instructions?

Three axes matter, and every mechanism below sits at a different point on all three.

Who writes it. Custom instructions and context are things you write, upload, or paste. Memory is something the model writes about you, based on what happened in your conversations, and you did not compose it.

How far it reaches. Custom instructions are account-wide, applied to every new chat regardless of topic. Context is scoped, usually to a single project, so a chat outside that project never sees it. Memory's reach depends on the vendor and the setting: it can span every chat you have, or it can be walled off to one project, or it can be switched off for a single conversation.

Whether it degrades. Custom instructions and uploaded context stay exactly as you wrote them until you edit them. Memory does not work that way. It gets summarized, it can be superseded by a later correction, and vendors describe it explicitly as something the model curates rather than a verbatim log.

How does this work on ChatGPT specifically?

ChatGPT actually runs three separate systems, and they stack rather than replace each other.

Custom instructions are the oldest of the three: a fixed field you fill in once, applied to every new conversation. OpenAI's help center is specific about the size: "Free and Go users can save up to 1,500 characters in custom instructions." Paid tiers get more than three times that: "Plus, Pro, Enterprise, Business, and Education users can save up to 5,000 characters." It is a flat cap by plan, not a rolling budget, and it updates going forward rather than rewriting chats already in progress.

Projects are the scoped container. A ChatGPT project keeps files, instructions, and chats together, and OpenAI's own documentation is direct about the boundary: "Project instructions apply across its chats." Nothing in that documentation claims a project's instructions override or beat your account-wide custom instructions when both are present; there simply isn't a stated precedence rule between the two, so don't assume one wins.

Memory is the auto-generated layer, and it is deliberately not something you author. OpenAI describes the mechanism plainly: "When enabled, memory helps ChatGPT automatically remember useful context from your chats, files, and connected apps to personalize your experience, so you don’t have to repeat yourself as often." You can see what it kept in a memory summary, edit it in place, or delete specific items, but you did not write the entries yourself, and the system keeps updating them as you chat. On the web, a book icon under a response shows which sources, custom instructions, past chats, files, or memories, actually shaped that particular answer, which is the closest thing to an audit trail any of these mechanisms offer.

There's one more wrinkle worth knowing if you're on a regulated workspace: OpenAI documents a "Project-only memory" mode for ChatGPT Enterprise with Regulated Workspace and ChatGPT for Healthcare, which keeps memory context walled off to a single project so chats outside it can't reference what happened inside. That's a narrow, admin-controlled setting for compliance-sensitive accounts, not a general consumer feature, so don't expect it on a personal plan.

How does this work on Claude specifically?

Claude's version of the same three-way split uses different names, and Anthropic's own support pages disagree with themselves on two separate points, which is worth knowing before you trust either one blindly.

Profile instructions are Claude's answer to custom instructions: account-wide settings, and Anthropic's help center frames the choice directly: "Use profile instructions for account-wide settings that affect all your interactions with Claude." This is the one that applies everywhere, all the time.

Project instructions and project knowledge are Claude's scoped container, and this is where Anthropic contradicts itself. One article states plainly that "Projects are available to all users, including those with free Claude accounts. Free users can create a maximum of five projects." A few paragraphs later, the same article's own choosing-a-feature summary says: "Use project instructions when you need specific guidance or context for a particular project (paid plans only)." Both sentences are on the same page. Free accounts clearly get projects; whether they get project instructions specifically is stated two different ways in one document. For ready-to-adapt starting points once you know which side of that you're on, see Claude Project Instructions.

Project knowledge, the files and pasted material you attach to a project, has its own contradiction. One help article says: "Enhanced project knowledge with RAG is only available to users with paid Claude plans (Pro, Max, Team, or Enterprise)." A separate, dedicated article on the same topic says: "RAG for projects is available for all Claude plans (free, Pro, Max, Team, and Enterprise)." Both were live when checked. Neither has been corrected to match the other. The honest position is to quote both and resolve neither, because that's genuinely where Anthropic's own documentation stands right now.

Memory is where Claude gets a feature ChatGPT's consumer plans don't have in quite the same shape: memory scoped to a specific project by default. Anthropic's documentation is explicit: "Each project has its own separate memory space and dedicated project summary, so the context within each of your projects is focused, relevant, and separate from other projects or non-project chats." Plan availability differs from ChatGPT's, too. Anthropic states "Memory is on by default for Free, Pro, and Max plans" — notably including the free tier. The reverse is true higher up: "On Team and Enterprise plans, memory is off by default and can be turned on by an owner."

Claude also documents real limits on what memory will touch. By default, "Claude does not store topics related to personal or sensitive subject matter, like your health, race, ethnicity, religious beliefs, politics, gender identity, and other similar areas" unless you opt in. Some categories are refused outright, opt-in or not: "Some information is never saved to memory, even if you ask. This includes government ID numbers, criminal history, financial account numbers, and immigration status."

One more timing detail if Claude's memory feels different than it used to: Anthropic migrated accounts from an older, legacy memory system to the current one, and its own settings page offers a limited-time export of whatever the legacy version had saved, through September 9, 2026, in case something looks like it went missing in that switch. After that date, the export option itself goes away, not necessarily the memories, so check sooner rather than later if you suspect something didn't carry over.

What actually goes where, mechanism by mechanism

Where does our own product fit into this?

Prompt Architects runs an extension sidebar inside ChatGPT, Claude, and Gemini, and it needed an answer to the same problem every vendor above is solving separately: somewhere to put the standing facts about you or your work so you stop retyping them. The feature is Personal Context, and it's gated like this: not available on the free tier, then a published 8,000-character library on Pro, and 15,000 on Advanced and Team.

The mechanical difference from a ChatGPT project or a Claude project is that it isn't tied to one vendor's app. You write a context entry once, in the sidebar, and it's available whichever of the three platforms you happen to be prompting in that day. That matters more than it sounds, because none of the mechanisms above cross vendor lines: a ChatGPT project's instructions do not follow you into Claude, and Claude's project memory does not follow you into Gemini. If your actual workflow spans tools, which is common once you're using more than one seriously, a platform-native context system means rebuilding the same background information twice.

It also behaves closer to custom instructions or context than to memory: you write the entries, you decide what's in them, and nothing gets auto-summarized or silently rewritten while you aren't looking. That is a deliberate trade-off. Memory is convenient because you do not have to maintain it, but that same property means you cannot fully predict what it kept or dropped. A context entry you wrote yourself does exactly what you wrote, every time, until you change it.

So what actually goes where?

A short decision rule, in order:

1. Is it true about you or your work, every time, regardless of topic? Your role, your tone preferences, your industry. That's custom instructions or profile instructions: account-wide, low-maintenance, and the thing every vendor's version of "personalization" was originally built for.
2. Is it specific to one ongoing project, repo, or client, and not true elsewhere? That's project context: Claude's project instructions and knowledge, a ChatGPT project, or a dedicated entry in a portable context library if the project spans platforms. Scoped on purpose, so it doesn't bleed into unrelated work.
3. Would you rather not manage it at all, and are fine with the model deciding what's worth keeping? That's memory's actual use case. Check the summary occasionally; it's editable, not a black box, but it is the model's judgment, not yours.
4. Would you hesitate to paste it into a shared document? Then it doesn't go in any of the above. Not custom instructions, not project knowledge, not memory, on any vendor, regardless of what that vendor is technically willing to store.

None of these four questions require guessing at internals. They map directly onto the axes from the start of this post: who writes it, how far it reaches, and whether it's allowed to change on its own. Once you know which bucket a piece of information belongs in, picking the right mechanism, on whichever platform you're using, stops being a judgment call.

The same split shows up outside ChatGPT and Claude, too. If you write code with GitHub Copilot, its repository-wide instructions file is the coding-assistant version of custom instructions, covered in GitHub Copilot Custom Instructions; it's account-wide-for-a-repo the same way profile instructions are account-wide-for-you.

Copy this and run it against your own setup once, per platform you actually use:

CONTEXT AUDIT — run per AI platform

1. What's in your custom instructions / profile instructions right now?
   - Is every line still true, regardless of what you're working on today?
   - Delete anything that was only true for one past project.

2. What projects do you have open, and what's in each one's instructions/knowledge?
   - Does anything in there actually belong in custom instructions instead,
     because it's true everywhere, not just this project?

3. Open the memory summary (ChatGPT: Settings > Personalization > Memory.
   Claude: Settings > Memory). Read every line.
   - Anything wrong? Correct it in place.
   - Anything sensitive you didn't mean to share? Delete that entry.

4. Anything above that's a password, API key, client secret, or another
   person's personal data? Remove it now, from all three.