I built Total Recall because I was tired of agents that forget. Every new session started from zero, and I kept retelling the same story to a very smart assistant with no memory. So when Tom Granot, who builds AI go-to-market systems for clients and reviews AI tools on his channel SyntaxGTM, reviewed Total Recall, I got a case study of the exact problem it was built for.
Tom's normal day runs on 15 to 25 terminal sessions at once (each one a separate agent working on something), spread across 7 to 10 projects he keeps moving in parallel. By his own account, he can't remember what he told an agent two hours ago, "not to mention 3 days ago." With that many agents running, forgetting grows from an annoyance into the bottleneck, which makes him a good test of whether a memory layer actually takes the job off your plate. To see why, it helps to start with what exactly gets forgotten.
The stuff that never makes it into the code
Working with AI agents produces two kinds of output. The first is the work itself, the code in a repository, with commits that record every change. Engineers have looked after that layer for decades. Everything you told the agents along the way is the other kind: the reasons, the trade-offs, the "no, do it this way." And that layer usually ends up buried in chat sessions nobody opens again.
Tom calls the second part "this little human layer we put on top of the agent work," meaning your thoughts, your decisions, your permissions and your directions. It's the most valuable thing you give an agent, because it carries your judgment. Yet it's also the first thing to disappear, from the agent's memory and from yours.
Skills show the gap best. A skill is packaged expertise, a method you saved once so any agent can follow it again, and Tom has a lot of them. Take his old YouTube upload skill. He knew what it looked like today, and he could read its commits. But the sessions where he built it, and the reasons behind each change, were gone. Total Recall keeps that human layer within reach, so a thought you had three months ago is still there when you need it. In his words, that's "super powerful."
Plenty of tools promise memory, though, so the next question was which kind he actually wanted.
"Overkill for me"
Tom looked at the alternatives before settling on a memory tool, and he gave each one a fair hearing. Mem0 is the biggest name in the space, "the current major player," though it's now VC-funded, which he admits "immediately makes me suspicious." Beads is the well-known open-source option, early to the game. Letta goes much further and offers a whole platform for giving agents state, a running record of what they know. For Tom, that was too much machinery.
Overkill for me. I just wanted something that does retrieval well and doesn't bother me along the way.
Retrieval means finding the right piece of past work at the moment you need it. And "doesn't bother me" is exactly how Tom uses Total Recall, because he barely touches it. His agents use it all the time, pulling back what they need from other sessions on their own. While he was recording the review, a browser window popped open on the side. One of his agents was testing something with Total Recall in the middle of its own work. "I swear I didn't plan it," he said.
The most powerful thing about Total Recall is that I don't think about Total Recall. It just works on the back end.
A memory you never think about still has to prove itself the moment you need it, and for Tom that moment usually comes when he needs the history of something.
A git log for a very disorganized guy
Tom builds little AI go-to-market machines for clients, several small systems that work together, and every week or month he sends each client a list of everything he did for them. But by his own description he's "very disorganized." Not everything lives in a GitHub repository, and he doesn't always save proper commits.
So he asks Total Recall to summarize, line by line and with dates, the changes he made to a skill over time. Total Recall goes through his sessions and hands back the history "in kind of like a git log manner," the neat, dated list engineers usually get only from their code history. And the log covered his sessions regardless of which agent he'd worked with. Tom moves between several agents, Claude and Codex among them, so a memory tied to one of them would only ever show him part of his own work. Total Recall is one brain for all of them, which means Codex remembers what Claude decided and why.
Old projects come back the same way. When he asked how he uploads videos to YouTube, Total Recall found a session from about three months earlier where he built the Google Drive upload, the later update where he added Auphonic for the audio, and the day he archived the old skill and folded it into a new one, all in order from earliest to latest. He had never told Total Recall anything about that skill, so everything it knew came from the work itself.
Total Recall will tell you step-by-step exactly how you worked on a thing over time.
It also rescues things you made and forgot. At the end of a long session, Tom often asks his agent to turn the flow into a skill so he can reuse it, and then forgets the skill exists. Total Recall catches a lot of those and uses them without being told. Sometimes, though, he wants to find them himself, and that's where the way he asks starts to matter.
One vague question, ten searches
People rarely ask for things precisely, so a memory has to cope with vague questions. Tom tested exactly that with "Can you recall the latest three skills that I worked on?" He called it "a very vague question" himself, since it could mean skills he built or skills he only used once in some session.
Total Recall started with one broad search, then ran several more at the same time. Tom counted them on screen and got to ten queries, each one narrowing in, going "deeper and deeper into niches," until it found the exact sessions and summarized them. Back came his Agent Mail work, a new secret project, and a sponsor CRM skill he built to handle the five to ten sponsor requests he gets a day. He'd never told it a single thing about that last one.
In practice, that means you don't need the right keyword, or even a memory of the session itself. You ask the way you'd ask a colleague who was in the room, and the digging is its job. That matters most on the days when Tom has been away from a project for hours.
The knowledge is always there
Agents have changed the shape of Tom's day. He gives an agent a very direct plan, lets it work for a long stretch, and comes back later to review what it did. A day might be 9:00 to 11:00 in the morning with an agent, nothing in the middle, then back at 11:00 at night until 1:00. Many of his agents keep working overnight on other machines. So every return to a project is a cold start, unless something kept the thread.
Whenever I come back to a project, the knowledge is always there. I never have to remember anything.
Coming back now means asking Total Recall what he thought or said about a project and where it stands, then going straight back in. Even when a session died, or he restarted the computer for an update, everything was still there, "which is super cool."
Total Recall has a visual side too, and Tom was honest about how little he uses it. Its dashboard shows all his sessions, an operations tab, plenty of settings, and activity stats in a GitHub green-dot style. He has opened it about twice, because he runs everything from the terminal. He hasn't tried the knowledge feature yet either, which connects a folder of documents so things you never discussed in a session become part of what Total Recall knows. And his advice matches how I designed it. The dashboard is there if you want to search and see the metrics, but the best way to use Total Recall is to let it work behind your agents and stop thinking about it. That idea, tools you never have to operate, is also where Tom ended his review.
Logs that are just there
Tom found Total Recall through Token Optimizer, my tool for cutting wasted tokens across your agents, which has since grown to 30,000+ users. He closed with a comparison from his own career. He spent years at Lightrun, an observability company (its tools show what software is doing while it runs). What he valued there was that the logs were simply there when you needed them, even if you hadn't set them up in advance. He sees the same idea in my tools, infrastructure for the average practitioner, "meant for silent consumption."
It's silent, it's reliable, it works in the background.
Tom also called me obsessed with developer experience, and he's right, with one addition. I care about the agent's user experience just as much, because the agents are the ones using Total Recall all day. So I ask them directly: "Hey, so how was it for you just now, using Total Recall? What was good, what was missing, what would make your experience better?" Their answers shape what I build next.
Memory that stays out of the way
Once a memory layer really works, the biggest change is that you stop being the one who remembers. That's what Tom's review comes down to. You don't decide in advance what to log, you don't maintain a folder of notes, and three months later the reason behind a decision is still one question away, from whichever agent you happen to be talking to. For me, that same memory and context layer is what lets my agents run longer tasks and more intricate loops, with me stepping in only when my opinion is truly needed.
It's also how we build for go-to-market teams at 10x Company, where the context runs underneath the work instead of becoming one more thing people maintain. Tom's 25 terminals were the stress test, and his memory is no longer the bottleneck.
Key moments
- 00:00Up to 25 terminal sessions across 7 to 10 projects, and no memory of what he told an agent 2 hours ago.
- 00:52Mem0, Beads and Letta, with Letta "overkill" for someone who wants retrieval that stays out of the way.
- 02:04Mid-recording, one of his agents opens a browser and tests something with Total Recall on its own.
- 04:22The YouTube skill's history, rebuilt from sessions about 3 months old, earliest to latest.
- 06:08A dated, git-log style client work log, no proper commits needed.
- 09:49One vague question becomes ten queries that drill down to the exact sessions.
- 14:07The Lightrun story: logs that were just there when you needed them.
Alex Greenshpun is an AI strategist and builder and co-founder of 10x Company. She builds Total Recall, Token Optimizer and Outsourcerer.
