RoBrain

Product Introduction

1. Definition: RoBrain is an open-source, self-hostable shared memory layer and AI agent orchestration tool specifically designed for software development teams. It operates as a systematic passive capture system that logs architectural decisions and their context during AI-assisted coding sessions.
2. Core Value Proposition: RoBrain exists to solve the problem of decision amnesia and context loss in multi-developer, multi-agent AI coding workflows. Its primary value is capturing every technical decision and, crucially, the rejected alternatives a team ruled out, then automatically surfacing this context to prevent re-litigation of past decisions and flag contradictions.

Main Features

1. Systematic Passive Decision Capture: RoBrain automatically monitors conversation turns between a developer and their AI agent (in Claude Code, Cursor, or GitHub Copilot setups) without requiring manual note-taking. It uses a local Perception API (powered by Anthropic's Claude Haiku model) to classify and extract structured decision objects, including the chosen path, rationale, and a structured rejected[] array of vetoed options with reasons.
2. Structured Memory with Veto Tracking: The core innovation is storing rejected alternatives as first-class, queryable structured data (JSONB in PostgreSQL) rather than burying them in prose. This enables semantic search and proactive warnings. Decisions are stored with lifecycle states (active, superseded), file associations, and confidence scores, creating an auditable timeline.
3. Cross-Tool Context Injection & Contradiction Detection: An always-on summary is automatically fetched at the start of every coding session via the Sensing MCP server, providing baseline context. For focused retrieval, the npx robrain inject CLI command performs semantic search. The batch Synthesis engine periodically scans the entire decision corpus to identify logical contradictions and thematic drift across sessions, flagging them for review via npx robrain review.

Problems Solved

1. Pain Point: Teams using AI coding assistants suffer from "agent reset," where each new session lacks memory of prior architectural decisions made by other team members or in past sessions, leading to wasted time re-discussing settled topics and introducing inconsistent patterns.
2. Target Audience: The primary user personas are engineering teams and tech leads who utilize AI-powered coding assistants (Claude Code, Cursor, Copilot) collaboratively on medium to large-scale projects. It is particularly valuable for distributed teams and projects with a lifespan exceeding six months, where decision history becomes critical.
3. Use Cases: Essential scenarios include: a new developer joining a project and needing instant historical context; preventing an agent from suggesting a library (e.g., Redux) that was previously rejected for a documented performance reason; and conducting an audit to understand why a particular architectural pattern (e.g., REST over GraphQL) was chosen months ago.

Unique Advantages

1. Differentiation: Unlike Claude Code's Auto-Memory (which is user-local and markdown-based) or generic memory systems like Mem0, RoBrain provides a team-shared, database-backed store focused exclusively on coding decisions with structured veto tracking. Unlike Zep, which is a general conversation memory and knowledge graph, RoBrain's schema is purpose-built for software decision lifecycle management.
2. Key Innovation: The combination of passive capture, the first-class rejected[] field, and the batch Synthesis engine for corpus-wide contradiction detection is unique. This allows RoBrain to move from simple recall to proactive governance, warning developers before they repeat a historically rejected approach.

Frequently Asked Questions (FAQ)

1. Does RoBrain send my code to an external service? In self-hosted mode, no. Conversation turns are processed by your local Perception API (Docker) and stored in your local PostgreSQL instance. The Rory Plans cloud version sends turns to a hosted API for extraction but does not retain raw conversation text after processing.
2. How does RoBrain compare to just using a CLAUDE.md file? A CLAUDE.md file is static, manual, and prone to staleness. RoBrain automatically captures decisions as they happen, tracks their validity over time (invalidating old decisions), supports semantic search by file or topic, and is shared across an entire team, not just a single machine.
3. What AI models and APIs does the self-hosted version require? The self-hosted OSS version requires two API keys: an ANTHROPIC_API_KEY for the Haiku model used by the Perception classifier, and a separate key for an embeddings provider (OpenAI, Voyage, or Cohere) used for the semantic search vector database.
4. Can RoBrain work with multiple code editors and AI agents? Yes, this is a core feature. Through its MCP (Model Context Protocol) server implementation, RoBrain's Sensing component can integrate with any MCP-compatible client. It is explicitly tested and supports Claude Code, Cursor, and GitHub Copilot-capable setups, enabling decision context to flow between different developers using different tools.
5. What happens when a decision is reversed or updated? RoBrain maintains a full decision lifecycle. When a new decision contradicts an old one, Synthesis flags it. Using npx robrain review, a user can resolve the conflict, which will mark the old decision as superseded and link it to the new, active decision. The history remains fully queryable, preserving the "why" behind changes.