What they say

Memory lets AI “remember things about you across conversations,” “learn your preferences over time,” and “build a persistent understanding of who you are.” OpenAI has Memory, Claude has Memory, Gemini has Memory, Kiro has Memory. Each one implies the model is doing something special.

What it actually is

The LLM is stateless. Every conversation starts fresh — the model has no access to previous sessions. “Memory” is a feature your application (or the vendor’s platform) builds on top: persist facts to storage, retrieve them at the start of the next conversation, prepend them to the system prompt.¹

The pattern in pseudocode

// Session ends — persist what's worth keeping
async function saveMemory(fact: string) {
  await db.upsert('memories', { userId, fact, updatedAt: new Date() });
}

// Next session starts — load and inject
async function loadMemories(userId: string): Promise<string> {
  const rows = await db.query('SELECT fact FROM memories WHERE userId = ?', [userId]);
  return rows.map(r => r.fact).join('\n');
}

// The "memory" is just a string prepended to the system prompt
const system = `
You are a helpful assistant.

What you know about this user:
${await loadMemories(userId)}
`.trim();

const response = await llm.chat({ system, messages });

The model isn’t doing anything different. The application is doing the remembering.

The “extra steps”

1. Extraction — deciding what’s worth saving (another LLM call, or a hard-coded rule)
2. Storage — a database, flat file, or the vendor’s managed store (just a write)
3. Retrieval — loading memories at session start (just a read)
4. Injection — prepending to the system prompt (string concatenation)
5. Eviction — deciding what to forget when the memory store gets too large (LRU, relevance scoring, or a max token budget)

What you already know

If you’ve ever stored user preferences in localStorage and read them back on page load, you’ve built memory. Same pattern: write on exit, read on entry, inject into context.

// localStorage version — you've written this
const theme = localStorage.getItem('theme') ?? 'light';
document.body.dataset.theme = theme;

// LLM memory version — same idea
const memories = await loadMemories(userId);
systemPrompt = basePrompt + '\n\nUser context:\n' + memories;

The difference is that localStorage stores a preference; LLM memory stores facts that get read by the model. The mechanism is identical.²

Footnotes

1. Every major vendor’s memory implementation works this way. OpenAI Memory stores facts and injects them into future conversations. Claude’s memory in Claude.ai works the same way. Kiro’s memory and Gemini’s memory follow the same pattern. The LLM is stateless in all cases — statelessness is a fundamental property of the API. ↩

2. Key–value database — Wikipedia — the simplest possible storage model, and what almost every memory implementation reduces to at the persistence layer. ↩