Setup in one command
Sign in at roryplans.ai, create an API token on your profile page, then run the installer and paste the token when it asks. Claude Code, Cursor, GitHub Copilot and Codex CLI are wired automatically. No Docker, no database, no LLM or embedding keys: extraction and search run on our side.
npx robrain install # cloud mode: paste your token when asked
cd /path/to/your/project
npx robrain init-project # writes CLAUDE.md, AGENTS.md, .cursor/rules/robrain.mdcFrom here capture is automatic: every session turn is classified, nobody tags anything, and prior decisions load at session start. The CLI is the same one self-hosted users run, and the dashboard covers the same memory in the browser: everything you can do is listed below. Judgment (contradictions, drift, entity promotion) runs server-side, so there is no synth job to schedule.
Each machine you install on gets its own key, so setting up a second laptop does not sign out the first. One account can have up to ten. A machine you have not used for 90 days is signed out the next time you install. Run the installer on it again to bring it back.
On Claude Code, add the plugin (claude plugin install robrain@robrain); on Codex the installer wires the same hooks. On a cloud install they check every prompt against ranked memory and prior rejections whether or not the model asks, and score each reply against what was injected.
Production agents on eve
Install @robrain/eve and declare one memory slot. Set ROBRAIN_API_URL to https://api.roryplans.ai and ROBRAIN_API_KEY to a Rory Plans API token from your profile page. Do not reuse the key the installer saved on your laptop: every new install replaces it. The agent name gives the agent its own memory project the first time it runs; the tags say what kind of agent it is.
// agent/memory/robrain.ts
import { robrainMemory } from "@robrain/eve";
import { defineMemory } from "eve/memory";
export default defineMemory({
description: "The team's engineering decisions, including rejected alternatives and why.",
provider: robrainMemory({
apiKey: () => process.env.ROBRAIN_API_KEY,
agent: { name: "support-agent", tags: ["support"] },
}),
scope: "team",
});At turn start the agent gets the project summary plus veto warnings for the incoming message, with a required acknowledgement when a warning comes from a decision nobody has reviewed yet. During the turn it can call check_prior_decisions before it proposes an approach. At turn end the turn is shipped for decision extraction. The provider never throws into a turn: if the API is unreachable the agent carries on without memory.
Memory is only half of it. Cloud is where the team decides what its agents must follow.
Governance for production agents
Self-hosted RoBrain keeps one project per repository, on purpose. Cloud adds a memory project per production agent and one org rules project above them, so a rule your team made while building reaches the agents that run in production, with its reason and its author attached. Coding projects do not read org rules.
1. The agent registers itself
The first recall or capture creates project agent-support-agent-<hash>. Everything the agent decides, every run it records and every rule pushed to it lives there. The project is typed as an agent project: only org admins can change what it captures.
2. The team decides, as usual
Decisions and rejections are captured passively from coding sessions, each with the author's identity and date. Rules can also be written by hand with robrain rules add, stored with confidence 1.0 and approved on insert.
3. An admin searches and pushes
Push a decision to every production agent, to every agent with one tag (including agents registered later), or into one project. The copy keeps the text, the rejections and the author, and records who pushed it and when. Invalidating the original later does not touch the copy.
npx robrain search "never auto-send"
npx robrain promote <decision-id> --to tag:support # or --to production-agents, or --to <project-id>4. Tags come from the tools an agent uses
Declare tags in the agent's config, set them as an admin, or derive them: the provider reports the tools an agent calls every turn, an admin keeps one tool-to-tag mapping per org, and the tag applies once a matching tool was used in three turns. Admins can remove a derived tag.
npx robrain tags map add "send_email*" email
npx robrain projects tag <project-id> support eu5. Everything is on the record
Who registered an agent, who pushed which rule where, who tagged or changed what: every governance action lands in a ledger with the identity of the signed-in person, never a client-sent name. Org rules sit at the top of each agent's summary, so a new rule reaches a quiet agent on its next turn. Any member can read the ledger with robrain auditor on the dashboard's Activity page.
Everything you can do
One row per thing you can do, with the command for it and where it lives in the dashboard. A dash means that surface does not have it yet.
| What you want to do | CLI | Dashboard |
|---|---|---|
| Set up | ||
| Connect your editors | npx robrain install | |
| Start remembering a repository | npx robrain init-project | |
| Check that everything is connected | npx robrain status npx robrain doctor | |
| Review what was captured | ||
| Approve, edit or reject captured decisions | npx robrain review | Decisions |
| Release what trust screening held back | npx robrain review --quarantined | |
| Search memory, with who decided and when | npx robrain search "<query>" | Decisions, with filters |
| Settle two decisions that contradict each other | npx robrain review | Conflicts |
| See what a decision replaced and what replaced it | npx robrain lineage <decision-id> | Lineage |
| See which memories help and which get pushed back on | Effectiveness | |
| Understand why a file is the way it is | npx robrain explain <file> | |
| Pull context for a task to paste into an agent | npx robrain inject --query "..." | |
| Check before you act | ||
| Check a proposal against prior rejections | npx robrain check "<proposal>" | |
| Check it for contradictions with stored decisions | npx robrain check "<proposal>" --conflicts | Pre-flight check |
| Write rules and decide what gets captured | ||
| Write a rule by hand | npx robrain rules add "<rule>" | |
| Say in plain language what to store or skip | npx robrain capture set --instructions "..." | |
| Store other kinds of memory, such as runs or preferences | npx robrain capture set --add-kind "run: ..." | |
| See the settings, or try them on sample turns first | npx robrain capture show npx robrain capture test | |
| Govern production agents (admins) | ||
| Push a decision to every agent, one tag of agents, or one agent | npx robrain promote <decision-id> --to production-agents | tag:<tag> | <project-id> | |
| See or set an agent's tags | npx robrain projects tag <project-id> [tags] | |
| Map the tools an agent uses to tags | npx robrain tags map add "<tool pattern>" <tag> | |
| See who changed what (every member can read it) | npx robrain audit | Activity |
| Projects and data | ||
| List, create or merge projects | npx robrain projects list | create | merge | Project filter |
| Feed git reverts back into ranking | npx robrain outcomes | |
| Take everything with you as JSONL | npx robrain export | |
| Mirror approved decisions into Claude Code memory or a file in the repo | npx robrain export-memory | |
Not needed on cloud: robrain synth (judgment runs on our side every night) and robrain up (that starts the self-hosted stack). Every flag: CLI reference.
What agents get without anyone running a command
- Every editor: each turn is captured, the project summary loads at session start, and at each task boundary Control hands the agent the memories ranked for the task plus any veto warnings.
- Claude Code and Codex: hooks run the same check on every prompt and score each reply against what was injected.
- Production agents on eve: summary and veto warnings at turn start, capture at turn end, and a
check_prior_decisionstool to call before proposing an approach.
What cloud adds to the open-source stack
Same Sensing capture, same CLI, same rejected[] substrate. The hosted API adds the layers that make memory arrive on its own and keep a team honest about who decided what.
- Automatic injection at task boundariesPlanning scores what is relevant to the current task with the same 5-signal scorer self-hosted exposes on retrieval; Control injects it in every editor without a manual
inject, and in Claude Code and Codex the hooks do it on every prompt. - Conflict detection with acknowledgementWhen a new decision contradicts an older one, the agent sees the prior choice, the rejected option and the reason at the next task boundary, and must acknowledge it before proceeding.
- Pre-commit conflict verdict
robrain check --conflicts(or/dry-run) returns a verdict on a proposal before it lands: each close stored decision is labelled contradicts, extends, related or unrelated, so a contradiction is caught even when it names no rejected option. - Who decided, verifiedThe author on every decision is the signed-in identity from org membership, shown in review, search, the summary and veto warnings. Self-hosted uses the git
user.emailof the session. - Team memory and rolesOrgs, API keys and roles. Members read and capture; admins govern agent projects, push rules and manage tags. Solo subscribers get a private memory space; teams share one.
- Write-time supersession and lineage"We switched X to Y" is detected when it is written, never deduplicated away, and every decision carries a lineage timeline in
robrain lineage, the API and the dashboard. - Calibrated extractionA calibrated extraction prompt and a 4-way contradiction taxonomy, fewer false positives.
- Web dashboardReview captures, settle conflicts, follow lineage, see which memories help, and read the governance activity in the browser, not only in the CLI.
Self-hosted vs RoBrain Cloud
| Capability | Free / self-hosted | RoBrain Cloud |
|---|---|---|
Passive session capture + structured rejected[] | ||
| Decision lifecycle (active / superseded / invalidated) + graph | ||
| Cross-tool MCP — Claude Code, Cursor, Copilot, Codex CLI, Hermes | ||
| Always-on summary at session start | ||
| Synthesis — drift, contradictions, entity promotion | ||
| Provenance on every memory + secrets redaction | ||
| Who decided — author and date on every decision, in review, search, the summary and veto warnings | git user.email | signed-in identity, never client-sent |
robrain search and hand-written rules (rules add) | ||
Production agent memory — a project per eve agent, rules pushed to all agents, one tag, or one agent (promote), tags derived from the tools an agent uses | ||
Governance ledger — who registered, pushed, tagged or changed what (robrain audit, dashboard) | ||
| Outcome linking — git reverts feed memory rank | ||
| Memory quality feedback — used/ignored counters, auto-demotion | + helpful/pushback per injection | |
| Memory interchange export + VetoBench CI gates | same scorer | |
| Self-host on your own infrastructure — data stays local | processed remotely | |
| Fully-local mode — LLM + embeddings on Ollama / LM Studio / vLLM | ||
| Automatic injection at task boundaries | manual inject | |
Deterministic veto scan (robrain check, POST /veto-scan) | ||
Pre-task rejected[] warning before the agent acts | Claude Code (plugin), Codex (hooks), and Hermes (provider) | everywhere |
Pre-commit conflict verdict (robrain check --conflicts, /dry-run) | ||
| 5-signal relevance scorer | on retrieval | applied automatically per task |
| Calibrated extraction prompt (fewer false positives) | ||
| Vetoes survive supersession — rejection history follows the newest decision | full history merge | |
| Write-time supersession detection — "we switched X→Y" auto-resolves | ||
Conflict auto-resolution + decision lineage timeline (robrain lineage, dashboard) | ||
| Team memory — orgs, API keys, roles, scoped isolation | ||
| Web dashboard |
Full breakdown: Concepts, self-hosted vs cloud. Commands: CLI reference.
What we store, and what we do not
Stored
- Extracted decision objects: the decision, rationale, rejected alternatives, confidence
- Provenance: author identity, date, session and turn, a short excerpt, file paths in scope
- Governance events: who pushed, tagged or changed what, and when
Not retained
- Raw conversation text after extraction
- Full file contents
- Secrets: API keys, tokens, private keys and connection-string passwords are scrubbed at capture and again at ingest
Turns are processed on our side, so pick self-hosting when nothing may leave your machine; it stays free and fully supported. There is no lock-in either way: export the whole corpus as robrain-memory/v1 JSONL at any time with npx robrain export. Details and third-party processors: Privacy Policy.
Plans
RoBrain Cloud is included with every paid Rory Plans plan: individual standard or annual, Teams, and enterprise. Solo subscribers get a private memory space; a Teams org shares one memory across its members and its production agents. Rory Plans is the Cloud Office where humans and AI agents plan and work together; RoBrain is its memory and governance layer, open source and self-hostable forever.
Self-host when you want everything on your own infrastructure. Choose cloud when you want nothing to host, memory shared across the team, and rules that reach your production agents with a name and a date attached.
Get started
npx robrain install