Your memory. Any agent.

Two values for one thing

Everything below is output from brain demo, copied out of a real run against a scratch vault. Nothing here is a mockup, and you can produce the same six panes on your own machine in about four seconds.

  > "staging runs on port 8080"
  ✓ Logos · stored in brain — memory #1

  > "we moved staging to port 9090"
  ✓ Logos · stored in brain — memory #2

  #1  Staging runs on port 8080.   ← still returned
  #2  Staging runs on port 9090.   ← also returned

  ✓ Logos · 1 memory superseded — the old value is now history

  > context("deploy to staging")

  - fact: Staging runs on port 9090.  (demo, 2 Sep 2026, confidence 0.90)

  created     #1  Staging runs on port 8080.
  created     #2  Staging runs on port 9090.
  superseded  #1  Staging runs on port 8080. → #2

What one agent wrote, and what the next one got

A checkpoint is a markdown file with front matter, written by whichever agent was working. A resume is what a different agent, on a different day, in a different product, reads back. Both panes below are real files from this project’s own vault.

---
type: checkpoint
project: logos
agent: claude
branch: feat/bench-temporal
commit: a5e72a2
uncommitted: 2
checkpointed: 2026-09-01T08:57:24-07:00
---

## Didn't work

- publishing under the unscoped name
  'logos' — taken on npm at 1.0.4
- claiming the @logos scope — the org
  already exists, not ours to take

# Context for: resume work on logos

Last checkpoint by claude, 1d ago.

Repository was: feat/bench-temporal
a5e72a2 · 2 files uncommitted

Already tried, didn't work:
- publishing under the unscoped name
  'logos' — taken on npm at 1.0.4
- claiming the @logos scope — the org
  already exists, not ours to take

_Context budget: ~284 of 4000 tokens._

The dead ends travel. An agent that has never seen your project does not get to spend an hour rediscovering what last week’s agent already paid for.

It knows something before you teach it anything

Point it at a repository you have never used it on. It reads the git history and proposes what it can defend, each with the command that produced it — then writes nothing until you drop --dry-run.

From the git history of ~/code/logos, scoped to project "brain":

  1. Coder8124 writes most of this codebase — 145 of the last 145 commits.
     git shortlog -sn: Coder8124 145/145 · confidence 0.80

  2. Change concentrates in cmd/brain/ (145), (root) (93) and
     internal/memory/ (72) — file-touch counts over the last 145 commits.
     git log --name-only: 977 paths across 69 areas · confidence 0.80

  3. Commit subjects here are capitalised sentences with no trailing
     period — 124 of the last 145.
     git log --format=%s: 124/145 · confidence 0.65

  4. This project runs at roughly 12 commits a month; the most recent
     is dated 2026-09-02.
     145 commits over 12 months · confidence 0.80

4 memories would be written. Nothing was.

Every line carries the command behind it, so you can check any claim rather than take it. Changed your mind after writing them? brain memory forget --source bootstrap removes exactly what the machine added and nothing you did.

Every integration is a client, never a home

The failure mode this project exists to avoid is memory that lives inside one product. If your record is a table in somebody’s app, switching agents means starting over, and the vendor decides how long you get to keep it. So the rule here is enforced at every layer, not just advertised at the top one:

• Vault formatMarkdown with YAML front matter. Human-readable, diffable, greppable, and committable to your own git. Truth lives here.
• Index.brain/index.db is SQLite and is a cache. Delete it; it rebuilds from the files. Nothing is only in the database.
• MCP interfaceThe wire protocol every host already speaks. Not a plugin per editor — one server, and the hosts are interchangeable.
• Go packageimport "github.com/Coder8124/brain" and embed the engine directly if you are building your own agent.
• CLIEvery operation available over MCP is also a command, so a shell script, a CI job, or an agent framework nobody has written yet is a first-class client.
• ProvenanceEach memory records which agent learned it, from what source, when, and at what confidence — taken from the MCP handshake, never asked of the model.
• SemanticsSupersession, dead ends and abstention mean the same thing to every client, because they are properties of the record rather than of a prompt.

If this project stops being maintained tomorrow, you still have a directory of markdown. That is the test of ownership, and it is the only one that matters.

“Verified” means a real handshake and a real store-then-recall against that host, not that the config file looks right. The unverified rows say so on purpose — if you use one, a report closes the gap.

Measured, on one machine, against eight others

