Robrain
About
Shared memory across your team and your AI agents — with judgment.
Details
- Author
- adelinamart
- GitHub stars
- 80
- Downloads
- 468
- Categories
- Knowledge Base, AI
Jump to
- 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
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
RobrainCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
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
sensing_start_session
Signal the start of a new Claude Code session. Call this once at the beginning of every session. Returns the always-on project summary to inject into your context. session_id may be omitted or empty — the server generates a unique id and returns it (use that id for sensing_record_turn and sensing_end_session).
sensing_record_turn
Record a completed conversation turn (user message + Claude reply). Call this after every exchange. Survives server restarts — keep using the same session_id even if the server reconnected mid-conversation. Returns whether a topic shift was detected — if true, call your context injection tool.
sensing_end_session
Signal the end of a Claude Code session. Triggers the flush-on-close hook to ship any unclassified buffered turns to Perception before the session closes.
sensing_get_status
Get the current status of the Sensing buffer for a session. Useful for debugging.
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"robrain": {
"robrain-sensing": {
"command": "npx",
"args": [
"-y",
"robrain",
"mcp"
]
}
}
}
}McpServers
{
"robrain-sensing": {
"command": "npx",
"args": [
"-y",
"robrain",
"mcp"
]
}
}RoBrain
Shared memory across your team and your AI agents — with judgment about what's worth keeping.
RoBrain isn't just another memory layer — it's the brain that helps you and your agents make better decisions and avoid costly mistakes.
Self-hosted on your own Postgres. Passive capture, structured vetoes, corpus-wide contradiction scans — nothing leaves your machine. Works with Claude Code, Cursor, GitHub Copilot (VS Code), and Codex CLI.
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.
What it is
RoBrain records what your team and its agents decide — and the alternatives they ruled out — without anyone tagging anything by hand. Sensing captures session turns; Perception extracts each decision into Postgres, where every row can carry a structured rejected[] field.
Most agent-memory tools stop at capture: they store what happened and hope you query it later. RoBrain adds judgment. Batch Synthesis reads the whole corpus to flag contradictions, stance drift, and recurring entities that no single session could see.
The point is the handoff. Someone makes a deliberate call in Cursor on Tuesday — say, keeping Perception on Hono instead of porting to Express. A new teammate opens Claude Code on Wednesday with no memory of it and asks to make exactly that change. RoBrain surfaces the recorded rationale before the agent steers down a path you already rejected — same Postgres store, same vetoes, captured passively.
> The cost of forgetting a rejection isn't inefficiency. It's the auth bypass you already patched, the migration you already rolled back, the dependency you already removed for a CVE — re-suggested by an agent with no memory of why you said no.
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.
How it works, the two pillars (capture + judgment), and the full walkthrough: docs/concepts.md.
Install
No clone needed — robrain up pulls the published Perception image and generates credentials into ~/.robrain/stack/.env:
export ANTHROPIC_API_KEY=... OPENAI_API_KEY=... # or add them to ~/.robrain/stack/.env after the first run
npx robrain@latest up # start Postgres + Perception from ghcr.io
npx robrain install --self-hosted # wire Sensing MCP into your editors
<details>
<summary>From a clone instead (development, or building the image yourself)</summary>
First pnpm docker:up auto-creates .env and fills PERCEPTION_API_KEY / POSTGRES_PASSWORD. Perception still needs your LLM + embedding keys before it stays up.
```bash
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
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
