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.
Pick up where you left off across sessions and machines. codemem captures coding decisions, discoveries, and dead ends, then automatically brings relevant memories into later OpenCode, Claude Code, and Codex sessions. Start with your own work; share selected project knowledge with teammates when it helps.
Works with
OpenCodeClaude CodeCodex
See what was remembered
This example uses invented project memories. Explore the Feed, Facts, and Projects walkthrough.
Sync
Peer-to-peer sync carries the reasoning behind your work across machines when you want continuity.
cross-session memory open source peer-to-peer sync selective sharing structured recall opencode + claude code + codex background capture
why this exists
Reasoning doesn't survive the session.
You investigate a failing migration and find why a fallback must stay. In a fresh session, the code remains — but the next agent may not know why you kept it.
codemem stores that decision so it can be recalled when the migration comes up again. Keep stable rules in your project docs; use memory for the context you discover while working.
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.
continuity
Keep your context. Share what the project needs.
your work
Start with memory you own.
Memories stay in local SQLite you control; no hosted memory account is required. The observer sends captured context to your configured model, which can incur charges or consume plan usage.
peer-to-peer
Bring reasoning across machines.
Peer-to-peer sync carries project memory to another laptop or environment. Sharing a project includes its existing memories and future activity unless you mark a memory Only me.
selective
Share selected knowledge with teammates.
Choose the projects and memories that help the team. Teammates receive copies; changing visibility later cannot remotely erase copies that have already synced.
how it works
Capture context in the flow of work. Bring it back before you need to re-derive it.
01
Capture
Work normally. A configured observer model turns session activity into memories of decisions, discoveries, and fixes.
02
Structure
Keep those memories in local SQLite, with the details and file references you can inspect in the viewer.
03
Recall
Retrieve context for the current task and deliver it to your agent automatically, without asking it to search first.
built for engineers
Built for OpenCode, Claude Code, Codex, and the workflows around them.
Keep project knowledge available when you switch between supported coding agents.
Agent integrations use local MCP over stdio. Advanced single-user self-hosting can expose only the OAuth-protected Streamable HTTP MCP endpoint to configured remote clients; keep the localhost viewer private. Read the remote MCP deployment guide.
- 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
Start with one decision worth remembering.
Complete a real task and find its captured decision in the viewer. Start a fresh session in the same project and ask what changed and why without giving away the answer. Compare the response with the stored memory and the original evidence.
docs