Saving is easy. Managing is everything.

Merso is open-source long-term memory for AI agents. One memory for every project and every tool you work in, kept in your own cloud and reconciled every day, so your agents know what is true now, not just what was once said. Use it for your own work, or build it into the AI apps you ship.

In design. Built in public and used daily before the first release.

  1. Memorize
  2. Extract
  3. Reconcile
  4. Surface
  5. Own

Most memory systems stop at M and E. Merso is built around R.

A pile of notes is not a memory

What reconcile means

Each day Merso compares what happened with what it already knows. Changed facts get an end date instead of being overwritten, names that mean the same thing merge, and one-off details expire.

New from today

Codex session in atlas-web, Oct 14

  • Moved the database from Postgres to Cloudflare D1.
  • Fixed the login redirect in the dashboard app.
  • Port 4321 was busy, so I used 4322.

Memory

  • factAtlas runs on Postgressince Sep 2Sep 2 to Oct 14
  • factAtlas runs on Cloudflare D1since Oct 14
  • thingAtlasalso atlas-web, “the dashboard app”since Aug 30
  • thingatlas-websince Sep 12
  • factLogin redirect fixed in AtlasOct 14
  • noteUsed port 4322, 4321 was busyexpires Nov 13 unless linked

3 new items to reconcile.

How it works

Five steps for every session and every day. The first two are easy. The third is the reason Merso exists.

  1. Memorize

    An adapter in Claude Code, Codex, Flue or your own agent sends each finished session to your Merso. Nothing to do by hand.

    Runs in your tools

  2. Extract

    A model reads the session and pulls out what matters: facts, decisions, open questions and the things they are about.

    Runs in your cloud

  3. Reconcile

    New knowledge is checked against what Merso already knows. Facts that changed are closed, not overwritten. Duplicates merge. Stale details expire. All of it follows rules you can read and edit.

    Runs in your cloud, every day

  4. Surface

    Every session starts with a short briefing of what is current. Everything else is one search away, so the context stays small and precise.

    Runs in your tools

  5. Own

    Merso runs in your own Cloudflare account. Your memory is readable, exportable and fixable, and it outlives any tool you use today.

    Your account, your data

Where each step runs

The same five steps as running parts. Pick a step to see what moves through the system. This is the design Merso is being built to, and the roadmap says what ships when.

Mersocontainer diagram, C4 model, level 2

Merso: container diagram, C4 model, level 2Memorize: When a session ends, the harness sends its record to the gateway. Nothing to do by hand, and the raw sessions are kept in your memory instead of disappearing with the tool. Extract: Extraction reads the new sessions and, with a model, pulls out what matters: facts, decisions, open questions and the things they are about. Reconcile: The heart of the system. Every day the reconciler compares what is new with what memory already knows. It closes facts that changed, merges names that mean the same thing and lets one-off details expire, following the rules in constitution.md. Surface: Every session starts with a short briefing, and the agent fetches the rest on demand. Over MCP any tool can read memory, including tools without an adapter. Own: Memory runs in your own Cloudflare account. You can read it and correct it, and switching tools deletes nothing.Merso[System]Memory: factsAtlas language: TypeScriptAtlas runs on PostgresSep 2 to Oct 14Atlas runs on Cloudflare D1newsince Oct 14since Oct 14, checkedAtlasmergedatlas-webClaude Code[Harness: hooks]Sends each finished session,gets a briefing at the start.Codex[Harness: hooks]The same session recordthrough a twin adapter.Flue[Harness: TypeScript]An agent on Workers sendssessions and reads memory.Other tools[Harness: MCP]Cursor, Gemini CLI, claude.airead and write over MCP.Gateway[Container: Worker, API + MCP]Takes sessions from adaptersand serves memory over MCP.Memory[Container: Durable Object]Journal, facts with timeand how things relate.Extraction[Container: Cloudflare Workflow]Pulls out facts, decisions,open questions and things.AI model[External system]Reads sessions and weighswhat changed.Reconciler[Container: Cloudflare Workflow]Closes facts, merges names,writes the briefing.constitution.md[File: Markdown]Rules for managing memory,a readable file, not code.Memory browser[Container: Worker]Read what your agents knowand correct it.You[Person]Owner of the memory,data in your account.sends the session[hook]sends the session[hook]sends the session[HTTPS]stores sessions[SQL]reads,writes[SQL]extractsfacts[HTTPS]reconciles withwhat it knows[SQL]readsrulesweighschanges[HTTPS]reads and writes[MCP]serves briefing,searches[SQL]readsand correctsedits facts[SQL]drawingContainer diagramnotationC4 model, level 2scopefull MERSO cycle

Memorize. When a session ends, the harness sends its record to the gateway. Nothing to do by hand, and the raw sessions are kept in your memory instead of disappearing with the tool.

Extract. Extraction reads the new sessions and, with a model, pulls out what matters: facts, decisions, open questions and the things they are about.

Reconcile. The heart of the system. Every day the reconciler compares what is new with what memory already knows. It closes facts that changed, merges names that mean the same thing and lets one-off details expire, following the rules in constitution.md.

Surface. Every session starts with a short briefing, and the agent fetches the rest on demand. Over MCP any tool can read memory, including tools without an adapter.

