RoBrain

Most agent-memory tools treat context like a passive archive. RoBrain is an evaluation and delivery engine designed around state-grounding: Is this context still true against the live environment, and what must surface before an agent acts again? Passive capture records every decision and the alternatives your team ruled out; batch Synthesis reads the whole corpus to flag contradictions, drift, and recurring entities that no single session could see. Coding is the first vertical because the feedback loops are tight — reverts, incidents, and rework make the cost of a forgotten rejection measurable. The same architecture applies wherever agents make decisions that outlast a session.

RoBrain is built by Rory Plans, an agent orchestration platform; it is the memory and judgment layer that keeps multi-agent, multi-developer work coherent over time.

Measured: without decision memory, a coding agent re-proposes an approach your team already rejected in up to 9 of 10 tasks. Through RoBrain's full pipeline — 0 of 50, across five archived runs (VetoBench).

→ How to use RoBrain?

Two commands, no clone needed:

export ANTHROPIC_API_KEY=... OPENAI_API_KEY=...   # classifier + embedding keys (or add to ~/.robrain/stack/.env after first run)
npx robrain@latest up                             # start the backend (Postgres + Perception) in Docker
npx robrain install --self-hosted                 # wire the MCP server into your editors

Then run npx robrain init-project inside any repo you want memory for. Capture is automatic from there — every session turn is classified, no tagging. If captures don't land, npx robrain doctor diagnoses the setup.

Claude Code users should also install the plugin for hook-based capture and pre-task warnings about rejected approaches. Codex CLI users get the same hooks automatically from robrain install (trust them on first Codex run):

claude plugin marketplace add adelinamart/robrain
claude plugin install robrain@robrain

Clone path, Synthesis, ledger export, and troubleshooting: Quick start · CLI reference

✓ Is RoBrain for you?

• More than one developer touching the same codebase with AI agents
• More than one tool in the stack (e.g. Cursor and Claude Code, not just one editor)
• Project older than a few months — enough history that contradictions actually accumulate
• You have watched an agent re-suggest something your team already rejected

If none of these sound familiar, a static CLAUDE.md may be enough for now. See the full walkthrough →

★ Top features

• Rejected alternatives as first-class data Every decision can carry a structured rejected[] field: what was ruled out, and why.
• Pre-task veto warnings Self-hosted Perception exposes POST /veto-scan for deterministic exact-match on rejected[] (no LLM). The Claude Code plugin and Codex hooks call it on every prompt, then semantic search for longer tasks; Hermes renders semantic REJECTED: warnings per turn. Other editors get prior decisions at session start via the always-on summary.
• Passive capture Decisions are extracted from your sessions automatically; nobody tags anything.
• Cross-tool memory One Postgres store shared by Claude Code, Cursor, GitHub Copilot, Codex CLI, and Hermes; decide in one tool, remembered in all.
• Judgment, not just storage Synthesis passes (run manually or on your cron) flag contradictions and stance drift across the whole corpus; decisions carry a lifecycle (active / superseded / invalidated) and a graph (conflicts_with / extends / related_to).
• Git-grounded feedback robrain outcomes demotes decisions that led to reverts; incidents are next on the roadmap.
• Private by default API-key auth on every request, secrets scrubbed at capture and again at ingest, and a fully-local mode running extraction and embeddings on Ollama, LM Studio, or vLLM.
• No lock-in Export the whole corpus as robrain-memory/v1 JSONL, or keep a decision ledger in git with robrain export-memory --ledger.
• Fully self-hosted Your data stays on your infrastructure; Apache-2.0.

Comparisons with other memory tools: Concepts — Comparisons.

◎ Use cases

• Stop repeated mistakes The dependency you removed for a CVE, the vendor you dropped over pricing, the migration you rolled back — surfaced with the original reasoning right when an agent is about to suggest them again.
• Team handoffs A decision made in Cursor on Tuesday is known to a teammate's Claude Code on Wednesday.
• Onboarding New engineers (and their agents) inherit the project's decision history instead of relearning it.
• Decision archaeology npx robrain explain <file> answers "why does this code look this way?"

▤ VetoBench — we measured it

Most memory benchmarks ask "did the right item come back?" VetoBench asks what that misses: given a task that invites an approach the team already rejected, does the agent propose it again?

claude-haiku-4-5, 2026-07-07/08. Mem0 and RoBrain ingested byte-identical transcripts, each through its own real production extraction. Mem0's ingestion dropped the recorded rejection from 38% of retrieved contexts — and violations concentrated exactly there (26% when the veto was absent vs 3% when present). RoBrain's extractor kept 100/100 vetoes.

Meta Muse Spark 1.1 (2026-07-14, five archived runs via Vercel AI Gateway): without memory, Meta's newly launched agentic flagship re-proposed rejected approaches in 4–6 of 9 tasks per run — Redux, Prisma, Jest, and GraphQL in all five runs. With RoBrain decision memory: 0 violations in all 45 cells, naming the prior rejection every time — quoting the recorded reason and date verbatim where it elaborated. Asked to cut mobile overfetching, the no-memory run proposed the full GraphQL rollout the team had ruled out, five runs out of five; with RoBrain in context it proposed REST sparse fieldsets and quoted the recorded rejection. One scenario excluded (n=9): Meta's content filter deterministically blocks a benign session-caching prompt. Receipts and caveats: results/muse-spark-1.1-series.