Existing memory benchmarks score retrieval: given a long history, can the system find the fact. That is not the setting these tools are deployed in. We built a handoff suite instead — 32 hand-authored scenarios, nine systems, the same embedding model throughout — where a scenario passes only if the successor gets the current fact, without the stale one beside it, inside a token budget it did not choose.

Carry is required facts retrieved. Leak is superseded facts returned anyway — lower is better. Signal is telling the successor that something was already tried or has since changed.

Read the row order carefully, because it is the finding: retrieval is not the differentiator. Every real system carries 82–89% of the required facts. The entire spread comes from leakage and signal — from whether the agent that resumes gets one answer or gets the right one sitting next to the wrong one it replaced.

On the durability family — write, delete every rebuildable artifact, read again — Logos scores 100% and every other system scores 0%.

It loses too, and the numbers stay in: arithmetic, recency-conflict and multi-hop are all 0%. The suite, the scenarios and the runner are in the repository, so you can reproduce the wins and the losses alike — the write-up is here.

You can see it working, and you can turn that off

A continuity layer nobody notices restoring anything is a continuity layer nobody believes in. So every operation that changes what the assistant knows says so, in one line, in the host you are already looking at.

  ✓ Logos · stored in brain — memory #41 (fact, kestrel)
  ✓ Logos · already knew that — reinforced memory #12 (fact, kestrel)
  ✓ Logos · checkpoint saved to brain — 20260902-171104-claude.md
  ✓ Logos · recalled 1 checkpoint, 3 notes, 2 open questions

Too chatty after the first week? LOGOS_ANNOUNCE=quiet shortens them and off removes the marker entirely. What never changes with the setting is the information — turning receipts down tells you less loudly, not less.

And a separate, host-level record that does not depend on a model choosing to write it: brain activity replays every prompt, tool call and turn the agent actually took, captured by hooks rather than volunteered.

Install the plugin instead

The version to prefer, because it is more than the MCP server: it also installs a SessionStart hook that puts the last handoff in front of the model before it does anything — the difference between continuity that works and continuity that works when the model remembers to ask for it.

1. / plugin marketplace add Coder8124/logos

   Copy

2. / plugin install logos@logos

   Copy

The marketplace is the repository; the plugin inside it is named logos.

Cursor and VS Code

Deep links that hand the host a finished config. Nothing else to edit.

Any MCP host

No install at all — npx resolves the binary on demand, so this config is portable between machines in a way an absolute path is not.

{
  "mcpServers": {
    "logos": {
      "command": "npx",
      "args": ["-y", "@noeton/logos", "mcp", "serve"]
    }
  }
}

Add "env": { "BRAIN_VAULT": "/path/to/vault" } to keep the vault somewhere other than ~/brain.

Or just take the binary

One static executable, pure Go with CGO_ENABLED=0 — so a single Linux build covers glibc and musl alike. Checksums travel with the release.

Verify against SHA256SUMS · the executable inside keeps the development name, brain. With Go on the machine: go install github.com/Coder8124/brain/cmd/brain@latest.

One vault, one project per folder

Every host points at the same vault — that is what makes continuity work across tools. Facts are still kept apart: the project comes from the directory the agent is working in, so two repositories open in two windows do not write into each other’s memory.

~/code/kestrel    → project "kestrel"
~/code/acme-api   → project "acme-api"   # cannot see kestrel's decisions

Nothing to configure, and the agent never has to remember which project it is on — a rule a model can forget is not isolation.

What installing actually does to your machine

• A directory of markdown files, at ~/brain unless you say otherwise. Open them, grep them, commit them, delete them.
• Nothing is wired without a yes. Setup lists the agents it found and what it would write to each, and --dry-run prints the plan without touching anything.
• Nothing an agent proposes is believed on the spot. A memory written over MCP waits in a review queue — brain review accepts or rejects it, and it carries which agent proposed it.
• No postinstall script. The binary ships as real package contents, so --ignore-scripts and offline installs both work.
• No AI runtime required. Checkpoint, resume and dead ends are markdown and SQL. Search falls back to lexical, which for identifiers and stack traces is arguably the right tool anyway.
• No account, no server, no telemetry. .brain/index.db is a cache; delete it and it rebuilds from the files.

Ollama, LM Studio, Jan and Msty are auto-discovered if present. Nothing an MCP host calls ever needs a chat model.