Baron Munchausen — local memory that outlives the chat

_{Everything above is a real run against a clean clone. rpc is the two-line curl wrapper defined in docs/demo/baron-demo.sh; re-record the whole thing with cd docs/demo && ./record.sh.}

Public alpha (0.6.1). The engine has run daily in the authors' own work for months; this repository is one day old. The code is Apache-2.0 and complete — the packaging, the docs and the install path are what "alpha" refers to. Report anything that breaks.

Your session ends. Your project doesn't. One call brings back where the project stopped, what was decided and what comes next — after a closed tab, a spent limit or a change of model. And every answer built on that memory comes back with a verdict: grounded, partial or ungrounded, with the sentences nothing backs named one by one.

A memory server in Python 3.12 with no third-party runtime dependency. MCP over stdio for your client, JSON-RPC on 127.0.0.1:8765 for everything else. Nothing here calls a model and nothing leaves your machine. A fresh install starts with an empty graph: we ship the tools, never the data.

Why

Three numbers, each one measured, each one with what it does not say written next to it.

1. One context return: 7 146 tokens → 2 388. The 7 146 is a real compaction summary out of a session transcript; the 2 388 is the slice a live memory_ground_prepare returned for the same moment of the same project. Both counted with tiktoken/cl100k_base on 2026-09-10. What it does not say: it is one pair of instances, not a distribution — a second summary from the same corpus came to 5 913 tokens, which would make the same slice a 60 % cut instead of a 67 % one.

2. Claude Opus 5: −69.6 % input tokens, measured. Not arithmetic on the figures above — this is what the models' own usage reports came back with on live runs of the same tasks, 2026-09-10. Sonnet 5 came to −61.7 %, Haiku 4.5 to −66.3 % on the same runs. What it does not say: these are the authors' graph and the authors' tasks. Your ratio depends on how much of your context is recoverable from a graph at all, and nobody has run this on a public benchmark yet.

3. Thirty tools, zero runtime dependencies. curl -s 127.0.0.1:8765/health reports "tools": 30 on a fresh clone — the same 30 over MCP stdio and over JSON-RPC, with requirements.txt empty of third-party runtime packages. What it does not say: nothing about quality. It is a count.

What those percentages are worth in money depends on your model and your volume: the savings calculator on shinegang.click does that arithmetic with current list prices, and shows which figures are measured and which are calculated.

Install in two minutes

git clone https://github.com/shinegang/baron.git && cd baron

# 1. start the memory server — standard library only, nothing to install
bin/baron --host 127.0.0.1 --port 8765 --store blank

# 2. in a second terminal: it is up, the graph is empty, 30 tools are loaded
curl -s http://127.0.0.1:8765/health | jq '{product, version, nodes, tools}'

# 3. check the stdio bridge against the live server
python3.12 bridge/mnemos_bridge.py --selftest

# 4. register it with your MCP client (Claude Code shown; the rest are below)
bash integrations/baron_add.sh

Step 2 prints {"product": "Baron Munchausen", "version": "0.6.1", "nodes": 0, "tools": 30}. Without jq, drop the pipe and read the raw JSON.

Write a fact and get a verdict without any client at all — this is the same JSON-RPC the demo above runs:

curl -sX POST 127.0.0.1:8765/rpc -H content-type:application/json -d '{
  "jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"memory_add",
  "arguments":{"items":[{"claim":"The release build is pinned to Python 3.12.",
  "source":"team decision","kind":"rule"}],"session_id":"demo"}}}'

Installing the package (pip install .) puts the same server on PATH as baron; python3.12 -m baron works from a checkout.

Clients

Any client that takes the standard mcpServers JSON block can use Baron. These are the ones with a file in integrations/ already written:

Claude Code can go further than registration: the PreCompact and SessionStart hooks in tools/hooks/claude/ re-inject a slice of the graph when the context window is compacted, so what the window drops the graph still holds.

What it does, with the number and where it is checked

Every number below was measured on 2026-09-10 on the authors' own graph and their own machine, and every one of them can be re-measured from this repository. Where a number does not exist yet, this page says so.

Numbers this project does not have. No LongMemEval or LoCoMo score: those harnesses have not been run here, and until they are, the honest word is "not measured". In fourteen days of live use the verdict distribution on the authors' own journal was 81 ungrounded, 41 partial, 20 grounded over 142 passes — that is a measurement of how often agents answered without consulting the graph first, not a quality score, and it is published because hiding it would be the kind of thing this tool exists to catch.

How grounding actually works

No pre-pass, no credit. Call memory_ground without a matching memory_ground_prepare and the verdict is ungrounded (notes: no_pre_pass), however many claims the text happens to support.