I think everyone's ended up building one of these for themselves. I did too[0]. In the end it's quite easy these days:

* I use the bge-en-base CPU embedding model

* I put storage behind a simple endpoint that has read,write,update,search semantics

* The endpoint just stores markdown in an S3 like structure (bucket-key-value; tree structure is inferred) and vector indexes

* The actual persistence is just SQLite

Most modern models are pretty good at handling this. Our home agents (voice and text) use this to store information and I also have skills for claude code and codex to do that as well. Overall, works quite well.

I still use MEMORY.md for the home agents to keep short-term memory, and use the KB for long-term memory. You do need a self-reflection/consolidation/dream step in order to periodically consolidate and groom the KB but that's also just another job.

The whole setup is pretty trivial and what anyone would come up with from scratch and it's surprising that it works but it does. I'm a pretty good documenter so it helps. In some future perhaps a vision model could see all the things I'm doing and remember, but for now I just tell it and it's pretty good about everything I want.

0: https://wiki.roshangeorge.dev/w/Blog/2026-07-01/The_Everythi...

I can't even get my agents to properly read the memories they have saved locally let alone remotely.

I like that this stays local instead of depending on a hosted service. One thing I've noticed while building LLM applications is that memory becomes much more valuable when it's easy to inspect and edit manually. Are you planning to support semantic search later, or is the goal to keep everything deterministic and text-based?

Does memory for AI agents basically mean -

- Save everything to disk. Index it or store in vectorDB. - Search the storage for similarity based on the new prompt - include any finding with the new prompt as system/user prompt (or if you find the exact answer skip the llm call)

?

Or is there more to it ?

Still waiting for the agentic memory system for the local Mainframe emulator DB2 instance.

Similar to https://ctx.rs/ and others, I'm sure.

I'd lead with your differentiation. Is it the ssh?

Hi HN. I built deja after watching Claude Code and Codex debug the same problems more than once.

The annoying thing was that the answer usually already existed somewhere in my old sessions. My records were stored on the disk for months (~3.3 GB). It wasn't easy to find them manually and the new agent session had no idea what the other agent had already found out.

deja indexes the transcripts that Claude Code, Codex, and opencode already write. On my corpus, the initial index takes about 10 seconds and warm searches are 7-9 ms.

There are 3 ways to get the memory back: a normal CLI search, an MCP tool (agent can query it directly) and a SessionStart hook that automatically injects a bit of relevant project context.

The feature I built this for:

deja sync ssh <host>

It moves new memory between machines using the existing SSH setup. Secret data is deleted during indexing and checked again before exporting.

My setup is a laptop and a mac mini without an interface. The agent can work on the mini all night, and in the morning I extract its memory. Then the agent on my laptop will know what the mini tried, what broke, and what eventually worked.

There are other projects (cass, ctx, claude-mem):

https://github.com/Dicklesworthstone/coding_agent_session_se...

https://github.com/ctxrs/ctx

https://github.com/thedotmack/claude-mem

I wanted deja to intentionally use a small approach: one binary code with zero dependency, no LLM calls, searchable verbatim text instead of generated summaries, and synchronization via your own SSH. It does not implement its own network transport; it just connects to the system ssh/scp.

You can install it via curl, brew, npx or go install, then run:

deja install --all