Own. Memory runs in your own Cloudflare account. You can read it and correct it, and switching tools deletes nothing.

  • person
  • container: a separately running part of Merso
  • the heart: Reconcile
  • harness or external system
  • system boundary
  • who talks to whom and why, technology in brackets
  • at work in the current step

Now in the system

  1. MClaude Code, Codex and Flue end their sessions and send the records.
  2. MThe gateway stores 3 sessions in today’s journal.
  3. EExtraction reads the new sessions and asks the model.
  4. ENew fact: Atlas runs on Cloudflare D1.
  5. RThe reconciler reads the rules in constitution.md.
  6. RFact “Atlas runs on Postgres” closed: Sep 2 to Oct 14.
  7. R“atlas-web” and “Atlas” merged into one thing.
  8. SA new Claude Code session gets a briefing of four sentences.
  9. SCursor asks over MCP what Atlas runs on and gets: Cloudflare D1.
  10. OYou open the memory browser.
  11. OYou confirm the fact: Cloudflare D1, checked.

Diagram elements

  • Claude Code [Harness: hooks]: Sends each finished session, gets a briefing at the start.
  • Codex [Harness: hooks]: The same session record through a twin adapter.
  • Flue [Harness: TypeScript]: An agent on Workers sends sessions and reads memory.
  • Other tools [Harness: MCP]: Cursor, Gemini CLI, claude.ai read and write over MCP.
  • Gateway [Container: Worker, API + MCP]: Takes sessions from adapters and serves memory over MCP.
  • Memory [Container: Durable Object]: Journal, facts with time and how things relate.
  • Extraction [Container: Cloudflare Workflow]: Pulls out facts, decisions, open questions and things.
  • AI model [External system]: Reads sessions and weighs what changed.
  • Reconciler [Container: Cloudflare Workflow]: Closes facts, merges names, writes the briefing.
  • constitution.md [File: Markdown]: Rules for managing memory, a readable file, not code.
  • Memory browser [Container: Worker]: Read what your agents know and correct it.
  • You [Person]: Owner of the memory, data in your account.

Relations

  • Claude Code to Gateway: sends the session [hook]
  • Codex to Gateway: sends the session [hook]
  • Flue to Gateway: sends the session [HTTPS]
  • Gateway to Memory: stores sessions [SQL]
  • Extraction to Memory: reads, writes [SQL]
  • Extraction to AI model: extracts facts [HTTPS]
  • Reconciler to Memory: reconciles with what it knows [SQL]
  • Reconciler to constitution.md: reads rules
  • Reconciler to AI model: weighs changes [HTTPS]
  • Other tools to Gateway: reads and writes [MCP]
  • Gateway to Memory: serves briefing, searches [SQL]
  • You to Memory browser: reads and corrects
  • Memory browser to Memory: edits facts [SQL]

One memory for any AI app

Merso is a service, not a plugin. Anything that speaks MCP or HTTP can read and write it: coding agents, agent frameworks, chat apps, or an AI feature in your own product. Switch tools and your agents still remember.

Where it plugs in

  • Claude Code
  • Codex
  • Pi
  • Flue
  • Pydantic AI
  • Cursor
  • Gemini CLI
  • claude.ai
  • ChatGPT
  • Your own AI apps

How they connect

MCPRead and write from any app that supports MCP: the briefing, search, a given day, a project, “remember this”.
APIThin adapters send each finished session, and your own apps can call it directly.

Where memory lives

Your Merso, in your Cloudflare account

  • Journal of days
  • Facts with time
  • Things and how they relate
  • Search by meaning
  • The reconciler, daily, following constitution.md
Your tools sit on top and can change. The memory underneath stays the same.

The rules are a file

How a memory should be managed is a matter of opinion. Merso keeps that opinion in constitution.md, a plain-text file the reconciler follows. To change how your memory behaves, edit the rules, not the code.

constitution.md

# How this memory is managed ## Facts- Every fact has a start date. When it changes, close it.- Never overwrite. Keep the old value, answer with the current one. ## Things- Merge names that refer to the same thing. Keep the aliases. ## Forgetting- One-off details expire after 30 days unless something links to them.- Never store passwords, keys or tokens. ## Briefing- At most 60 lines. Only what is current.

What Merso believes

Saving is easy. Managing is everything.
Capturing sessions is a solved problem. Deciding what is still true is the real work, so Merso is built around it.
Memory belongs to you, not to your tools.
One memory across harnesses and projects, in an account you control. Tools come and go; what you learned stays.
Little in context, the rest on demand.
A short briefing beats a long dump. Agents get sharper when they see less, and look up the rest when they need it.
Facts have time.
A memory should know what is true now, what used to be true, and when that changed.
A person can read it and fix it.
If you can’t see what your agent knows, you can’t trust it. Everything Merso remembers is readable and editable.

Roadmap

Built in public. Each stage is used daily by its author before it ships. The repository opens with v0.1.

  1. Stage 1Designing now

    Core and the first two harnesses

    The memory service on Cloudflare, an MCP server, adapters for Claude Code and Codex, a daily journal and the briefing.

  2. Stage 2

    The reconciler

    Facts with time, merged duplicates, relations between things and expiry. An adapter for Flue.

  3. Stage 3

    See and shape your memory

    A browser for reading and correcting memory, weekly compaction, and more sources such as email and meeting notes.