Memory that
runs itself.
Your AI remembers the work. The decisions, the reasoning, and the fix you found last time.
Mention the topic and Total Recall brings back the relevant context automatically, even in a brand-new chat.
Codex
I’m reopening our annual pricing proposal.
We kept monthly plans because buyers couldn’t approve an annual commitment before the pilot. I’ll carry that constraint into the proposal.
Past reasoning surfaced automatically
Memory that
Your agent forgets.
Your work shouldn’t.
The proposal shape that worked. The customer constraint that changed the plan. The operating decision that explained everything. Useful history stops being usable when the next conversation starts.
The right context.
The moment it matters.
It knows what to keep and what to intelligently forget until it’s needed again. Your agent gets the slice that matters, not the whole archive sitting in the prompt all day.
Keep talking.
It remembers.
Install once, then keep talking to your agent the way you already do. Research, writing, planning, code, and everything in between.
A new session
Your AI agent
Your AI agentDraft next week’s content plan using the direction we agreed on.
Total Recall · 3 earlier conversations
We agreed on implementation stories, the workflow objection buyers raised, and two posts next week. The launch announcement stays on hold.
Scroll to continue
One memory. Across your tools.
Claude CodeNative integrationCodexNative integration
HermesNative integration
DevinNative integration
DroidNative integration
Claude CoworkNative integration
KimiSession capture
MCPConnect your clientNative integrations pick up your sessions on their own, with nothing to configure. MCP gives any connected tool access to the same memory.
Same question.
A very different starting point.
Mention the work. Your agent finds the relevant past conversations, decisions and fixes on its own. You get to move forward.
Without memory
Annual pricing proposalNew conversation
ClaudeTry the next message
With Total Recall
Annual pricing proposalNew conversation
ClaudeTry the next message
No Recall command. No pasted history.
Select a message to continue the example. Explore examples measured on real sessions →
Keep the decision.
Carry the reasoning.
The plan, the reason behind it, and what happened next. Recall carries that context into your next conversation, whichever agent you use.
ClaudeMonday · Find the directionThe interviews keep pointing to data import. Let’s fix onboarding first. Keep the dashboard as it is.
Agreed. Guided CSV import first. The dashboard stays unchanged.
Decision remembered automatically
CodexWednesday · Build on itBuild the onboarding flow we agreed on.
Picking up your decision in Claude: guided CSV import, same dashboard.
01
Validate the columns.
02
Preview before importing.
03
Fix errors before writing data.
Recalled from Claude · Monday
HermesFriday · Tell the storyWrite the release note from what we built.
A smoother first import.
Preview your CSV, check the columns, and fix errors before they reach your workspace. Your dashboard stays familiar.
Claude’s decision + Codex’s implementation
Scroll to follow the same work
Where memory comes from
Live context
Past sessions
Knowledge you connect
Live context, past sessions, and the knowledge you connect.
Your agent recalls from three places at once: the conversation you are in, everything you have already worked through, and the sources you choose to bring in.
What you are working on right now shapes what gets recalled, so memory stays relevant to the task in front of you.
Decisions, reasoning, and fixes from earlier work with any of your agents come back when the topic returns.
Point it at a folder, add a document, a PDF, or a book, and it is ingested and searchable right next to your own work.
See the work, the decisions, and the story behind it.
Search across sessions, projects, people, decisions, and turning points. Browse the actual work history with its context intact, not a pile of disconnected summaries.
Benchmarked where persistent memory either works or it doesn’t.
These benchmarks measure whether Total Recall recovers the right history and helps an agent answer correctly across months of past work.
98.0%
LongMemEval E2E
500 questions, gpt-5.4 judged answers. 490/500 correct.
97.73%
LME Recall@10
Retrieval-only, deterministic. Zero LLM at search time.
91.17%
LoCoMo Recall@10
Categories 1-4, 1,536 questions, retrieval-only.
How Total Recall stacks up.
Public benchmark results plus the product differences that matter most in practice.
| System | LME E2E | LME Recall@10 | LoCoMo | Local-first | LLM at retrieval |
|---|---|---|---|---|---|
| Total RecallLeading | 98.0% GPT-5.4, judged answers |
97.73% LME-500, retrieval-only |
91.17% Recall@10, cat 1-4 / 1,536q |
Yes | No |
| Mastra OM | 94.87% gpt-5-mini |
Not published | Not published | Not the core story | LLM in memory formation |
| Hindsight | 91.40% gemini-3-pro-preview |
Not published | Not published | Self-hostable | Mixed system |
| Zep | 71.20% gpt-4o |
Not published | Not published | Mostly cloud | Varies |
Real work, minus the re-explaining.
Whatever you point your agent at, Total Recall hands back the past work instead of making you rebuild it from scratch. Four kinds of work, one less blank page every time.
94.5% fewer tokens
Catch me up on this branch. Where it stands, what changed and why, and the exact step you had planned next.
96.2% fewer tokensEverything I’ve found, in one brief. Every scattered session and doc on the topic, pulled into a single picture.
95.9% fewer tokensDraft it from what I shipped. The real material of the work, handed over so you start from something, not a blank page.
96.6% fewer tokensThe picture of everything this week. What moved, what stalled, and what needs you, across everything you are running.
Memory that learns and grows with you.
The point is not to hoard random details. The point is to recover the narrative: what changed, why it changed, what worked, what kept breaking, and which pattern matters right now.
Reconnect the arc
Pull back the real sequence of events: what started the problem, what you tried first, what changed the direction, and why the final decision made sense.
Recover the reasoning
Bring back the tradeoffs, constraints, and judgment behind the decision, not just the final line item that ended up in a document or code diff.
Connect the dots
Spot recurring bugs, repeated objections, familiar decision shapes, and the patterns that let the agent act with context instead of improvising from scratch.
It fits the way you already work.
Total Recall is built so you do not have to contort your workflow around the memory system. The memory system adapts to the way you and your agent already operate.
Memory stays out of the live prompt until it is needed. No permanent context bloat.
Search happens locally, so the memory layer stays fast, private, and cheap to run.
The agent can surface relevant past work on its own instead of waiting for the perfect command.
Small footprint, low latency, and a setup that does not ask you to adopt a brand new ritual just to get memory.
It starts with memory, and grows into intelligence.
Session recall is the foundation. The broader direction is a system that compounds recurring patterns, durable know-how, and practical judgment across real work without turning into a junk drawer.
Remember the pattern
Not just “we discussed this,” but “this is the bug that usually appears after that change.”
Keep what compounds
Not every detail should live forever. The system should preserve the patterns and judgment that keep paying off, while letting noise fade.
Know when it matters
Not just searchable memory, but proactive memory that surfaces the right pattern, context, or decision when the work makes it relevant.
Total Recall, in the wild.
Walkthroughs and reviews of the memory layer in real use.
If you already use AI agents for real work, you should not have to start over every session.
Total Recall is built for that exact frustration: not the absence of information, but the absence of usable memory. Keep working the way you already do. Let the memory layer catch up.
Native integrations, plus MCP access
Ask normal questions in the agent you already use and memory kicks in when it matters.
Local, proactive, lightweight
Zero LLM calls at retrieval time, low latency, and a footprint small enough to stay practical.
Benchmarked, not hand-waved
97.73% Recall@10 (LME-500, retrieval-only) and 98.0% end-to-end judged answer accuracy on LongMemEval with GPT-5.4, plus 91.17% Recall@10 on LoCoMo (cat 1-4 / 1,536q, retrieval-only).
Up and running, then it just remembers.
What it takes to start, how the memory works, and where it fits.
Answer
How do I use Total Recall?
Install it once, on macOS it is a double-click, then keep talking to your agent the way you already do. Ask in plain language, like “what did we decide about pricing?” or “find the auth bug from last week,” or use the
/recall command. There is no new workflow to learn. The memory layer works underneath the one you already have.Does Total Recall support MCP?
Yes. MCP lets connected tools access Total Recall memory. Claude Code, Codex, Hermes, Devin, Droid, and Claude Cowork also have native integrations that pick up your sessions on their own, and Kimi sessions are captured too.
How do I make it remember?
You do not have to. Total Recall captures your work automatically as you go, both your decisions and your agent’s reasoning, so there is nothing to file, tag, or maintain. When you want to pin a durable fact, say “remember that…” and it sticks. Recall is just as hands-off: your agent surfaces the right past context on its own, often before you think to ask. Knowledge that lives outside your sessions can join in too: connect a folder or add a document and it becomes part of what your agent can recall.
How is it different from other AI memory tools?
Most memory tools keep an indexed store in the cloud that you pay to carry and prompt to maintain. Total Recall runs fully on your machine with zero LLM calls at search time, so retrieval is deterministic, private, and free at rest. It is proactive, with no manual save calls, and one memory is shared across your agents, so one agent can pick up what you decided with another.
How is it different from a second brain or knowledge base?
A knowledge base is something you maintain: you file notes, then go read them. Total Recall captures the actual work as it happens, the sessions, decisions, files, and recurring patterns, and feeds the right piece back to your agent in the moment. You are not curating a library. And when you do have sources worth keeping, point Total Recall at a folder, add a document, a PDF, or a book, and it is ingested and searchable alongside your work. The memory does the remembering, and the recall, for you.
Is it only for coding?
No. Total Recall works for any work you point an agent at: marketing, research, writing, planning, client work, and coding. It remembers the thinking and the decisions behind the work, and every kind of work has those.
What are the common use cases?
Catching up on a project after days away, recovering why a past decision was made, pulling everything you know on a topic into one brief, and drafting an update from what shipped. See the use cases for engineering, research, writing, and operations examples, each with measured token savings.
Is my data private?
Yes. Total Recall is fully local. Your conversations and memory never leave your machine, and nothing is uploaded. Search runs on your machine too, so the memory layer stays fast, private, and cheap to run.
How much does it cost?
Nothing, for now. Total Recall is free during the public beta, for everyone. Pricing comes later, and the plan is a generous free tier that stays free.
Keep what you learned.Pick up where you left off.
The decisions. The reasons. The fixes that worked.
Your next conversation can start with all of that.