Memory

The problem

Coding agents lose context across sessions. Claude, Codex, Cursor, OpenCode, Goose, Aider, and other agents each keep their own short-lived view of work. When users switch tools, close terminals, or hand off from one agent to another, useful context disappears.

Git remembers code history. Rekord remembers work history.

What Memory adds

• Durable project memories
• Git-aware snapshots with full patches
• Agent-to-agent handoff
• Resume context for interrupted work
• Named session linkage
• MCP tools so agents can read and write memory directly

Memory is stored locally by default under:

~/.rekord/projects/<project-hash>/

Rekord does not write memory files into your repository by default.

Core workflow

Store something important:

$ rekord remember "Parser refactor stopped at the failing unicode fixture"

Capture a stopping point:

$ rekord snapshot "Implemented parser refactor; tests still failing"

Search project memory and resume later:

$ rekord recall parser
$ rekord resume

Agent-to-agent handoff

Memory can scope context by agent. If Claude started the work:

$ rekord snapshot --agent=claude "Stopped at failing refresh-token test"

Codex, OpenCode, or another agent can continue from Claude's context:

$ rekord resume --from-agent=claude --to-agent=codex

The output includes the latest snapshot, relevant memories, changed files, patch files, blockers, and continuation context.

--agent, --from-agent, --to-agent, and --session shape a handoff:

So --from-agent / --to-agent are metadata only: they never hide another agent's memory. A handoff returns all of the project's open and recent memory, labeled claude → codex:

$ rekord resume --from-agent claude --to-agent codex

To see just one writer's memory, use --agent <name>. The same flags apply to recall, memory list, and memory search.

Named sessions

Agents can name Rekord sessions and tell users how to resume them.

memory-mvp-claude

Store memory and create snapshots linked to that session:

$ rekord remember --agent=claude --session=memory-mvp-claude "Auth middleware refactor is incomplete"
$ rekord snapshot --agent=claude --session=memory-mvp-claude "Stopped after debugging token expiry"

Resume from that exact session:

$ rekord resume --session=memory-mvp-claude

Git-aware snapshots

rekord snapshot captures the current branch, current HEAD, dirty status, changed files, full unstaged patch, and full staged patch.

Patch files are written locally under:

~/.rekord/projects/<project-hash>/patches/

This makes snapshots useful for review, recovery, and handoff.

Projects and storage

Rekord memory is per project, stored user-local under ~/.rekord/projects/<storage-key>/:

~/.rekord/projects/<storage-key>/
  memories.jsonl     # all memories for the project
  project.json       # { "path": "...", "key": "..." }
  patches/           # snapshot git patches
  snapshots/         # snapshot metadata

The storage key is derived from the project's git repository root. Any working directory inside the repo — top level or a deep subdirectory — resolves to the same key. This is what lets different tools (Claude Code, OpenCode, Cursor, …) share one project's memory even when each launches rekord mcp from a different directory.

Projects outside a git repository fall back to the absolute path of the directory.

List every project that has stored memory:

$ rekord memory projects
70eb5d71578c8d85  /Users/you/code/myapp
a1b2c3d4e5f60718  /Users/you/code/other

Agents can read the same listing via the memory_projects MCP tool.

rekord resume prints the resolved storage key so you can confirm which folder a session reads and writes:

$ rekord resume
Project: /Users/you/code/myapp
Storage key: 70eb5d71578c8d85

Commands

$ rekord remember <text>
$ rekord recall [query]
$ rekord resume
$ rekord snapshot [note]

Full memory management:

$ rekord memory add <text>
$ rekord memory list
$ rekord memory search <query>
$ rekord memory show <id>
$ rekord memory resolve <id>

MCP tools

Positioning

Memory makes Rekord the continuity layer for agentic development:

Record what happened.
Snapshot where work stopped.
Remember what matters.
Resume with the next agent.