Claude doesn't remember you. I don't mean that in some poetic sense. I mean it literally. Every conversation starts from zero. The preferences you set, the decisions you made, the brief you spent twenty minutes explaining: all of it exists only inside a temporary buffer called the context window. When that buffer fills up, or when you close the conversation, it's gone. This is the single most important thing to understand about Claude AI memory, and most people discover it the hard way.
I've watched it happen dozens of times in training sessions. Someone spends half an hour building a detailed analysis with Claude, making careful decisions about structure, agreeing on terminology, setting constraints. Then around message twenty-five, Claude contradicts something they established at the start. The reaction is always the same: confusion, then frustration. "I already told it that." You did. It just doesn't have that information any more.
This isn't a flaw you can report or a setting you can toggle. It's how the technology works. And once you understand the mechanics, you can build systems that compensate for it instead of fighting a limitation that won't go away.
How the context window actually works
Every conversation with Claude takes place inside a context window. Think of it as a desk with a fixed surface area. Everything on the desk is visible: your messages, Claude's responses, any documents you've shared, the system instructions from a Project or CLAUDE.md file. Claude can see all of it, reference it, reason with it. The desk has edges, though, and you can't push them back.
When the desk fills up, something has to give. The system compresses or removes older material to make room for new content. This process is called compaction. Claude doesn't choose what to drop. It doesn't weigh up whether your brand guidelines are more important than the last paragraph it wrote. The compression is mechanical, and earlier material gets summarised or discarded based on recency, not relevance.
The result is a sliding window of awareness. Everything recent is sharp and detailed. Everything from earlier in a long session may be blurred, compressed, or gone entirely. Your conversation has a horizon, and that horizon moves forward as you keep talking.
What compaction feels like in practice
You're working through a client proposal. In the first few messages, you established specific constraints: budget ceiling of €50k, three-phase delivery, no subcontractors, payment terms of net-30. Twenty messages later, you ask Claude to revise the pricing section and it produces a four-phase plan with a budget of €65k. It hasn't decided to ignore you. Those constraints were compacted out of the active context to make room for everything that came after.
I see this consistently when working with business teams. The symptoms are predictable:
- Claude loses track of instructions from thirty messages ago and reverts to default behaviour on things you already corrected.
- It repeats suggestions it already made, without recognising the repetition.
- It contradicts earlier decisions because the original agreement has been compressed out.
- Specific details you mentioned once, like file paths, client names, or variable definitions, disappear from its awareness.
On the Pro plan ($20/month), this can happen within twenty to thirty exchanges during a complex session. On Max ($100/month), the same conversation might run fifty or sixty exchanges before compaction becomes noticeable. The effect is identical; it just arrives later. And when it arrives, the cost is always the same: you stop working, restate the lost context, and verify Claude has picked it up again.
This isn't specific to Claude
Every large language model operates within a context window. GPT-4, Gemini, Llama, every model you've heard of. The window sizes differ, and the compaction strategies vary, but the fundamental constraint is architectural. Any vendor claiming their AI "remembers everything" is either using retrieval systems behind the scenes (which is a different thing entirely) or misrepresenting the technology. The useful response isn't to find a model without this limitation. It's to build your working environment so the limitation matters less.
Projects: persistent context on Desktop and Web
The simplest form of continuity in Claude is the Projects feature, available in Claude Desktop and the web interface on Pro plans and above. Projects let you upload documents, set custom instructions, and define scope. Everything you add loads automatically at the start of every new conversation within that Project.
This is not memory. Claude does not remember your previous conversations. What Projects do is reload your context fresh each time. If you've uploaded a client brief, a style guide, and a set of working instructions, Claude has access to all of them the moment you open a new chat. You don't need to paste them in again.
That's genuinely useful. A client brief, a brand voice document, a list of standard procedures: anything you'd otherwise re-explain every session can sit in a Project and be available automatically. For most people using Claude Desktop or the web interface, this is the first thing to set up, and it makes an immediate difference.
The limitation is that Projects are static. They hold whatever you put there, but they don't track what happened in previous conversations. Claude will know your preferences and your client's details. It won't know what you worked on yesterday, what decisions were made, or where you left off. The reference material is persistent. The working context is not.
CLAUDE.md: persistent instructions in Claude Code
Claude Code, the command-line and VS Code interface, takes a different approach. Instead of uploading documents to a Project, you create files within your workspace that Claude reads automatically at the start of every session.
The most important of these is the CLAUDE.md file. It's a markdown file containing your core instructions: how Claude should behave, what conventions to follow, what terminology to use, what mistakes to avoid. Claude reads it fresh every time, which means your instructions survive compaction and persist across sessions without any effort on your part.
You can also create rules files for specific domains. Communication standards, research conventions, file organisation policies, citation formats. Each one loads alongside the CLAUDE.md, and together they form a comprehensive set of operating instructions that Claude follows from the first message.
This is more powerful than Desktop Projects for a specific reason: your entire workspace acts as context. Claude can read your folder structure, check file names, understand how your work is organised. The instructions are embedded in the environment itself, not attached as separate documents. It's the difference between handing someone a manual and sitting them at a configured workstation.
Auto-memory in Claude Code
Claude Code also has an auto-memory feature. As you work, Claude saves observations and preferences to a memory file that persists across sessions. Over time, it builds a record of how you like things done: what patterns to follow, what corrections have been made, what specific preferences you've expressed.
Auto-memory is lightweight and cumulative. It doesn't record full conversation history. It captures the kind of practical notes a competent assistant would keep. "Uses UK English." "Proposals need a cover page with signature block." "Never use em dashes." Small details that compound into significant consistency over time.
The gap that remains
Projects and CLAUDE.md files solve the identity problem. They ensure Claude starts every session knowing your preferences, your context, and your standards. That's essential. It's the right foundation.
But there's a gap, and it's a big one. What Claude did in the last session, the decisions that were made, the files that were changed, the progress that was achieved: all of that is lost when a new conversation starts. Your CLAUDE.md tells Claude what to do. It doesn't tell Claude what it already did.
Here's where it gets real. You spend two hours with Claude working through a client proposal. You make decisions about scope, pricing, phasing, and deliverables. You iterate on the structure three times before settling on a final version. The next day, you start a new session to continue refining it. Claude has your CLAUDE.md, your rules, your style preferences. But it has no idea you worked on this proposal yesterday. It doesn't know what you decided, what you rejected, or where you stopped.
You're back to explaining working context from scratch. Not the foundational context (that's handled by your persistent files), but the session context: what happened, what was decided, what comes next. For simple one-off tasks, this gap doesn't matter. For sustained, multi-session work on complex projects, it's a genuine constraint that costs real time.
How AI Business OS addresses session continuity
The AI Business OS is a workspace template built specifically to work around context limitations in Claude Code. It provides the full structure: CLAUDE.md files, rules, skills, commands, file organisation conventions, and a state tracking system that bridges the gap between sessions.
The state system maintains a structured record of every project you're working on, including its current status, the last action completed, and exactly where work stopped at the end of the previous session.
Session continuity fields
Two fields in particular make the difference.
- stoppedAt records exactly where work was interrupted or ended. Not a vague summary, but something specific: "Completed sections 1-3 of the proposal. Section 4 (pricing) drafted but not reviewed. Client feedback on section 2 needs to be incorporated."
- lastAction records the final completed action: "Sent draft proposal to client for initial feedback."
When a new session starts, Claude reads these fields and knows precisely where to pick up. No re-explanation needed. The record is there, structured and specific, and it loads in seconds.
Project state and session history
Beyond continuity fields, the state system tracks milestones, task lists, and a rolling session history for each project. Claude can see not just where you stopped, but the broader trajectory: what's been completed, what's outstanding, what's blocked, and what the priorities are.
This is not AI memory. It's structured record-keeping that Claude reads at the start of each session. The distinction matters. AI memory would imply that Claude internally retains information between sessions. What's actually happening is that a system external to Claude maintains the records, and Claude consumes them on demand. The result feels like memory. The mechanism is file reads. Understanding this helps you use it effectively, because you can inspect, edit, and override every record.
How PRIMA adds conversation history
PRIMA sits alongside the AI Business OS and addresses the final piece: full conversation history across sessions.
The state system records structured data about what happened (project status, last action, stopping point). PRIMA records the actual conversations. Every exchange between you and Claude is logged to a local database on your machine. Nothing is sent to external servers. The data stays entirely with you.
What this enables
At the start of a new session, Claude can search PRIMA's history to recover what happened previously. This goes beyond the structured fields in the state system. It includes the full conversation: the reasoning, the alternatives considered, the specific wording of decisions, the questions you asked, and the answers Claude gave.
- You can ask "what did we decide about pricing for the Smith proposal?" and Claude will search session history and find the answer.
- You can resume work on a project and Claude will know not just where you stopped (from the state system) but the full context of how you got there (from PRIMA).
- If you discussed multiple options and chose one, PRIMA records both the options and the decision. The state system records only the outcome.
A searchable log, not human memory
PRIMA doesn't give Claude memory in the human sense. It provides a searchable log. Claude queries the log when needed, retrieves relevant information, and uses it in the current session. The effect feels similar to memory, but the mechanism is retrieval, not retention.
This distinction is practical, not pedantic. A searchable log can be audited. You can see exactly what Claude retrieved, verify it against your own recollection, and correct it if something is wrong. True internal memory would be opaque, operating inside the model with no way to inspect or override it. The log-based approach is more transparent and more controllable. For business use, that transparency matters.
The combined picture
Together, AI Business OS and PRIMA create a layered continuity system.
- CLAUDE.md and rules handle identity: who you are, how Claude should work, what the standards are.
- State tracking handles status: what projects exist, where each one stands, what was done last.
- PRIMA handles history: what was discussed, what was decided, and the reasoning behind each session's work.
The result is that Claude can start a new session and, within seconds, know your identity, your rules, your project status, and your recent working history. That's a fundamentally different experience from a blank conversation with no context.
What you can do right now, regardless of setup
Whether or not you use the AI Business OS, these principles apply immediately.
Save decisions to files, not just conversation
If you make an important decision during a session, write it somewhere persistent. A notes file, a project document, a CLAUDE.md entry. Anything in a file will be available next session. Anything that exists only in conversation will be lost when that conversation ends.
Use Projects or CLAUDE.md for critical instructions
Don't rely on telling Claude your preferences at the start of each session. Put them in a Project (Desktop/Web) or a CLAUDE.md file (Claude Code). This is the single most impactful thing you can do to improve consistency. Your instructions load automatically, survive compaction, and persist indefinitely. The guide on structuring your workspace covers this in detail.
Keep sessions focused
The longer a session runs, the more likely compaction will remove early context. If you're working on a complex, multi-part task, break it into shorter, focused sessions. Complete one phase, save the output, start a new session for the next phase with the relevant context loaded fresh. Three thirty-minute sessions will produce better results than one ninety-minute marathon where Claude has lost half your initial instructions by the end.
Reinforce important context mid-session
If you notice Claude losing track of something during a long session, restate it. Paste the relevant instruction or decision back into the conversation. This moves it to the recent end of the context window, where it's far less likely to be compacted out. It takes ten seconds and saves you from a full re-explanation later.
Don't assume continuity
The most important habit is the simplest: don't assume Claude remembers anything from a previous session unless you have a system ensuring it does. Check. Verify. Provide context explicitly when it matters. Treat each new session as a fresh start until your tooling proves otherwise. The guide on direction and judgement builds on this principle for day-to-day work.
Where this is heading
Claude's context capabilities are expanding. Anthropic continues to increase window sizes, improve compaction quality, and develop features that address session continuity natively. The gap described in this article is real today, but it's shrinking with each model release.
In the meantime, the practical approach hasn't changed. Understand the limitation, build systems that compensate for it, and focus your effort on the work rather than fighting constraints. The businesses I work with that get the most from Claude are the ones that structure their environment to support it, rather than expecting the tool to handle everything internally.
That's what the AI Business OS is designed for. And it's why understanding what your workspace can do matters more than any individual prompting technique.