Unforgetter
Menu
Join the private alpha
Self-maintaining memory for AI agents

Every agent.Same memory. Always.

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.

Join the private alphaSee how it works

Compatible with Claude, ChatGPT / Codex, Cursor and Grok Bot through MCP.Private alpha · guided setup

Working state· booking product· compiled 26 Aug, 14:15Prototype
Decision

The fee measures against the original booking date

Approved 6 Aug · supersedes the 22 July draft

Open thread

The capacity split is unresolved

Do not implement around it until it is decided

Preference

Money is stored in minor units, never as a float

A working method carried into every coding agent

Provenance

Three sources, freshest 6 Aug

Every line traces back to material you can open

Compatible through MCP

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.

Pick an agent to see what it starts from

You openClaudefor long-running product workMCP

You openChatGPT / Codexfor thinking the problem through and writing the codeMCP

You openCursorfor editing in your IDEMCP

You openGrok Botfor research and outreachMCP

It starts from

  • 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.

Product proof

The same task, handed to a second agent.

Choose a task, then compare what the second agent does with and without shared context.

Compare what the second agent starts from, per task
Task
Prototype
Task

Extend the booking flow so a late cancellation is charged against the right date.

Claude CodeCodex

Same task. Same second agent. Only the context it starts from changes.

Agent
Without UnforgetterCodexafter Claude Code
Context it starts from
Context missing

A blank session. Whatever survives is what you paste in by hand.

What it does

Opens with

“Which date should the fee measure against, the original booking or the rescheduled one?”

It picks the rescheduled date. The opposite was decided three weeks ago, so the change ships wrong and is reverted in review.

Agent
With UnforgetterCodexafter Claude Code
Context it starts from
Context compiled

Five current items compiled for this task. History, the rejected draft and other projects stay out.

  • 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 (3)
  • The rejected 22 July fee proposalSuperseded. Kept for audit, not sent to the agent.
  • Four months of session transcriptsHistory, not working truth.
  • Every other project in your workspaceOut of scope for this task.
What it does

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.”

The decision, its reasoning and the unresolved thread survive the handoff. Nothing is closed by accident.

Task

Write the monthly product update for customers without re-teaching the tone.

ClaudeGrok Bot

Same task. Same second agent. Only the context it starts from changes.

Agent
Without UnforgetterGrok Botafter Claude
Context it starts from
Context missing

No record of how you write or what customers may be told.

What it does

Opens with

“Happy to help. Could you share a few examples of the tone you are going for?”

You get a competent update in nobody's voice, rewrite it, and the next agent asks the same question again.

Agent
With UnforgetterGrok Botafter Claude
Context it starts from
Context compiled

Your writing rules, the customer-copy policy and the last four updates, compiled together.

  • 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 (3)
  • Internal revenue and runway notesOut of scope for anything customer-facing.
  • The abandoned enterprise positioningRejected in March. Kept as history so it is not re-proposed.
  • Raw meeting transcriptsSuperseded by the decisions drawn from them.
What it does

Opens with

“Drafting the product update. Plain sentences, no superlatives, and it says what is still unfinished, the way your last four updates read.”

Your working method travels with the memory, so voice survives a change of vendor.

Task

Research a competitor for one client without touching another client's material.

CodexClaude Code

Same task. Same second agent. Only the context it starts from changes.

Agent
Without UnforgetterClaude Codeafter Codex
Context it starts from
Context missing

Either the whole workspace, or nothing. The agent cannot tell which client this is.

What it does

Opens with

“I have access to the whole workspace. Which parts are relevant here?”

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.

Agent
With UnforgetterClaude Codeafter Codex
Context it starts from
Context compiled

The Northwind scope only: their brief, the agreed method and the open questions.

  • 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 (3)
  • Your three other client workspacesOutside the project scope configured for this task.
  • Your internal margin notes on this accountNot included in the project scope configured for this task.
  • The archived 2025 engagementStale. Flagged in the record, not sent to the agent.
What it does

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.”

One memory, but each agent only ever receives the slice this task is permitted to use.

Prototype UI using a sanitised scenario based on current product behaviour. It is not a screenshot of a shipped screen.

The actual gap

Stored history is not working context.

Agents need to know what still applies now. Three things break that continuity.

01Agent 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.

02Context 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.

03No 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.

Kept current

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.

Today's input· 26 AugPrototype
  1. Claude CodeSession endCancellation fee shipped against the original date.
  2. YouCorrectionRefunds follow the same original-date rule.
  3. CodexProposalAdd: refunds measure against the original date.
  4. Grok BotSession endOutreach draft ready; pricing still not public.
  5. CompilerReconciled1 decision updated · 1 thread still open · 0 conflicts
Working state· booking product · compiled 14:15Current
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

More than a memory dump

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.

Compiled

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
Delivered over MCP to the agent doing the task

How it works

Four steps, and then it keeps the context current.

Connect the work once. Unforgetter maintains, compiles and governs the context from there.

  1. 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.

    Your agents reach one memory instead of separate silos.
    Step 1 of 4

  2. Maintain the working truth

    Unforgetter keeps a living record of current status, decisions and why they were made, preferences, open threads and rejected proposals.

    A correction you make once stops returning as a new suggestion.
    Step 2 of 4

  3. 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.

    The agent receives what it needs, not everything that happened.
    Step 3 of 4

  4. 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.

    One agent's session never becomes the truth by accident.
    Step 4 of 4
See the full flow

Ownership and control

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.

Working now

Scoped access

Each agent token is bound to a workspace, a trust zone and a project catalogue, enforced on the server every time context is served.

Working now

Provenance and freshness

Context carries the source and compile time needed to understand why a fact is present and how current it is.

Working now

Proposals, not overwrites

Agents suggest changes. A single publisher decides what becomes part of the working truth.

Verified

Readable Markdown

The canonical memory is versioned Markdown that opens without a proprietary viewer.

Read the security model

Use cases

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 →
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 →
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 →
All use cases

Practical objections

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 guidesDocumentation
Private alpha

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.

Read the docs firstJoin the private alpha