Open-source · cloud option

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.

Claude Code Cursor Copilot Codex CLI
View on GitHub Join cloud early access
RoBrain robot pushing back against blind instructions — good agents understand, question, and think before acting

Most agent-memory tools stop at capture — they store what happened and hope you query it later. RoBrain is built around a different question: what is worth keeping, and what should surface before the 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.

Whether that's worth the setup depends on your situation.

✓ Is RoBrain for you?

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

If they do, here's how RoBrain compares to the obvious alternatives.

⊞ What RoBrain does that others don't

Feature comparison: RoBrain vs Mem0 vs Cloudflare Agent Memory vs Claude Code Auto-Memory
Feature RoBrain Mem0 Cloudflare Agent Memory Claude Code Auto-Memory
Tracks what your team ruled out Yes — structured rejected[] field per decision No No No
Catches when a new decision contradicts an old one Yes — scheduled scan across the whole project (Synthesis) No — only at the moment of insertion, no scheduled corpus scan Partial — internal use only Yes — silently deletes the loser
Past decisions stay queryable after you change your mind Yes — old and new both kept No — new replaces old No No
Shared memory across your team Yes — one Postgres for the whole team Partial — via scoping workaround Yes — managed profiles No — per-user, per-machine
Works across Claude Code, Cursor, Copilot, and Codex CLI Yes Yes Yes No — Claude Code only
Open source, self-hosted Yes — Apache 2.0, your Postgres Partial — graph features paywalled No — managed only N/A — markdown files locally
Warns the agent before it suggests something you ruled out Cloud: yes, automatic.
Self-hosted: yes, via inject.		 No No No

Why structured lifecycle matters: Claude Code Auto-Memory can flag contradictions — but silently deletes the loser. RoBrain keeps both sides queryable so teams revisit reversals intentionally.

More detail and tradeoffs: Concepts — Comparisons.

⟲ 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)

What you interact with

Sensing MCP runs quietly inside your editor and fetches the always-on summary at session start. The robrain CLI is the manual surface for review, explain, synth, focused inject queries, and export-memory (Claude auto-memory and an optional git ledger).

Team ledger (opt-in)

npx robrain export-memory --ledger regenerates decisions.md for PR review; Postgres stays the source of truth. Separate from per-user Claude auto-memory under ~/.claude/projects/<slug>/memory/.

What starts with one Docker command

Run pnpm docker:up and RoBrain brings up Postgres (decisions + pgvector for retrieval) and the Perception API (extracts and stores decisions from session turns) in the background.

What runs on a schedule

Synthesis is the batch job: run npx robrain synth on demand or on a cron schedule so the whole corpus gets scanned for contradictions, drift, and recurring entities.

Cloud-only extras

Planning API and Control MCP add task-boundary relevance scoring and automatic injection on Rory Plans cloud.

⌂ Trust & privacy

Your conversation turns never leave your machine. 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’s Haiku API (you provide ANTHROPIC_API_KEY) 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:

Captured

  • Architectural decisions made during AI coding sessions
  • Rationale and rejected alternatives
  • Files in scope, timestamps, confidence

Not captured

  • Your source code or file contents
  • Secrets, passwords, or personal data
  • Anything outside your sessions with the agent

Convinced? Here's the path from zero to first capture — plan on one sitting from a fresh clone (Docker, keys, install, then init-project on your app repo).

⚡ Quick start

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.

One-time — RoBrain repo

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)"

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

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.

Already running self-hosted, or want the version with less manual lifting?

☁ Rory Plans cloud

Self-hosted gives capture, corpus-wide judgment, and the always-on summary at session start. When you need focused context beyond that block, you still pull it with inject.

Cloud adds Planning + Control — rejection warnings and conflict surfacing before the agent acts, without paste. Next up: linking decisions to outcomes (reverts, incidents, cycle time) so RoBrain can flag when a team is optimizing for the wrong thing in its own codebase.

Join early access Self-hosted vs cloud

◎ Documentation

Overview: README on GitHub. Deep dives: