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
Engineering memorycurrent

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.

Files
queue/worker.py, queue/redis.py
Commit
7d8f1c3 · Recallium-Memory trailer
Read by
Claude Code, Codex, Cursor and every teammate's agent

An agent that finds the March decision also sees what replaced it. It stops suggesting locks.

How we dog-food Recallium →

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.

Current
memory that knows what changed

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.

Monday
handoffs that resume, not restart

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.

Every session
rules that are always there

“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.

6 months
commits that explain themselves

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.

By role
access by team, project and member

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.

OptionGood forWhere it stops
Built-in agent memoryCLAUDE.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 layersMem0 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 repositoryA 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.

500

memories a month on Free, until December 2026. Pro adds shared team memory.

60+

MCP clients, so the memory follows the team, not the tool.

99.8%

right memory on LongMemEval, the serving products' own benchmark, from 3.8 results per question. See the benchmarks.

1

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.

  1. Run the installer

    npx -y recallium install finds the coding agents on your machine and connects each one.

  2. Sign in once

    The installer shows its plan before it writes anything.

  3. 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.