Why the migration changed course, which fallback stayed, and which compromise was actually intentional.
foss developer tooling
The code is still there. The reasoning usually isn't.
codemem is local-first memory for agent-heavy engineering work. It captures the parts that usually vanish — decisions, dead ends, repo-specific traps — and makes them recoverable before you need to rebuild the same understanding twice.
Works with
OpenCodeClaude Codemore to come
Viewer UI
The web UI shows recent memory, health, and sync state when you want to inspect what the agent workflows have already captured.
Sync
Peer-to-peer sync extends the same local-first memory across your machines when you want continuity.
local-first open source peer-to-peer sync structured recall opencode + claude code background capture
why this exists
Reasoning doesn't survive the session.
Migrations, debugging trails, architecture trade-offs, environment gotchas, and the exact reason a fallback exists tend to disappear at the worst possible time.
codemem keeps that context recoverable without forcing it into a hosted dashboard, a bloated wiki, or a pile of forgotten markdown files. Keep it local by default, then sync it across machines or selected projects when that is actually useful.
what gets stored
The parts of software work that are expensive to rediscover.
Not generic chat history. The useful bits that explain what happened, why it happened, and what to avoid next time.
The edge case you only noticed after three runs, plus the clues that finally made the bug make sense.
A recoverable trail of what happened so the next pass starts with context instead of guesswork.
The repeated fixes, gotchas, and project-specific habits that stop future work from relearning the same lesson.
sync
Use it locally. Sync it when continuity matters.
local-first
Your memory stays useful on one machine.
You do not need a server or account just to keep context from disappearing between sessions.
peer-to-peer
Keep your machines up to date.
Bring the same working memory to another laptop or environment without turning the product into a hosted silo.
selective
Share only the projects you mean to share.
Selective sync makes it possible to keep certain projects in sync where you want them without turning every memory into a shared artifact.
how it works
Capture context in the flow of work. Bring it back before you need to re-derive it.
01
Capture
Capture useful context in the flow of actual work instead of asking humans to maintain another side system.
02
Structure
Keep memory typed and queryable so retrieval is more useful than trawling old chats, terminals, or notes.
03
Recall
Bring context back into the next session, machine, or agent loop before the same understanding has to be rebuilt.
built for engineers
Built for OpenCode, Claude Code, and the workflows around them.
codemem already works with OpenCode and Claude Code. The point is durable project memory for real engineering work, not one-off chat transcripts tied to a single surface.
- recovering debugging context after a dead-end session
- keeping architecture decisions attached to the work that produced them
- handing context between humans and coding agents
- remembering repo-specific traps without building a private wiki
install
Install it and see if it earns a place in your toolbox.
Wire codemem into OpenCode or Claude Code, let it capture useful context quietly, and bring that context back when the next session needs the thread again.
docs
Get oriented fast and get back to the repo.
Install
Set up OpenCode or Claude Code, verify capture is working, and get to useful memory quickly.
Sync
Local-first by default, peer-to-peer when you want the same memory on another machine.
Integrations
Built for OpenCode and Claude Code today, with more agent workflows to come.