Why do AI assistants lose context between conversations?
AI assistants lose context when earlier work is not present in the information available to the current request. Every response is limited by a context window. A client may also use context compaction to summarize a long conversation, which can omit details.
Some assistants offer built-in memory, but its scope, controls, retention and portability depend on that provider and can change by product or plan. A separate memory layer addresses a different need: keeping project context outside one conversation so supported tools can retrieve it again. It does not guarantee that every fact is saved or that every connected assistant will use retrieved context correctly.
How does a persistent AI memory layer work?
A persistent memory layer saves durable context separately from the chat, retrieves relevant items, and sends only the selected context to the AI tool. A practical workflow has five parts:
- Capture. Save an established decision, fact, open question, todo or summary when it becomes useful.
- Store. Keep those notes in a project-specific memory, separate from raw chat transcripts.
- Index. Prepare project files for exact or semantic search without treating every source passage as a remembered fact.
- Retrieve. Recall relevant notes and source passages at the start of a session or before answering a project question.
- Trace. Keep file, page and chunk metadata with retrieved passages so a person can inspect the source.
How is an AI memory layer different from built-in chat memory?
Built-in chat memory belongs to one assistant, while an independent memory layer can serve multiple supported tools from a separate store. The best choice depends on whether you need simple personalization, application infrastructure or reusable project context.
| Kind | Where memory lives | Best fit |
|---|---|---|
| Built-in assistant memory | Inside the provider's product and account | Personalization within that assistant |
| Developer memory service | In a service or database connected through an API or SDK | Teams building memory into their own application |
| Project memory layer | In a project store on storage you choose, with retrieval exposed to supported clients | Reusable context across projects, sessions or more than one supported AI tool |
These categories can overlap. A product may offer built-in memory and external connections, and an organization may combine local storage with optional cloud infrastructure. Compare the actual data boundary, export options, supported clients and retrieval behavior rather than relying on the word “memory” alone.
What should you look for in an AI memory layer?
Look for inspectable storage, controlled writes, cross-session retrieval, clear data boundaries and source traceability. Six practical checks help:
- Human-readable records. You should be able to inspect and correct durable notes rather than treating an opaque index as the source of truth.
- Explicit write boundaries. The product should distinguish tools that read source files from tools that write memory notes.
- Supported connections. A standard such as MCP (Model Context Protocol) can make one store available to multiple clients, but compatibility and capabilities still vary by client and platform.
- Deliberate checkpoints. A memory checkpoint should record an established item without copying an entire conversation.
- Source traceability. Retrieved document passages should retain available file, page and chunk metadata. Traceability helps review; it does not prove that the source or generated answer is correct.
- Clear data boundaries. A local-first default should state what remains on chosen storage, which connections send data elsewhere and which network calls are required.
How does Central Brain provide persistent AI memory?
Central Brain keeps project memory in human-readable local files and exposes recall, checkpoint and compaction tools through a project-specific MCP server. Its memory notes can record decisions, facts, open questions, todos and summaries. A separate project brief provides a compact starting point for a new session.
memory_checkpoint appends one established item. memory_recall searches saved notes and the brief. memory_compact replaces the project brief with a supplied updated summary and marks the included notes as compacted rather than deleting them. central_brain_ping confirms that the server is running and reports the project root. These tools support continuity, but the connected assistant must call them and people should review important records and outputs.
Central Brain also prepares PDF, DOCX, TXT, Markdown, CSV and XLSX files, can run optional OCR on scans when the build includes it, and embeds chunks with a bundled 384-dimension MiniLM model into a local vector index. The default preparation, embedding and search workflow does not require a cloud AI provider.
Can one AI memory work across Claude, ChatGPT, Copilot and Codex?
Yes, one project memory can serve multiple supported AI clients when each client is connected to that project's Central Brain MCP server. Central Brain provides project-specific setup for Claude Desktop, Claude Code, GitHub Copilot and the ChatGPT desktop app (Chat, Work and Codex modes) on Windows and Apple silicon Mac. Client features, setup and platform support can differ, so check the current getting-started guide for the combination you plan to use.
Does local-first AI memory keep everything private and offline?
Central Brain itself runs air-gapped between 14-day license checks, but a connected cloud AI tool still receives what it retrieves. In Central Brain's default project workflow, source files, prepared output, memory files, the bundled embedding model and the local vector index remain on storage you choose. File tools can read or search permitted project files but do not modify, move or delete those source documents; memory tools can append notes and update the project brief.
Data crosses that local boundary when you send retrieved context to a connected AI tool or configure cloud embeddings, Pinecone, Postgres, Redis or another optional destination. License activation and periodic verification contact Keygen and can exchange licensing and device information, but they do not require project documents. People and software with access to your device, folders, backups or synced storage may also be able to access the data. Review Security and data boundaries before using sensitive material.
Is AI memory the same as a second brain?
An AI memory layer can be part of a second brain, but the terms are not identical. A second brain for AI usually combines durable notes, searchable source files and a retrieval path for assistants. Central Brain is designed so a person can inspect the memory while supported AI tools can retrieve from the same project store.
Who needs an AI memory layer?
An AI memory layer is most useful for people who revisit the same projects across many sessions or supported AI tools. Typical use cases include:
- Consultants and analysts juggling client folders who are tired of re-uploading the same PDFs into every chat.
- Teams evaluating sensitive workflows that need inspectable storage and explicit data boundaries. Local-first architecture does not itself provide a compliance certification or determine legal suitability.
- Developers using more than one supported assistant on the same repository who want a shared record of project decisions.
- Researchers whose mixed folders of papers, notes and spreadsheets should be searchable by meaning, with page numbers attached.
- Small teams that want project-specific memory and source-traceable retrieval without making a hosted memory service the default store.
What do people ask about AI memory and MCP?
How do memory_recall, memory_checkpoint, memory_compact and central_brain_ping work in plain language?
memory_checkpoint appends one established decision, fact, open question, todo or summary to the project memory. memory_recall searches the saved notes and project brief. memory_compact replaces the project brief with an updated summary supplied by the assistant and marks the included notes as compacted; it does not delete the original notes. central_brain_ping confirms that the server is running and reports the project's root folder. The connected assistant must call these tools for the workflow to work.
What gets remembered?
Central Brain can save five note types: decisions, facts, questions, todos and summaries. A separate project brief provides the compact baseline a new session can start from. The assistant saves individual notes with memory_checkpoint, while memory_compact updates the brief from a supplied summary. Raw chat transcripts are not automatically copied into memory, and prepared project files are indexed separately for search. People should review important notes because an assistant can save something incomplete or incorrect.
What happens when my session is compacted?
Checkpoints already written to the project memory remain available when a chat client compacts its live conversation. Compaction behavior varies by client, but it commonly summarizes or drops older conversation detail as a context limit approaches. After client compaction, or in a fresh session, memory_recall can search the saved notes and project brief. Anything that was never checkpointed may not be present. See context compaction.
Which tools connect to Central Brain?
Claude Desktop, Claude Code, GitHub Copilot and the ChatGPT desktop app (Chat, Work and Codex modes) connect through a project-specific MCP (Model Context Protocol) setup on Windows and Apple silicon Mac. Capabilities vary by platform and by client, because each client decides which MCP features it supports. Setup steps are in getting started. Other MCP clients may work but are not listed as supported; if you rely on one, test it before buying or ask us.
Is MCP access read-only?
Source-file access is read-only, but the memory tools are intentionally writable. The file tools (semantic_search, search_text, read_file, list_files) search, read and list permitted project files; they do not modify, move or delete those documents. memory_checkpoint appends memory notes, and memory_compact updates the project brief and compaction state. Review the security and data-boundaries page before using sensitive material.
Can multiple projects have separate memories?
Yes. Central Brain is organized project by project. Each project has its own root folder, its own index and its own memory (five note types plus a project brief). The MCP setup is also per project, so a Claude or Copilot session attached to project A does not see project B's memory. This keeps client work, personal research and codebases apart. If you want shared context across projects, the practical approach is to keep that material in a project of its own.