RoBrain CLI
RoBrain passively records team and agent decisions and warns when an agent re-proposes an approach you already rejected
- 90 ★ on the repository
- Last commit
- Apache-2.0
Broad access
Why this level
- Hooks and MCP read the text of every session turn and send it to external models for decision extraction
- Starts containers and a Postgres database and writes `CLAUDE.md`, `AGENTS.md` and editor rules into your project
- In cloud mode team memory is stored by a third-party service
Install
- Works in
Manual install
npx robrain@latest upStarts Postgres and Perception from an image. Docker and the ANTHROPIC_API_KEY and OPENAI_API_KEY keys are required.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- Hooks and MCP read the text of every session turn and send it to external models for decision extraction
- Starts containers and a Postgres database and writes `CLAUDE.md`, `AGENTS.md` and editor rules into your project
- In cloud mode team memory is stored by a third-party service
This is third-party code. Review the repository files before installing.
What it does
RoBrain builds a shared memory of team and agent decisions with the reasons behind them. The Sensing layer captures session turns, and the Perception layer extracts decisions into Postgres: each row has an author, date, session turn and a `rejected[]` field of ruled-out alternatives. No manual tagging is needed. A batch Synthesis pass reads the whole corpus and flags contradictions and stance drift. The main use: on Tuesday someone in Cursor decides not to port to Express, and on Wednesday a new teammate in Claude Code asks for exactly that port. RoBrain shows the recorded rationale before the agent heads down a rejected path. The self-hosted stack starts with `npx robrain@latest up` (Postgres and Perception from an image), `npx robrain install --self-hosted` wires the Sensing MCP into editors and the Claude Code plugin adds capture hooks and pre-task warnings. The Rory Plans cloud mode needs no hosting. It works with Claude Code, Cursor, GitHub Copilot, Codex CLI and Hermes.
Who it is for. Teams where several people and agents work on one codebase and keep re-proposing what was already rejected, rolled back or found vulnerable.
Good fit when
- A new teammate in Claude Code asks for a change the team rejected last week in Cursor
- An agent does not remember why a migration was rolled back and the recorded rationale must show before work begins
- You need a per-file decision log: who decided, when and from which session turn (`robrain explain`)
- Once a week you need a pass over the whole decision corpus for contradictions and drift with `robrain synth`
Not a fit when
- You work alone on a small project: a `CLAUDE.md` file with rules is enough
- You cannot run Postgres and Docker or have no Anthropic and OpenAI keys for decision extraction
- You only need shared notes with no tracking of rejected alternatives
Example request
Start RoBrain locally, connect it to Claude Code and show the decisions the team already rejected for this repositoryLimitations
- The self-hosted install needs Docker, Postgres and LLM and embedding keys: Anthropic for extraction and OpenAI for vectors by default, other setups are in `docs/concepts.md`.
- Capture and extraction go through external models, so session text reaches providers and, in cloud mode, the Rory Plans service.
- The cloud is included in paid Rory Plans tiers, and self-hosting is free.
- The author's VetoBench figures (no misses in 159 runs) come from its own task set, so verify on your own.
How to disable. Stop the stack with the stop command from `docs/cli.md`, remove the `robrain` entries from the editors' MCP configuration and the plugin with `claude plugin uninstall robrain@robrain`. Data lives in `~/.robrain/` and in your Postgres.
FAQ
How do I run RoBrain myself?
Set Anthropic and OpenAI keys, then run `npx robrain@latest up` and `npx robrain install --self-hosted`. `up` pulls the Perception image and generates credentials in `~/.robrain/stack/.env`.
What does `robrain init-project` do?
It writes `CLAUDE.md`, `AGENTS.md` for Codex CLI and the `.cursor/rules/robrain.mdc` rule for Cursor into the project. After that capture and recall of past decisions run automatically.
How is RoBrain different from ordinary agent memory?
Most memory tools only store what was said. RoBrain keeps decision provenance, a rejected-alternatives field and finds contradictions across the whole corpus.
How do I install the Claude Code plugin?
Run `claude plugin marketplace add adelinamart/robrain` and `claude plugin install robrain@robrain`. The plugin gives capture hooks and pre-task warnings.
What does `robrain explain` show?
The decision history for a file: who decided and when, which session turn it was extracted from and which alternatives were rejected.
Discussion
No questions or reviews yet.
Related
CLI toolsBrainDB keeps agent memory in PostgreSQL: entities, relations, search and rules, with two skills wiring it to Claude Code.
A long-term memory MCP server for agents: one Rust binary that runs offline and never calls a language model
GBrain stores sourced facts, searches them and gives Claude Code, Codex and Cursor one shared memory the owner can correct.
Local project memory for AI agents: repository, sessions and decisions in SQLite with evidence labels, no cloud, no telemetry.
External memory for Hermes, Claude Code, Codex and Cursor: session archive, recall layers and relevant context injected back
BrainAPI turns text into a knowledge graph on your server and serves agents over MCP, REST and a console with fact-path answers
README in short
The README presents RoBrain as a governance layer for agents with shared memory, decision provenance and architectural guardrails. Next come the working principle with a Hono versus Express example, two install modes (own stack and Rory Plans cloud), a quickstart and a VetoBench write-up. Details live in `docs`.