Inspiration
As I've gotten older, I've noticed that my memory isn't always as sharp as it used to be. Remembering names, retaining information, and recalling details sometimes takes more effort than it once did. Rather than accepting those frustrations, I decided to do something about them.
The techniques that work are centuries old. Tie a name to something you can see on the face. Hang a list on numbered pegs. Turn a number into words you can picture. What makes them hard is building the pictures, and that is exactly where a language model is fast. It is also where a language model will quietly invent a word that only looks right, which is worse than having no cue at all.
So Recall is built on one rule: the models propose, and code decides.
What it does
Meet someone new, add their name and a photo, and Recall finds one feature on the face to hang the name on (it is instructed never to identify anyone) and builds a picture that ties a sound-alike of the name to that feature.
Anything else goes in the same box, typed or spoken: a list, an ordered routine, a passage, a PIN or a year. You can also describe what you want instead of citing it. Ask for "the verse about God loving the world" and Tavily search works out that you mean John 3:16; the wording is then fetched from a public-domain translation, never from the search result or the model.
Recall chooses a memory technique, writes one illustrated scene per item, and trains you on it: one item at a time, hints that count against your score, a schedule that counts back from the date you need it by, and, when you miss the same cue in two sessions running, a Repair Agent that diagnoses why and rewrites it under the same contract. Material that mixes kinds (groceries and a PIN, say) is split into parts, each with the technique that suits it.
How we built it
Every language-model call runs on NVIDIA Nemotron 3 Super (nvidia/nemotron-3-super-120b-a12b) through Nebius Token Factory, across seven agent roles: Memory Expert, Storyboard, Rules, Repair, Research, Language and Training. Image inspection also runs on Token Factory (zai-org/GLM-5.3-Flash). Images come from FLUX and speech from NVIDIA Parakeet on NVIDIA's hosted API. The Research Agent calls Tavily at runtime to find where material lives.
Three layers make the models propose and code decide:
- A contract per technique, checked by code. The source wording must survive exactly; Major-system words must decode back to the digits; every memory-palace cue needs its own place in route order; image prompts may contain no numerals, text or logos. A storyboard that breaks the contract goes back to the agent with the specific violation, at most three times.
- An image inspector that reports, not judges. A vision model returns a typed description of each picture; code applies the rules and asks for a targeted redraw when one is broken.
- A small self-hosted decision model with earned authority. It may decide only in the categories where its measured accuracy justifies it, and it cannot grant itself more.
The server is dependency-free Node.js with file storage, deployed on Railway from a Dockerfile.
Challenges we ran into
Models cheat on numbers. Before the contract existed, Recall encoded 1066 as "tooth, sausage, sheep, sheep", which decodes to the wrong digits. Code now computes real candidate words, decodes every word the model returns, and sends coinages back. The same year now comes back as "tea, sea, she, she".
A model disappeared overnight. On October 3, Nemotron 3 Super was retired from NVIDIA's own API with nothing but an HTTP 410 on every call. It is still served on Token Factory, so we moved there for good and added a catalog check that warns in the studio before a demo breaks.
Our decision model contradicts itself. Asked a question and then its opposite, it gives the same answer about three times in four. Instead of hiding that, we limited what it may decide on its own and published the numbers in docs/EVALUATION.md.
Accomplishments that we're proud of
You can check our claims without trusting us. The public evaluation page at /eval needs no login. It lists every storyboard and image the code refused, and why, plus every run of a live benchmark that any judge can start from the studio: five tasks drawn at random from our held-out test set, run through the full pipeline, scored by code beside our published numbers.
From that published evaluation:
- 0 wrong automatic technique picks across 17 held-out tasks
- 11 of 11 test requests produced a contract-compliant kit, 9 of them on the first attempt
- 18 of 18 correct verdicts from the image inspector on our labeled set
Every kit can also export an audit receipt: who chose the technique and why, the contract it was held to, and every refusal along the way.
What we learned
A model is most useful when the system around it knows exactly what it is allowed to decide. The checks that make Recall trustworthy are mostly a few lines of code each; the hard part was naming each rule precisely enough to write it.
The best use of AI isn't always doing something for people. Sometimes it's helping people do something better themselves.
What's next for Recall
- Measure it honestly. Track recall over weeks, not just within a session, and keep separating improvement on trained tasks from claims about memory in general.
- Everyday memory. Names, appointments and conversations, captured by voice in the moment.
- Mobile. Practice wherever you are.
- Lower cost and more privacy. Retrain the decision model on the corrections it collects, and run more of the pipeline on open models.
I started building Recall because I wanted to improve my own ability to remember. Now I want to build something that helps others remember what matters most.
Log in or sign up for Devpost to join the conversation.