Your code remembers what changed. Recallium remembers why.

Institutional engineering memory for humans and AI agents.

Recallium preserves the decisions, designs, fixes, constraints, rules and working context behind your software, so engineers and AI agents in Claude Code, Codex, Cursor and 60+ tools start from what your team already knows.

15k+developers building
with Recallium
99.8%right memory found
on LongMemEval →
Claude Code
Ask your agent anything…⏎ send
The problem

Your engineering organization forgets every day.

An engineer and an agent spend two hours on a production issue. They learn why an architecture decision exists, find a hidden constraint, reject two tempting fixes and land the safe one. The code keeps the implementation. The judgment usually leaves with the session.

GitWhat changed
TicketsWhat was assigned
ChatWhat was discussed
DocsWhat somebody took the time to write down
Agent chatWhat fit in that one session
RecalliumWhy the system is the way it is: the decision, the alternatives it beat, the constraint that forced it, and what replaced it later.

Engineering judgment should not disappear when the conversation ends.

Judgment

Git says what. Recallium says why.

A commit tells an agent that authentication changed. Recallium tells it why the team changed it, which alternatives were rejected, which constraint drove the call, and what earlier decision it replaced.

What Git keeps
commit 7d8f1c3
Rotate auth tokens; drop the 30-day JWT expiry
src/auth/token-manager.ts+184 −62
What Recallium keeps
decisionauth-hardening
Move from long-lived JWTs to rotating refresh tokens
Why
The security review found a replay risk in a leaked 30-day token.
Rejected
Shorter-lived JWTs on their own: mobile sessions would drop every hour.
Constraint
Mobile clients must tolerate 24 hours offline.
Replaces
The March token decision, still on record.
src/auth/token-manager.tscommit 7d8f1c3Priya · security-review-2026

Your agents shouldn't follow yesterday's decision.

Engineering knowledge evolves. Recallium keeps the full history and makes the current decision explicit, so an agent that finds the March call also sees what replaced it and why. A stale memory is more dangerous than a missing one.

  1. MarchUse long-lived JWTs with a 30-day expiryreplaced · still on record
  2. SeptemberUse rotating refresh tokensReason: the security model changed · commit 7d8f1c3current
Continuity Recallium Pro · Coming soon

What one agent learns, your whole team knows.

Session to session, engineer to engineer, agent to agent, repository to repository. Pro turns what one developer's agent works out into what every teammate's agent starts from, and the knowledge stays with the team when people move on.

Backend devFrontend devClaude CodeCursorCodexone team memory

The week, in one recap

Every teammate's decisions and fixes across projects, with names attached. Read it instead of calling a status meeting.

Personal until you share it

Keep drafts private, then promote a memory or a whole project to the team when it is ready.

Ask what a teammate decided

“What did Sam decide about auth?” Search by author and get their reasoning, not a Slack archaeology dig.

Knowledge stays when people move on

Shared memory belongs to the team. Hand off a project or an on-call shift with its full history attached.

How it works

Models come and go. Institutional memory stays.

Connect once over MCP. Use Claude Code today, Codex tomorrow, a private model where required: Recallium is not Claude's memory, Codex's memory or Cursor's memory. It is your team's, every tool is a client of it, and your engineering knowledge is never trapped inside one vendor's conversation history.

  1. 01
    Connect onceOne MCP endpoint in Claude, Cursor, Codex, VS Code and 60+ clients. Nothing to install.
  2. 02
    Work as usualDecisions, fixes and patterns are captured as your agents work, with files and reasoning attached.
  3. 03
    Every agent remembersAny agent, in any tool, starts from what the team already knows.
Trust

Your engineering memory belongs to you.

  • We do not train AI models on your memories. We do not sell your data. Period.
  • Sharing follows the repository. A memory stays personal until you share it with the team.
  • Teams and role-based access on Recallium Cloud: the server decides who reads a project's memory.
  • Memory you can inspect, not a black box: see what each project holds and how it connects.
Security and trust →
Economics

Engineering memory should be ubiquitous, not expensive.

Persistent context should not be rationed by query, repository or conversation. One agent reads the code and records what it learned; every teammate's agent gets it back in one search instead of re-reading the files, so the team pays for those tokens once.

3.8results per question on average, not hundreds, on LongMemEval-S
9×less for an agent to read before it starts, compared with pasting the files
Per engineernot per query, retrieval or token, because that is who the memory serves
See pricing →

Never make your team relearn what it already knows.

Engineering memory that survives sessions, repositories, people and AI tools. Start free on your own, bring the team onto Pro when you are ready. Recallium Cloud is in a closed pilot; join the waitlist for general availability.

Plans
FreeFor the solo developer · 250 500 memories a month until December 2026
ProFor teams · 5,000 memories a month, unlimited repos
See plans →