DEV Community

Cover image for A free memory layer for your agents, and why you still don't know you need it
Giulio D'Erme
Giulio D'Erme

Posted on

A free memory layer for your agents, and why you still don't know you need it

No install needed to try it: ask the beta chatbot on re-call.dev. It runs on RE-call.

Your agent learns something every session. A fix that worked. A rule you gave it. A trap it fell into.

Then the session ends, and all of it is gone.

The next session starts from zero. It repeats the diagnosis. It falls into the same trap. You explain the same rule again.

Nothing breaks loudly, so you never see the bill. The work is just slower, and it carries more mistakes.

In August my CLAUDE.md and MEMORY.md together held 17,499 characters. The memory folder behind them held 636,191, in 185 files. That is 36 to 1. Claude Code loads the first 200 lines of MEMORY.md at start-up. Most of what my agents had learned sat outside what they read.

RE-call is a memory layer for that work. It saves what agents learn, finds it the moment the work needs it, and abstains when it has nothing. Version 0.16.0 runs completely free.

Two commands, zero spend

python -m pip install "recall-rag[fastembed,mcp]>=0.16.0"
recall setup --lite --memory ./notes
Enter fullscreen mode Exit fullscreen mode

Point it at a folder of Markdown notes. Restart your agent. Ask it something your notes answer. It needs Python 3.11.5 or newer.

What you get:

  • SQLite on your disk. No Docker, no database server.
  • A local embedder (BAAI/bge-small-en-v1.5). It downloads once, then runs on your CPU.
  • No API key. No account.
  • No LLM call to store a memory, build the graph or search.
  • AGPL-3.0. All of it is on GitHub.

Your agent is the only LLM in the loop. The memory layer spends nothing.

What runs under it

Hybrid rank fusion. Every search runs two ways: dense vectors and full-text search. Reciprocal rank fusion merges the two lists. The exact error code and the fuzzy description of a failure both find the same memo.

Atomic rescue. Sometimes the answer is one sentence buried in a long memo. RE-call cuts each chunk into short 24 word views and embeds them locally. When one view matches the query closely, its memo moves up. At most one memo, and only in rank. It can never turn an abstention into an answer. In 0.16.0 it is on from the first install.

Semantic graph. RE-call reads what your memos already state: links, supersedes:, depends_on, headings. It builds a graph from them with no model. The dashboard draws it, so you can follow which memo replaced which.

Trust layer. It calibrates a threshold on your own store. Below it, search abstains instead of handing back the nearest note. A memo that declares supersedes: outranks the one it replaces. An expired memo comes back flagged. On Lite, forget zeroes the deleted bytes in the file.

Every search returns a verdict: trusted, degraded or abstained. With the reason.

Why you need it

1. Fewer errors

I measured it. Claude Code with Haiku 4.5, four trap tasks, 40 paired runs. Each fix lived only in memory, never in CLAUDE.md.

  • CLAUDE.md alone: the agent fell into the trap 21 times in 40.
  • The same CLAUDE.md plus RE-call: 0 times in 40.

One trap: onnxruntime ignores OMP_NUM_THREADS. Without memory, the agent fell for it 9 times in 10.

Stale notes cause errors too. They are often the closest match, and similarity search serves them with confidence. I asked whether release 0.12.0 included the Codex integration. The closest hit was the preparation memo. RE-call marked it superseded, named its successor and cited the published release record instead.

And when memory has nothing:

How does the Kubernetes operator autoscale the GPU inference pods?

abstained: true. Reason: probable corpus gap. Nothing to cite, so nothing to invent from.

2. Faster work

A background test run once reported "completed, exit 0" with empty output. It was still running. I trusted it, launched a second run, and two suites hit one database. That cost me about 40 minutes and a contaminated run.

I saved the lesson. The third time it happened, it cost nothing.

Another one. I asked my memory about a symptom only:

my long background job on the server died when I closed the SSH session, even though I started it with nohup and &

It returned the fix that worked (setsid), a second case of the same failure, and the neighbouring failure where setsid does not help. No re-diagnosis.

3. Shorter instruction files

CLAUDE.md and AGENTS.md load in full, every session. So they grow. Then they rot.

Keep the standing rules there. Move the project history into memory. The agent searches it when it becomes relevant.

Do not delete the file, though. In the same study, replacing CLAUDE.md with retrieval changed nothing. Adding retrieval next to it is what worked.

4. One memory for every agent

I run Claude Code and Codex on the same projects. Without shared memory, each one starts blind to what the other learned.

On Lite, every client on the machine reads and writes the same store. Writes wait in a queue.

One example from the site. Claude Code saves two rules: the reporting week starts on Thursday, and refunds count against the original sale's week. A fresh Codex session searches memory before building the weekly report. All 45 tests pass, refunds included.

Another one. Codex saves why an export uses pipe separators. Later, Hermes finds that memo and puts the reason in a client briefing.

One agent can also retire another agent's memo. supersedes: now accepts a memo from another agent's folder.

recall setup --lite wires Claude Code in one run: server, hooks and skills. When it finds Codex, Codex gets the same. OpenCode and Hermes have their own guides.

Try it in under a minute

The site has a starter kit of 25 sample notes. It reproduces a cited answer, a superseded memo and an abstention on Lite 0.16.0.

Two notes before you start. A folder too small to calibrate refuses trusted answers until it grows. And the first atomic rescue build takes time on a large folder, because it embeds about ten views per chunk.

Limits

Abstention works on far gaps. On near misses it often fails. The trap study used four traps and one model, on my PostgreSQL store rather than Lite. A separate task success study found no overall uplift. Every number and its limit is in EVIDENCE.md.

Tell me what you think

I would like your comments and feedback, positive or negative. What worked, what broke, what confused you. Leave a comment here or open an issue.

If you have only a minute: point it at your own MEMORY.md folder and tell me where it abstained when it should have answered.

GitHub · Site and videos · Lite guide · PyPI

This post was written with AI assistance. I reviewed and edited it before publishing.

Top comments (0)