How to Give an AI a Memory: A Practical Guide

The short answer

How to give an AI a memory is really three separate questions, and most advice answers the wrong one. You can (1) switch on a memory feature inside a chatbot, (2) write a memory yourself in its instructions, or (3) give it a durable store that survives every session. Only the third one stops the forgetting for good — but all three have their place, and knowing which one you're doing is what separates a workaround from a fix.

Here is the honest map, step by step, ending with the recipe that actually works.

First, separate the window from the store

Before you touch any setting, understand the thing you're fighting. An AI assistant like ChatGPT, Claude, or Gemini doesn't hold your conversations in a memory the way a person does. It reads a context window — a finite amount of text it can see at one moment. Everything you've said lives there, and when the window fills, the oldest content is pushed out to make room for the new.

That's why the same assistant can be razor-sharp at minute ten and amnesiac by tomorrow. The model didn't change. What it can see changed.

So when you want to "give it a memory," you're choosing where the important stuff lives:

Approach	What it actually is	How long it lasts
Built-in memory feature	A short list of facts the vendor keeps	Across chats, but shallow
Custom instructions	A note you wrote that loads every session	Every session, but static
Persistent memory layer	A durable store outside the window	Indefinitely, and growing

Read why AI has no memory if you want the full anatomy of the problem — the short version is that most assistants have a whiteboard, not a filing cabinet.

Option 1: The built-in memory feature (good start, hard ceiling)

ChatGPT, Claude, and Gemini all ship some form of "memory" now. They work the same way: the AI decides certain facts about you are worth keeping — your name, your project, your dietary preference — and stores them as a short list it can consult on later chats.

Do this when: you want the basics to stick. Your name, your role, your recurring constraints. Tell it explicitly: "Remember that I'm building a garden design business and I work with clients in the evenings." Then, in a later chat, ask it what it remembers about you. You'll usually find the fact is there.

The ceiling: these features store facts, not threads. They will not hold the arc of a project, the reasoning you built across a dozen sessions, or the nuance of a long working relationship. A fact list is not a conversation history. If your work lives in the detail, the built-in feature will let you down at exactly the moment you need it most.

Option 2: Custom instructions and system prompts (a memory you write)

Every serious assistant lets you set persistent instructions — "custom instructions" in ChatGPT, "custom instructions" or project settings in Claude, "customization" in Gemini. Whatever it's called, this is a memory you write yourself, and it loads at the start of every session.

Do this when: you have stable facts about how you want to be helped — the format you like, the tone you want, the things you never want it to do. This is the cheapest real memory you can get, because it costs nothing, is fully transparent, and never drifts.

The ceiling: it's static. A custom instruction is a note pinned to the top of the conversation, not a living record. If your project changes, you have to edit the note by hand. And it can't hold what happened last week, because it doesn't know what happened last week. It's a memory of your preferences, not a memory of your history.

The step up from here is what most people skip — and it's the one that changes everything.

Option 3: A persistent memory layer (the real fix)

The durable answer is to move the memory out of the window entirely and into a store the assistant keeps — something it can read from and write to across every conversation, with no summary required.

This is the architecture behind the "AI that remembers you" products you've heard about, and it's not magic. It's a few honest pieces:

1. A durable record. Every session ends with the key facts, decisions, and state written to a store — not a paraphrase, the source itself.
2. Automatic rollover. When a new session starts, the assistant pulls in what's relevant and resumes, instead of starting blank.
3. Local or private storage. The record lives where you say it lives. If it's on your machine, it's yours.
4. No summary drift. Because nothing is compressed into a lossy summary, nothing quietly gets lost.

That last point is the one people underestimate. Every time you ask an AI to "summarise the chat so we can continue later," you're deciding what mattered — and the AI makes that call while already missing pieces. After a few rounds of summarise-and-continue, the thread is a game of telephone played with yourself. A persistent store keeps the original, so there's nothing to lose. For a deeper look, see why persistence beats a bigger context window.

The practical recipe, in order

If you want to do this properly today, here's the sequence I'd actually recommend:

1. Turn on the built-in memory and tell it the stable facts about you. Do this now — it costs nothing.
2. Write one good custom instruction about how you want help. Keep it to a short paragraph; specific beats clever.
3. For any project that spans more than two sessions, stop relying on memory features. Start a dedicated space for it (a project folder, a knowledge file, a persistent-memory app) where the working state lives.
4. End each working session by writing the state down yourself — decisions made, next step, open questions. This is the habit that makes every tool better, because it gives the next session something true to load.
5. When the project outgrows your notes, graduate to a real persistence layer — an AI companion or agent that keeps its own durable memory and resumes where it left off.

Step 4 sounds old-fashioned, but it's the hinge. Most people skip it and then blame the tool when the thread dies. The tool can't remember what you never wrote down.

What not to do

• Don't paste the whole transcript into every new chat. That's not memory, that's luggage. It eats the window and you become the archivist.
• Don't trust "just ask it to summarise" as your long-term plan. Summaries drift; the original doesn't. (Here's the fuller case: why context engineering is a workaround.)
• Don't assume a bigger model fixes it. A bigger window is a bigger whiteboard. It still gets erased — just later.

The bottom line

How to give an AI a memory? Use the built-in features for facts, write custom instructions for preferences, and for anything that matters across sessions — give it a durable store. Feature memory is a post-it note. Instruction memory is a laminated card. Persistent memory is a filing cabinet with your whole history in it. Most people need all three, but only the third one deserves the word "memory."

Read next: how to make ChatGPT remember across chats, and the types of agent memory explained.