https://github.com/user-attachments/assets/488a1e41-5a01-4c01-ac76-5c37b8e764f0
Coding agents keep memory: CLAUDE.md files, notes they extract, lessons from earlier sessions. You rarely see what is in it, what the agent took into this task, or whether it followed it. MemoSync is a local workbench for Claude Code, Codex, Pi and OpenCode that puts that memory on screen.
- Every change to memory waits for your review.
- Before each turn, you confirm what goes in.
- While the agent works, its replies cite the memories they use.
- After the turn, a separate check reports what was followed and what was ignored.
When a turn doesn't need that much attention, switch to Automatic and the agent handles memory on its own.
A turn with memory
Memory is a set of short items. Each has a scope (personal, project or session), a version and a history. The same item shows up in four places during a turn.
1. Review what the agent learned
Before a turn starts, MemoSync shows the memory changes it proposes, in three groups. Accept, edit, rescope or dismiss each one. Nothing reaches the store until you do.
- New candidates: taken from your last exchange and from what the agent actually did (files, commands, errors).
- Transfers from other projects: a rule from another project is first rewritten in general terms, then adapted to this project. You see all three versions side by side.
- Fixes to existing items: conflicts, duplicates to merge, and rules that have gone stale or keep being broken.
2. Choose the working memory
Working Memory for This Turn lists the items the agent intends to use, each with one line saying how. Remove rows or add others from your library. You can also ask in plain words, for example "drop the commit-style ones". The agent starts only after you confirm, and the audit later checks it against exactly this list.
3. Follow it while it works
Replies cite the memories they apply (M-07). Hover a citation to see the item.
Tool calls fold into one line, like Read 3 files, ran 2 commands, with the running step beside it. Open the line to see each step and what came back.
If the agent is doing the opposite of a memory:
- Press Stop on that citation.
- Write what should have happened.
- Optionally enforce the item for the rest of the run.
The agent resumes from the sentence where you stopped it, and your correction is saved to the item.
Citations are what the agent says it used, not proof that it did. That is why step 4 exists.
4. Check the result
When the turn ends, a separate pass reads the whole exchange and rates every selected item: violated, shaped the turn, not applicable, or no visible effect. Each verdict says whether the audit found it or the agent reported it, so a violation the agent never cited still shows up.
For a violated item:
- Where used jumps to the sentence and tool call behind the verdict.
- Enforce this next run makes the item a required row in the next turn. Only you can remove it.
Verdicts also come back to the trace: a memory shows on the tool call that used it, and a violated one is marked in red.
The audit is a model judgment and can be wrong.
Between turns
The Memory Board is the whole library. The rail on the left lists every scope, project and session, along with items waiting for review, archived items and memory files. See the library as a graph of where each memory lives, or as a board with one column per scope.
- On the board, drag an item to change its scope.
- Open an item to edit it, read its history, or archive it.
- Memory files keeps a Markdown copy for other tools, and imports an existing
CLAUDE.md as candidates for review.
Import memory, at the top of the board, brings in what Claude Code and Codex already remember. A model you pick splits their notes into short items, sorted into personal preferences and project memory. Nothing is saved until you review it. Later imports propose only what changed, and anything you remove stays under Removed, where you can bring it back.
The Memory Record, on the right of every chat, logs each turn: what was proposed, selected, cited, stopped and audited. It survives context compaction, so you and the agent can still refer back to it.
Automatic
Reviewing every turn pays off when memory matters, and is too much for a quick question. Set Settings → Memory → Control to Automatic:
- No cards before the turn. The agent reads the memory index and loads the items it needs.
- After the turn it learns in the background. Safe changes apply on their own, each with Revert; sensitive ones wait on the Memory Board, which shows a count in the sidebar.
- The audit still runs, but speaks up in the chat only when a memory was violated. Every verdict stays in the Memory Record.
Quick start
Mac app
Download the DMG from Releases and drag MemoSync to Applications. The app runs on Apple silicon Macs; on an Intel Mac, run it from source.
The app isn't notarized yet, so macOS blocks it the first time. Try to open it, then go to System Settings → Privacy & Security and choose Open Anyway.
The app doesn't include any agents, so install Claude Code or Codex first. To use Pi, install @earendil-works/pi-coding-agent 1.3.0 or newer. The app shares ~/.memosync/data with a source install, and only one of them can run at a time.
From source
You need Bun 1.3.5 or newer, plus one of:
- Claude Code or Codex already signed in, or
- an API key from any provider.
git clone https://github.com/SLEEPYBQ/MemoSync.git
cd MemoSync
bun install
bun run build
bun run start
MemoSync opens at http://localhost:3210.
This is the beginning of the README. Read the rest at the original. Read the full README ↗
