Why Recallium
Your code remembers what changed. Recallium remembers why.
Recallium is engineering memory for your team: the record of why your software is the way it is, with the person, the files and the commit attached, shared with every engineer and every coding agent. Here is what that changes in the first week, and where the alternatives stop.
- Priced per engineer, not per request
- Claude Code, Codex, Cursor and 60+ MCP clients
- Store and recall in seconds
- 99.8% right memory on LongMemEval
Job queue moved from advisory locks to Redis Streams
WhyLocks were held through load spikes and nothing could replay a failed job. A second workers table was rejected: it would not survive a region failover.
ReplacedMarch: advisory locks on the jobs table. Kept on record, with the reason it changed.
An agent that finds the March decision also sees what replaced it. It stops suggesting locks.
Thursday, 4:40 PM. A ninety-minute bug.
With Recallium, a bug is found once: every later engineer and agent gets the fix, with the file it lives in. A webhook keeps shifting by a few hours, and it takes an engineer and an agent most of the afternoon to find out why. Here is what happens to those ninety minutes.
The payments provider sends UTC timestamps without the Z suffix. Parsed as local time, everything drifts by the local offset. You fix it, ship it, move on.
Six months later, in another repository, a teammate's agent meets the same provider. It parses the timestamps as local time, because nothing told it otherwise. Ninety minutes, again.
While you are still in the session, your agent records the root cause, the fix and the file it lives in, tied to the commit that shipped it.
You: How should I handle these webhook timestamps?
Agent: You hit this with the same provider six months ago: UTC strings, no 'Z'.
Here is the fix that worked, from payments/webhooks.py.A different repository, a different agent, a different teammate. The answer comes back with the file it came from.
A stale memory is more dangerous than a missing one. Recallium keeps the current answer, and what it replaced.
Five differences you will notice in the first week.
Recallium keeps the current decision, resumes a handoff where it stopped, loads the team's rules into every session, ties commits to the reasons behind them and scopes access by role. None of them is a bigger model or a longer context window. All of them are what a memory built for engineering does that a memory built for users never needed to.
Recallium marks the newer decision current and keeps the one it replaced. The team settles on advisory locks for the job queue; when it later moves the queue to Redis, agents stop suggesting locks.
Nothing is deleted: the old decision stays on record, with why it was replaced.
A half-finished migration lives in a workstream. Your agent, or a teammate's, opens it and picks up from the working state instead of re-reading the diff.
“Never edit generated files in src/gen” loads at the start of every session, in every connected tool, without anyone having to ask for it.
A Recallium-Memory: trailer ties a commit to the decision and the fix behind it, so “why is this here?” still has an answer long after everyone forgot.
On Recallium Cloud, teams and role-based access are built in: the server decides who reads a repository's memory, not a naming convention on a shared key.
The alternatives, fairly.
The alternatives are the memory files built into each agent, a general memory layer, and a decisions file in the repository. Each is real, and each is the right tool for something. Here is where each one stops.
| Option | Good for | Where it stops |
|---|---|---|
| Built-in agent memory | CLAUDE.md, AGENTS.md, Cursor Rules and Claude Code's auto memory are free and already there. Keep them for standing instructions. | They hold what someone wrote down, or what one agent noticed on one machine, and load whole into every session. Not shared across teammates or tools. See Claude Code, Codex and Cursor. |
| General memory layers | Mem0 and Supermemory ship real Claude Code and Cursor plugins with personal and project memory, and they work for coding. | What they store is facts extracted into a general-purpose model, and team isolation starts at $249 a month (Mem0 Pro) or $399 a month (Supermemory Scale), as of October 2026. See Mem0 alternatives and Supermemory alternatives. |
| A notes file in the repository | A shared DECISIONS.md costs nothing and needs no setup. | It works until the second teammate: nobody updates it in the middle of a fix, it conflicts on merge, and every agent loads all of it. |
Priced per engineer, ready in seconds.
Recallium Cloud is priced per engineer, because that is who the memory serves. There is no daylight between saving a memory and recalling it: the engine processes each one as it lands, so what one agent works out, the next agent finds right away.
memories a month on Free, until December 2026. Pro adds shared team memory.
MCP clients, so the memory follows the team, not the tool.
right memory on LongMemEval, the serving products' own benchmark, from 3.8 results per question. See the benchmarks.
engineer is the unit of price. Teams, Insights and role-based access are part of Recallium Cloud. See pricing.
Try it on your own repository.
Join the waitlist for Recallium Cloud, or use your pilot code to start now. The serving vs engineering split is on What is engineering memory?; side-by-side tables are on Comparisons.
- Run the installer
npx -y recallium installfinds the coding agents on your machine and connects each one. - Sign in once
The installer shows its plan before it writes anything.
- Work as usual
Recallium names the project after the repository and loads its context at the start of each session.
Your code remembers what changed. Recallium remembers why.
