Recall turns Claude Code cold starts into a local-first project memory system
Recall adds fully local project memory to Claude Code with project-scoped logs, compact resume context, and an offline TF-IDF plus TextRank summarizer that avoids extra API cost.
Most coding-agent workflows still pay the same continuity tax every time a session ends. You reopen the project, restate the goal, reconstruct what changed, and spend tokens rebuilding context that already existed yesterday. Recall stood out to me because it treats that problem like product infrastructure instead of accepting it as normal friction.
Recall is a plugin for Claude Code that adds fully local project memory. The pitch is simple, but the tradeoff is what makes the repo interesting: it does not solve memory by sending transcripts to another model or hiding state behind a hosted service. It keeps the whole loop on your machine, writes durable files into the project, and uses a local summarizer to create a cheaper resume point for the next session.
That is a narrower ambition than "universal AI memory," and that is exactly why the project feels useful. It is trying to make one painful workflow much cheaper and more trustworthy: resuming real work without replaying or re-explaining everything from scratch.
What the project actually ships
Recall writes two files under a project-local .recall/ directory.
history.md is the append-only log of what happened during a session: prompts, replies, files touched, and commands run.
context.md is the compact resume point: the goal, recent work, touched files, commands, and the next open threads.
The repo wires this into actual session behavior instead of leaving it as a manual habit. It defines SessionStart, Stop, and SessionEnd hooks, and it exposes commands like /recall:save, /recall:show, and /recall:log. That matters because memory tools usually fail at the boring part. If updating memory depends on discipline, the memory rots. Recall stays simple enough to run often.
Why the offline summarizer is the best idea here
The strongest product choice in Recall is that the summarization path is deliberately non-LLM.
The repo ships a vendored Python summarizer that uses TF-IDF plus TextRank, with a numpy-accelerated path when available and a pure-Python fallback otherwise. That sounds less flashy than another AI memory service, but it is the right tradeoff for this layer.
If every memory update requires another model call, continuity becomes one more metered subsystem with more latency, more cost, and another privacy boundary. Recall refuses that pattern. It uses Claude Code for the actual working session, but it does not spend model tokens maintaining the memory layer itself.
That makes the feature cheap enough to use continuously and local enough to trust by default. It is also a good reminder that not every supporting layer around agent software needs more AI. Sometimes classical techniques are the better product decision because they are deterministic, inspectable, and good enough for the job.
Why repo-local memory is better than hidden session state
Another thing I like is where the memory lives.
Recall writes plaintext artifacts into the current project instead of trapping continuity inside an opaque app cache. That makes the memory easy to inspect, portable across machines, diffable if a team wants shared history, and easy to delete or ignore when they do not.
This matters because a lot of agent "memory" is really just convenience around hidden session state. It works until you switch machines, clean history, or need to understand why the assistant resumed with the wrong assumptions. Project-local files create a healthier boundary.
The repo is also clear that this is different from hand-written instruction memory. CLAUDE.md tells the agent how to work. Recall records what actually happened. That separation is good product thinking because it keeps durable session history from getting mixed up with human policy and workflow rules.
The security stance is stronger than most memory tools
Memory features for coding agents can be risky because transcripts often contain implementation details, private paths, and sometimes secrets. Recall answers that with a narrower promise: no API key, no network calls, no third-party model, and writes confined to the project output directory.
The repo also includes a best-effort redaction pass for common secret shapes, hardens git reads so repository config cannot quietly execute code during history inspection, and prevents project config from redirecting writes outside the project boundary.
That does not make the problem disappear, and the README is honest about that. Redaction is best-effort, not magic. Shared .recall/ files can still become an injection boundary if a whole team writes to them. But I trust the repo more because it explains those boundaries clearly instead of pretending convenience automatically equals safety.
The limits are part of what makes it credible
Recall is intentionally scoped. It is built for Claude Code, not every coding agent. It does not replace hand-written guidance like CLAUDE.md, and it does not offer full transcript replay like --resume. Because the summarizer is extractive, it will never be as nuanced as a strong model trying to narrate the project state.
Those constraints are healthy. A lot of agent tooling overreaches early and becomes vague. Recall does something smaller and more believable: reduce the cost of cold starts for one real workflow with files you can inspect and an algorithm you can audit.
The main thing I would watch is how well the summary holds up on larger projects where intent and priority shifts matter as much as salient sentences. But for the resume-point problem, "good enough, cheap, and local" is often a better product answer than "smarter, slower, and networked."
Why builders should care
What makes Recall worth watching is not just that it adds memory to Claude Code. It is that it treats continuity as local, inspectable infrastructure.
As coding-agent workflows become more common, the repeated reconstruction cost around each session will matter more. Tools that reduce that cold-start tax without adding another cloud dependency or another billing surface will feel disproportionately valuable.
Recall points in a practical direction: keep the durable state near the project, use deterministic summaries where they are good enough, separate human instructions from machine-generated history, and make the artifacts readable. That is not a flashy demo. It is better than a flashy demo. It is a workflow somebody might actually keep using every day.