Total RecallAdapts to the way you work.
Install once, then keep talking to your agent the way you already do.
An intelligence layer for AI agents
Total Recall. Persistent agent memory that learns like you do.
Give your AI agents durable memory for real work.
You keep working as you do. But now, your agent remembers the context, decisions, patterns, and past work even when a session ends.
Fully local and token-efficient.
No LLM calls at search time. No giant memory dump sitting in the prompt all day.
Leading benchmark scores.
97.4% Recall@10 and 98.0% end-to-end on LongMemEval.
The Problem
Your AI agent forgets everything the moment a session ends.
You figure something out with an AI agent once, then spend time rediscovering it later. The proposal shape that worked. The bug pattern that always comes back. The customer constraint that changed the plan. The operating decision that explained everything.
The issue is not lack of information. The issue is that useful history stops being usable right when the next conversation starts.
Without Total Recall
Q2 content strategygone
Auth token debugginggone
Client proposal reasoninggone
Onboarding flow redesigngone
You start over every time.
With Total Recall
Q2 content strategysearchable
Auth token debuggingsearchable
Client proposal reasoningsearchable
Onboarding flow redesignsearchable
“what did we decide about content strategy?”
Found 4 sessions. Pivoted to implementation stories, kept the pricing notes and customer constraints attached.
Benchmarks
Benchmarked where persistent memory either works or it doesn't.
These are not decorative metrics. They measure whether the system can recover the right history and support correct final answers under long-horizon memory conditions.
Deterministic, reproducible retrieval from the local index. No LLM is used to search for the right session.
Strong conversational-memory performance on a second public benchmark for long-dialogue reasoning. Measured on an earlier Total Recall version, like the end-to-end LongMemEval number.
Zero LLM calls at retrieval time. Memory stays local, lightweight, and out of the prompt until it matters.
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 |
97.4% deterministic, no LLM retrieval |
87.3% J-Score, earlier version |
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 |
Best fit for cross-session memory
97.4%Recall@10
98.0%End-to-end
LongMemEval is the clearest external benchmark for the Total Recall use case: recovering relevant history from many prior sessions and supporting correct answers across that history.
•Retrieval measured separately from answering
•Deterministic local retrieval, no LLM search layer
•Stresses temporal reasoning, knowledge updates, and multi-session synthesis
Useful second lens for long dialogue
89.1%Recall@10
87.3%J-Score
LoCoMo focuses on long conversations rather than many separate sessions. It is useful because it shows how the system behaves under long-dialogue retrieval and answer-faithfulness pressure.
•Strong complement to LongMemEval, not a substitute for it
•Helps show conversational memory quality under long histories
•Published Total Recall result comes from an older snapshot than the LongMemEval result above
Use Cases
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.
Engineering
Catch me up on this branch
Where it stands, what changed and why, and the exact step you had planned next.
94.5% fewer tokens read
See the recall →
Research & Analysis
Everything I've found, in one brief
Every scattered session and doc on the topic, pulled into a single picture.
96.2% fewer tokens read
See the recall →
Writing & Content
Draft it from what I shipped
The real material of the work, handed over so you start from something, not a blank page.
95.9% fewer tokens read
See the recall →
Operations
The picture of everything this week
What moved, what stalled, and what needs you, across everything you are running.
96.6% fewer tokens read
See the recall →
What It Understands Over Time
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.
Dashboard
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.
The dashboard makes the memory layer inspectable, searchable, reusable, and grounded in the real narrative of the work.
Why It Fits
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.
Beyond Recall
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.
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.
Works with your existing workflow
No special ritual required. Ask normal questions and let the agent use memory 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.4% Recall@10 and 98.0% end-to-end on LongMemEval with GPT-5.4, plus strong LoCoMo results.
FAQ
Up and running, then it just remembers.
What it takes to start, how the memory works, and where it fits.
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.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.
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. 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.