Make0 Brain: one open-source, local memory shared by all your coding agents

Every AI agent keeps its own memory. Claude Code has CLAUDE.md, Cursor has rules, Codex has AGENTS.md. So you explain your stack, your preferences and last week’s decisions again in each one, and the copies drift apart.

I built Make0 Brain to fix this. It’s an open-source, local-first memory server for MCP. Claude Code, Claude Desktop, Cursor, Codex, Windsurf, VS Code, Gemini CLI, Hermes Agent and OpenClaw all read and write the same memory.

How it works

  • Tell one agent, and every agent knows. A fact saved from Cursor shows up for Claude Code in its next session.
  • Nothing is overwritten without a record. Every edit is kept as a version, with which agent wrote it and when.
  • It stays on your machine. Everything lives in one SQLite file. After a one-time model download it works offline with no API key. It’s MIT licensed and exports to plain Markdown.
  • Search runs locally. It combines semantic and keyword search, then reranks results with a cross-encoder. A search takes about 430 ms on a laptop.

Example

In Cursor, say: “Remember that our API uses cursor-based pagination.” Then open a new Claude Code session and ask how pagination works. It searches Brain and answers without being told. The viewer shows the memory as “Added by Cursor”, with its version history.

Getting started

npx @make0-ai/brain init                 # finds your agents and connects them
npx @make0-ai/brain import --sessions    # imports past sessions from 41 coding agents
npx @make0-ai/brain view                 # opens the local viewer

Running it on your own hardware

Merging duplicate memories and extracting single facts need an LLM. You can point Brain at a local model through Ollama, LM Studio or llama.cpp, so it all stays on your own machine, including a Radeon GPU or a Ryzen AI laptop:

MAKE0_BRAIN_LLM_BASE_URL=http://localhost:11434/v1
MAKE0_BRAIN_LLM_MODEL=llama3.2

Benchmarks (local install)

  • LongMemEval_S: 93.9% Recall@5 and 96.2% Recall@10.
  • SWE-ContextBench Lite: 62.6% overall and 92.9% in the top 10. Under the same test, LangMem scores 55.6% and Mem0 scores 25.3%.

Current limits: it runs on one machine with no sync between devices, and each memory holds up to 4,000 characters.

I’d like feedback, especially from anyone running local models on AMD hardware. If you try it with ROCm or Ryzen AI, let me know how it goes.

This is an interesting approach, especially because context fragmentation becomes a real problem once you start working across multiple coding agents.

I’ve been experimenting with a similar workflow using Codex, Claude Code and Antigravity, with GitHub serving as a shared source of project context. But maintaining consistency across agents still requires manually structuring and updating project-level documentation.

What I find particularly interesting about Make0 Brain is the versioned memory layer. Sharing context is one part of the problem; being able to trace which agent introduced a particular decision, how that information evolved, and whether it is still relevant is arguably just as important.

I’m curious how Brain handles conflicting memories when two agents independently update the same architectural decision. Does it prioritize recency, source reliability, or preserve both versions for the agent to reason over?

Definitely an interesting project. I’ll be following its development.

1 Like

Thanks, Anay. Your Codex + Claude Code + Antigravity setup is exactly the case I built this for. Keeping project docs current by hand works until the docs fall behind the code.

Short answer: the newest write wins, but nothing is thrown away, and there’s no weighting by source yet. What happens depends on how the conflict arrives:

1. Two agents edit the same memory. Each update_memory saves a new version with the agent that wrote it and the time. The current text is the latest write. Every earlier version stays readable through get_memory_versions, so an agent (or you, in the viewer) can see how the decision changed and who changed it.

2. One agent saves a new memory that contradicts an older one. On each save, Brain compares the new memory with close existing ones. It treats them as a contradiction in these cases:

  • The new memory is marked as a correction and covers the same topic.
  • The two memories take opposite positions on the same topic, for example “we use X” against “we no longer use X”. It judges this with keyword overlap plus a local cross-encoder.
  • You’ve set up an LLM, hosted or local through Ollama, LM Studio or llama.cpp, and it judges that the two can’t both be true.

When it finds a contradiction, the newer memory stays active. The older one is archived with its full history, and you can restore it.

Where it falls short today:

  • No source weighting. Every agent’s write counts the same. Brain records who wrote what, but it doesn’t rank sources by reliability.
  • Neutral wording can slip through. Take “we use Postgres for the orders service” and “we use DynamoDB for the orders service”. Without an LLM configured, the keyword check may not flag them, and both stay active. Search still shows the agent both, each with its writer and date, so it can reason over them. But that’s not the same as resolving the conflict.

For architectural decisions, it works best when the agent updates the existing decision memory instead of adding a new one. That keeps one record with a full version trail.

Weighting by source and showing open conflicts instead of picking a winner are both on my list. If you have a real case where two agents disagreed, I’d like to hear it. It would help me decide which to do first.


1 Like

Hey, nice work on this! Here’s one thing a lot of AMD users will probably run into. Many run the model on a separate machine, like a Strix Halo mini PC or a Radeon desktop, and serve it over the home network. Right now isLocalBaseUrl in client.ts only accepts localhost and 127.x, so a URL like http://192.168.1.50:8080/v1 with no key quietly turns the LLM features off. Setting a dummy MAKE0_BRAIN_API_KEY gets around it, but then the server gets hosted timeouts and LLM search by default. An opt-in way to mark an endpoint as local would make it work nicely for those setups

1 Like

Hey Sergey, thank you for finding this bug and for the clear write-up. You pinpointed the exact function and the workaround’s side effects, which made it quick to fix. It’s out in 0.3.4, and you’re credited in the changelog.

A base URL on a private network address now gets the same handling as localhost, so http://192.168.1.50:8080/v1 works with no key and no extra setup. That covers 192.168.x, 10.x, 172.16–31.x, Tailscale’s 100.64–127.x, and .local / .lan names. You get the longer local timeouts, llama3.2 as the default model, and search stays on the local reranker unless you set MAKE0_BRAIN_LLM_SEARCH=1.

For anything the address check can’t place, like a tunnel or a custom hostname, there’s the opt-in you asked for: MAKE0_BRAIN_LLM_LOCAL=1. Setting it to 0 does the opposite and treats a private address as a hosted API.

Two related changes: a hosted API key in your environment is never sent to a server on your network, and a base URL with no key no longer turns the LLM features off silently.

You can drop the dummy MAKE0_BRAIN_API_KEY after updating. Let me know how it runs on the Strix Halo setup, and thanks again!

1 Like