Robrain

What is Robrain?

RoBrain is shared memory for your team's AI coding agents — with judgment about what's worth keeping. It passively records the decisions made in your Claude Code, Cursor, GitHub Copilot (VS Code), Codex CLI, and Hermes sessions, including the alternatives you rejected and why. Every editor gets the project's decision history — rejections included — loaded at session start; in Claude Code, the RoBrain plugin goes further and warns the agent before it starts working on something your team already ruled out. Self-hosted on your own Postgres, with a fully-local mode where nothing leaves your machine at all.

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, which adds deterministic hook-based capture and pre-task warnings about rejected approaches:

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

Key features of Robrain

• Rejected alternatives as first-class data — every decision can carry a structured rejected[] field: what was ruled out, and why
• Pre-task veto warnings — the Claude Code plugin warns the agent before it re-proposes an approach you already rejected; every editor gets prior decisions, rejections included, at session start
• 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

Use cases of Robrain

• 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 answers "why does this code look this way?"

FAQ from Robrain

Where is the source code for Robrain?

https://github.com/adelinamart/robrain — Apache-2.0, TypeScript monorepo. Measured on VetoBench: without decision memory, a coding agent re-proposed an already-rejected approach in 8–9 of 10 tasks; through RoBrain's full pipeline, 0 of 50 across five archived runs. On byte-identical input, Mem0's ingestion lost the recorded rejection from 38% of retrieved contexts. Every retrieved context, agent reply, and verdict is committed in packages/vetobench/results/ — check the work before quoting it.

Does Robrain include a standard MCP config?

Yes:

{ "mcpServers": { "robrain-sensing": { "command": "npx", "args": ["-y", "robrain", "mcp"] } } } The server reads its backend connection from ~/.robrain/config.json (written by robrain up / robrain install), so no env block is needed.

What do I need to run it?

Docker with Docker Compose (for the local backend), Node.js ≥ 18.18, and an LLM key for decision extraction — Anthropic or OpenAI — plus an embedding key (OpenAI, Voyage, or Cohere). Or skip the keys entirely: fully-local mode runs extraction and embeddings on an OpenAI-compatible local server (Ollama, LM Studio, vLLM) with zero external calls.

Is there a paid version?

Self-hosted is free and covers capture, judgment, and recall. The Rory Plans cloud tier adds automatic injection at task boundaries (pre-task veto warnings in every editor, not just Claude Code), team orgs and roles, and a web dashboard.