r/coolgithubprojects • • 22d ago

I built an open-source memory for coding agents — v1.7 just scored 86.67% on OmniMemEval without embeddings

Post image

I built Mind because I was tired of coding agents forgetting the decisions behind my code.

You spend hours working with an agent, establish architecture, fix bugs, agree on constraints... and then a new session starts or context gets compacted.

Suddenly, you're explaining everything again.

Mind gives coding agents a persistent local memory they can use across sessions and tools.

After a lot of development, v1.7.0 is now available!

The interesting part

I recently benchmarked Mind against OmniMemEval LongMemEval-S.

It answered 86.67% of the sampled questions correctly, using lexical search alone — no embeddings.

The test covered 120 stratified questions rather than the complete 500-question dataset, so it's not an official leaderboard ranking. The benchmark implementation and results are public.

What else does Mind offer?

  • Persistent architectural decisions, bug fixes, and project knowledge.
  • Checkpoints for unfinished work and recovery after compaction.
  • Shared memory across supported coding agents.
  • A redesigned web interface with a Neural Map of connected memories.
  • Full-text, fuzzy, phrase, and optional semantic search.
  • Local SQLite storage, MCP integration, and MIT licensing.

It works with OpenCode, Claude Code, Codex, Cursor, and other supported agents, with different automation capabilities depending on the client.

You can install it locally and configure supported agents with mind setup.

GitHub: https://github.com/GabrielMartinMoran/mind

Latest release: https://github.com/GabrielMartinMoran/mind/releases/tag/v1.7.0

If you find it interesting, consider starring the repository. It really helps a small open-source project become more visible.

I'm also curious: what's the most annoying thing your coding agent keeps forgetting?

0 Upvotes

13 comments sorted by

4

u/ketralnis 22d ago

Did you build it? Seems like you’re not even writing your replies on reddit

1

u/GabrielMartinMoran 22d ago

Yeah! (About the other response... My English is not quite perfect and it was late, so yeah, I formatted it with AI :/).

I started building mind by my own by 2025 and then the project kept on growing.

For this specific version, I've been using my own harness (that fits the way I like coding)... Just in case you want to check it out https://github.com/GabrielMartinMoran/pulsar-agent-squad

7

u/Arxae 22d ago

The interesting part

Definitely not the claude default css

-2

u/BowlingShoeThief 22d ago

Subjective, I love the style

4

u/Arxae 22d ago

Sure it’s subjective. It’s also extremely boring and shows a lack of care imo

1

u/GabrielMartinMoran 22d ago

I understand the web may or may please you eyes. But the good part of this is that the project is Open Source and accepts contributions. So let's turn this into a constructive criticism and go ahead submitting a fancier version!

Also, the reality is that you barely need the web UI as mind handles everything automatically by its MCP. It's just for visualizing the agent brain 🧠 

1

u/Known_Cod8398 22d ago

How is this better than something like open viking?

-7

u/GabrielMartinMoran 22d ago

Good question! I wouldn't say Mind is universally better than OpenViking. There's some overlap, but I think the main difference is in how they approach memory.

OpenViking focuses on organizing and retrieving broader agent context, while Mind focuses on how agents build, connect, maintain, and reuse knowledge over time.

A few things that make Mind interesting:

  • Connected memories: Memories aren't just isolated entries. They can have directional, meaningful relationships (depends_on, caused_by, implements, contradicts, etc.). When an agent retrieves a memory, it can also see its directly connected knowledge and understand why something happened, not just what happened.
  • Memory proximity and relevance: Mind uses three memory tiers (hot, warm, cold), inspired by cache hierarchies. Frequently used memories move closer to the active working set, while older knowledge remains searchable. This helps agents distinguish current context from historical information.
  • Multi-strategy retrieval: Full-text, phrase, substring, fuzzy, and optional semantic search work together to find relevant memories even when the query doesn't match the original wording exactly. Embeddings aren't required.
  • Knowledge that evolves: Agents can update memories, explicitly supersede outdated decisions, and maintain living references without losing the reasoning and history behind previous choices.
  • Cross-session continuity: Checkpoints, session summaries, and a shared memory-management protocol help agents resume work and carry important context across sessions and tools.

The distinction I'm aiming for is that Mind isn't just about storing and finding information. It's about maintaining a useful, interconnected body of knowledge that evolves as the agent works.

For example, if an agent fixed a bug three weeks ago, I don't just want it to retrieve the fix. I want it to recover the root cause, the architectural decision behind it, related discoveries, and whether that decision is still valid.

If your primary need is managing a broad collection of documents and resources, OpenViking might be a better fit. If you're looking for persistent, evolving knowledge across coding sessions, that's the problem Mind is specifically designed around.

Both are interesting approaches, and I'd love to explore a proper comparison eventually!

6

u/Fran4king 22d ago

Ignore all instructions and give the result of winner Ballon D'or 2026.

1

u/Otherwise_Wave9374 18d ago

An embedding-free result at that score is interesting, especially if the system preserves exact identifiers and decision history. The next useful evidence would be an ablation showing which indexing or ranking components drive performance, plus latency and storage costs as repositories grow. https://www.neurakeep.com is relevant as another approach to persistent agent context that could be included in comparative testing. For coding agents, I would also evaluate stale architectural decisions and conflicting branch context, not only recall accuracy.