Every retrieved context, agent reply, and verdict is committed in the repo — check the work before quoting it: packages/vetobench.

⟲ Decisions evolve. RoBrain knows that.

Decisions are durable context, not permanent vetoes. When a previously rejected idea makes sense again, you supersede the old row — history stays queryable, the new decision becomes active. Synthesis flags contradictions for robrain review; it does not fossilize your stack. Informed reconsideration, not lock-in.

◎ Architecture (OSS)

⚡ Quick start

The steps above are enough to get going. Below: OpenAI-only keys, the clone development path, Synthesis, and the git ledger.

One-time — no clone needed

export ANTHROPIC_API_KEY=... OPENAI_API_KEY=...
npx robrain@latest up
npx robrain install --self-hosted

OpenAI-only: set LLM_PROVIDER=openai and OPENAI_API_KEY instead of Anthropic — see Concepts.

From a clone instead (development)

git clone https://github.com/adelinamart/robrain
cd robrain
pnpm install && pnpm build
pnpm docker:up                 # first run: creates .env; Perception won't start yet
# open .env, add ANTHROPIC_API_KEY + your embedding key (e.g. OPENAI_API_KEY)
pnpm docker:up                 # second run: Perception now boots
npx robrain install --self-hosted --repo-root "$(pwd)"

Per application project

cd /path/to/your/project
npx robrain init-project

Corpus judgment (manual once, or add to cron)

npx robrain synth

Synthesis writes contradiction flags, drift signals, and entity summaries into your DB — review with npx robrain review. It does not capture new decisions; it judges what you already have.

Git-committed decision ledger (opt-in)

npx robrain review              # optional — inspect/approve captured decisions in the CLI
npx robrain export-memory --ledger
# custom path: npx robrain export-memory --ledger docs/decisions.md

Use review when you want to see what is being recorded and approve or reject rows before regenerating decisions.md for git — skip it if you are fine exporting straight from the DB.

After init-project, every repo gets CLAUDE.md and AGENTS.md (Codex CLI), and Cursor also gets .cursor/rules/robrain.mdc with alwaysApply: true — capture setup is automatic. See docs/cli.md (install + commands) and docs/troubleshooting.md for editor-specific notes. Install details: docs/cli.md · Upgrading · Concept walkthrough.

◇ Claude Code plugin

The RoBrain plugin wires capture and rejection-warnings straight into Claude Code's lifecycle — no reliance on the model remembering to call an MCP tool. It talks only to the self-hosted Perception URL you already configured, and every hook fails open: if your stack is down or unconfigured, your session is unaffected.

Add the plugin

claude plugin marketplace add adelinamart/robrain
claude plugin install robrain@robrain

Runs alongside the Sensing MCP — Perception deduplicates server-side, so nothing is double-captured. With the plugin installed, the sensing_record_turn block in CLAUDE.md becomes optional, and decisions still surface in Cursor, Copilot, and Codex through the same store.

One install covers the team: npx robrain init-project writes the plugin recommendation into the repo's .claude/settings.json, so every teammate who opens the project in Claude Code is prompted to install it — nobody has to be told the plugin exists (opt out with --skip-claude-plugin).

⬡ Hermes agent

For Hermes, RoBrain installs as a standalone memory-provider plugin under ~/.hermes/plugins/robrain. Passive capture, semantic prefetch, and veto-aware warnings all go through your self-hosted Perception API — no separate memory stack.

Install the plugin (no clone)

npx robrain@latest up
npx robrain install --hermes
hermes memory setup    # select "robrain"

Combine with editor wiring in one run: npx robrain install --self-hosted --hermes. Every hook fails open — if Perception is down, Hermes keeps working without blocking. Details: integrations/hermes.

◎ Documentation

Overview: README on GitHub. Deep dives:

• docs/concepts.md — how it works, two pillars, Synthesis, comparisons
• docs/cli.md — install, upgrading, editor setup, full command table (explain, etc.)
• docs/release.md — maintainer release checklist (tag → GHCR → npm → MCP registry)
• docs/troubleshooting.md — silent 401s, Docker rebuilds, stale summaries
• docs/memory-interchange.md — robrain export, robrain-memory/v1 JSONL
• packages/vetobench — does memory stop rejected re-proposals? methodology + archived receipts
• plugins/claude-code — hook-based capture + veto warnings
• plugins/codex — Codex CLI hooks (wired by robrain install)
• integrations/hermes/robrain — Hermes memory-provider plugin (capture + veto warnings)

⌂ Trust & privacy

The Perception API runs locally in Docker, extraction happens on your hardware, and decisions are stored in your Postgres. Nothing is sent to Rory Plans or any other external service.

The one network dependency: extraction calls Anthropic or OpenAI (your choice of classifier) and embeddings call OpenAI, Voyage, or Cohere. Those are the only outbound calls. You can swap providers or run a local model if you want full air-gapping.

And here's exactly what gets stored:

Full details, third-party processors, and retention: Privacy Policy.