# Every agent. Same memory. Always. Self-maintaining memory for AI agents. Unforgetter keeps track of where the work stands: the decisions, the preferences, the open threads and what changed. Whichever agent you open starts from that same record, scoped to what it is allowed to see. - Compatible with Claude, ChatGPT / Codex, Cursor and Grok Bot through MCP. - Private alpha · guided setup Canonical: https://unforgetter.com/ ## Use whichever agent fits the task. One agent is enough to start. Unforgetter connects as an MCP server, so when you switch agent or add another, it reads the same working truth and you do not explain the project again. The agents that connect, and the job each one tends to do: - Claude: long-running product work - ChatGPT / Codex: thinking the problem through and writing the code - Cursor: editing in your IDE - Grok Bot: research and outreach Each of them starts from the same three lines: the fee measures against the original booking date; the capacity split is still open; money is stored in minor units, never as a float. The same record, whichever one you open. How much of it an agent may see is still set by its scope. ## The same task, handed to a second agent. Choose a task, then compare what the second agent does with and without shared context. Task: Extend the booking flow so a late cancellation is charged against the right date. Handoff: Claude Code to Codex. Without Unforgetter, Codex starts from: A blank session. Whatever survives is what you paste in by hand. It opens with: "Which date should the fee measure against, the original booking or the rescheduled one?" Result: It picks the rescheduled date. The opposite was decided three weeks ago, so the change ships wrong and is reverted in review. With Unforgetter, Codex starts from: Five current items compiled for this task. History, the rejected draft and other projects stay out. It opens with: "Continuing the cancellation fee. It measures against the original booking date, per the 6 August decision. The capacity split is still open, so I am leaving that untouched." Result: The decision, its reasoning and the unresolved thread survive the handoff. Nothing is closed by accident. Compiled into the task: Decision: Fee measures against the original booking date (6 Aug · approved by you · supersedes the 22 July draft); Open thread: The capacity split is unresolved (Do not implement around it until it is decided); Method: Money is stored in minor units, never as a float (Your convention, carried into every agent that writes code); Scope: Booking product only (Finance and client material are outside this task); Provenance: 3 sources, freshest 6 Aug (Every line traces back to a document you can open). Deliberately left out: The rejected 22 July fee proposal (Superseded. Kept for audit, not sent to the agent.) Four months of session transcripts (History, not working truth.) Every other project in your workspace (Out of scope for this task.) Task: Write the monthly product update for customers without re-teaching the tone. Handoff: Claude to Grok Bot. Without Unforgetter, Grok Bot starts from: No record of how you write or what customers may be told. It opens with: "Happy to help. Could you share a few examples of the tone you are going for?" Result: You get a competent update in nobody's voice, rewrite it, and the next agent asks the same question again. With Unforgetter, Grok Bot starts from: Your writing rules, the customer-copy policy and the last four updates, compiled together. It opens with: "Drafting the product update. Plain sentences, no superlatives, and it says what is still unfinished, the way your last four updates read." Result: Your working method travels with the memory, so voice survives a change of vendor. Compiled into the task: Decision: Product updates always state what is unfinished (14 Aug · your rule after an update overpromised); Method: Plain sentences, no superlatives, no invented numbers (An instruction-only skill, versioned and portable); Open thread: Pricing is not public (Customer copy must not imply a price); Scope: Customer-facing product material only (Nothing internal or financial enters customer-facing copy); Provenance: 5 sources, freshest 21 Aug (Including the four updates the tone is drawn from). Deliberately left out: Internal revenue and runway notes (Out of scope for anything customer-facing.) The abandoned enterprise positioning (Rejected in March. Kept as history so it is not re-proposed.) Raw meeting transcripts (Superseded by the decisions drawn from them.) Task: Research a competitor for one client without touching another client's material. Handoff: Codex to Claude Code. Without Unforgetter, Claude Code starts from: Either the whole workspace, or nothing. The agent cannot tell which client this is. It opens with: "I have access to the whole workspace. Which parts are relevant here?" Result: You paste the context by hand again, or the agent quietly reads material belonging to a client who has nothing to do with this task. With Unforgetter, Claude Code starts from: The Northwind scope only: their brief, the agreed method and the open questions. It opens with: "Researching for Northwind only. I have their brief, the agreed method and the open questions. Nothing from your other clients is in this context." Result: One memory, but each agent only ever receives the slice this task is permitted to use. Compiled into the task: Decision: Northwind competes on service, not on price (2 Aug · agreed with the client · anchors every comparison); Method: Three independent sources minimum, each one cited (Your research standard, applied by whichever agent runs it); Open thread: Their pricing page is being rewritten (Treat anything quoted from it as provisional); Scope: Northwind workspace, 1 of 4 client scopes (The agent's token is configured for this project scope); Provenance: 4 sources, freshest 25 Aug (Two client documents, two of your own notes). Deliberately left out: Your three other client workspaces (Outside the project scope configured for this task.) Your internal margin notes on this account (Not included in the project scope configured for this task.) The archived 2025 engagement (Stale. Flagged in the record, not sent to the agent.) > Prototype UI using a sanitised scenario based on current product behaviour. It is not a screenshot of a shipped screen. ## Stored history is not working context. Agents need to know what still applies now. Three things break that continuity. - **Agent silos · Each agent remembers a different version of you.**: Built-in memory stops at the edge of its own product. Switch agents and your corrections and working methods stay behind. - **Context drift · Yesterday's answer quietly becomes today's input.**: A decision gets superseded. A static context file does not know that, so the old version keeps guiding the next task. - **No authority · A session should not get to rewrite the truth.**: Agents should propose changes rather than overwrite the record, and a rejected idea should stay rejected. ## It keeps itself current. You stay in control. Sessions end. Decisions change. Unforgetter reconciles the record automatically, so the next agent starts from what is current. The change history is there when you need it. A day of input: 09:12 Claude Code, Session end: Cancellation fee shipped against the original date. · 10:40 You, Correction: Refunds follow the same original-date rule. · 11:05 Codex, Proposal: Add: refunds measure against the original date. · 13:30 Grok Bot, Session end: Outreach draft ready; pricing still not public. · 14:15 Compiler, Reconciled: 1 decision updated · 1 thread still open · 0 conflicts The compiled working truth afterwards: Decision: Fees and refunds measure against the original booking date (Updated 14:15 · grounded in your 10:40 correction); Open thread: The capacity split is unresolved (Carried forward · 11 days open); Preference: Customer copy never implies a price (Reconfirmed by Grok Bot's session); Provenance: What changed today: 1 line (Diff, actor and evidence kept for audit). ## The right context, not the whole vault. For each task, Unforgetter combines current memory, methods, scope, sources and freshness into one small bundle. Memory: Current status, decisions and their reasons, open threads and rejected proposals. Methods and skills: How you work: conventions, writing rules, review standards. Portable instructions any agent can follow. Policy and scope: What each agent may see and do. Project, client and data-class boundaries enforced by the server. Provenance: Which document, which date, which person or agent. Every line can be traced. Freshness: When the record was last compiled and which facts are provisional, so stale material is marked rather than trusted. One task bundle: Small enough to fit the task; Scoped to what this agent may see; Marked with provenance and freshness; Pointers for deeper retrieval instead of a vault dump. > In build. Enforced today: project and data-class scope, the kinds of material an agent may request, ordering and size limits. Narrowing the bundle by the wording of the task itself is the direction this figure shows, not something that is live yet. ## Four steps, and then it keeps the context current. Connect the work once. Unforgetter maintains, compiles and governs the context from there. 01 Connect agents and sources. Approved workspace material is configured as the source. Claude, ChatGPT / Codex, Cursor and Grok Bot connect through MCP, with access scoped to what each agent may see. Result: Your agents reach one memory instead of separate silos. 02 Maintain the working truth. Unforgetter keeps a living record of current status, decisions and why they were made, preferences, open threads and rejected proposals. Result: A correction you make once stops returning as a new suggestion. 03 Compile context for this task. The compiler assembles the relevant decisions, methods, policy, provenance and freshness, and leaves out history and anything outside the task's scope. Result: The agent receives what it needs, not everything that happened. 04 Propose, review and update. Agents propose changes instead of overwriting the record. A controlled publisher handles authority, conflicts and protected areas before the working truth changes. Result: One agent's session never becomes the truth by accident. - [See the full flow](https://unforgetter.com/how-it-works) ## One memory you control. Every agent can use it. Your working memory stays readable, reviewable and portable. Agents get scoped context, not a copy of everything. - **Scoped access** (Working now): Each agent token is bound to a workspace, a trust zone and a project catalogue, enforced on the server every time context is served. - **Provenance and freshness** (Working now): Context carries the source and compile time needed to understand why a fact is present and how current it is. - **Proposals, not overwrites** (Working now): Agents suggest changes. A single publisher decides what becomes part of the working truth. - **Readable Markdown** (Verified): The canonical memory is versioned Markdown that opens without a proprietary viewer. - [Read the security model](https://unforgetter.com/security) ## Built for work that outlives a single session. For people who rely on AI agents for work that continues beyond one session. - **Founders · Switch agents without re-explaining the company**: Strategy in one tool, code in another, outreach in a third. The same decisions and voice reach all of them. [Read more](https://unforgetter.com/use-cases#switching-agents) - **Builders · Resume long-running work where it stopped**: Open threads, conventions and superseded decisions travel with the task instead of living in a chat scrollback. [Read more](https://unforgetter.com/use-cases#resuming-work) - **Agencies · Keep client scopes apart, by design**: Each client can be an enforced project scope. An agent token cannot list or retrieve material outside its allowed catalogue. [Read more](https://unforgetter.com/use-cases#company-brain) - [All use cases](https://unforgetter.com/use-cases) ## The questions people ask before they apply. **Do I need to use more than one agent?** No. One agent is enough. The memory keeps itself current between your sessions, so the agent you already use stops losing decisions, preferences and open threads. It becomes even more useful when you use several agents, because they all read the same record and switching agent no longer means starting over. **How is this different from ChatGPT or Claude memory?** Built-in memory is excellent inside one product and stops at its edge. Unforgetter is the neutral layer beneath several agents: the same approved working truth, compiled per task, owned by you, and portable when you change vendor. **Why not a CLAUDE.md or a context file?** A file is a snapshot you maintain by hand. It does not know that a decision was superseded on 6 August, it cannot scope itself per client, and every agent reads all of it. Unforgetter keeps the record current, versioned and scoped, and sends only the slice that fits the task. **Does Unforgetter run my agents?** No. It is not an agent runtime or a task relay. Claude, ChatGPT / Codex, Cursor and Grok Bot and other MCP clients still plan and execute. Unforgetter maintains and compiles the context between them. **How do I actually connect an agent?** Through MCP, which is why Claude, ChatGPT / Codex, Cursor and Grok Bot all work. Setup differs per client, so in the alpha it is guided: we take the quickstart for your client, connect the scoped endpoint and token, and check together that the right workspace comes back. Self-service signup and OAuth login are in build. **Where does my memory live and can I leave?** The canonical memory is versioned Markdown, compiled on a controlled writer and served from a gateway in an EU region. It opens in any editor, so there is no proprietary format holding it. Export, revoke and verifiable deletion are still in build as product functions. **Can I sign up now?** Private-alpha access is guided rather than self-service. You can apply, every application gets a personal reply, and invited workspaces are connected with you. - [Read the guides](https://unforgetter.com/blog) - [Documentation](https://unforgetter.com/docs) ## Give every agent the same memory. Join the private alpha if you rely on AI agents for ongoing work and want decisions, preferences and current status to carry forward without re-explaining them. One agent is enough; the same memory follows when you switch. A personal reply, a short call, and an invitation when there is room. Setup is guided: we connect your first agent with you rather than hand you a signup flow. - [Join the private alpha](https://unforgetter.com/private-alpha) ## Next - [How it works](https://unforgetter.com/how-it-works) - [Use cases](https://unforgetter.com/use-cases) - [Security and ownership](https://unforgetter.com/security) - [Join the private alpha](https://unforgetter.com/private-alpha) --- Status: Private alpha · guided setup. Contact: hello@unforgetter.com.