The RoBrain server captures and manages AI agent conversations, acting as a central memory system that extracts structured decisions, detects contradictions, and prevents agents from re-proposing rejected approaches.
Core session tools:
sensing_start_session: Initialize a new session with a project ID and working directory. Returns a unique session ID and an always-on project summary (prior decisions, vetoes, etc.) to inject into the agent's context.
sensing_record_turn: Log each user-assistant exchange, including messages, optional file list, and memory IDs. Buffers turns for Perception processing and returns whether a topic shift was detected (prompting fresh context injection).
sensing_end_session: Signal session completion, flushing buffered turns to the Perception service for decision extraction and storage in Postgres.
sensing_get_status: Query the current sensing buffer state for debugging purposes.
Broader capabilities (via the Perception service):
Decision extraction: Processes captured turns to extract structured decisions and explicitly rejected alternatives, storing them with lifecycle states (active, superseded, invalidated).
Corpus judgment: Runs batch Synthesis to identify stance drift, contradictions, and promotes recurring entities into planning blocks.
Veto scans (POST /veto-scan): Deterministic scans to block re-proposals of rejected approaches.
Relevance scoring (GET /decisions?query=): 5-signal scorer for retrieving relevant past decisions.
Security: Authenticates via PERCEPTION_API_KEY and redacts secrets at capture and ingest stages.
Local mode: Supports fully-local LLM and embeddings (e.g., Ollama, LM Studio, vLLM).
Integrates with GitHub Copilot in VS Code to capture session turns and surface prior decisions.
Provides a memory-provider plugin for the Hermes agent, enabling passive capture and veto-aware recall.
Shared memory across your team and your AI agents — with judgment!
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), Codex CLI, Hermes and more.
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.
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.
Related MCP server: Axiom-hub
Two ways to run RoBrain — pick one:
Option 1 · Self-hosted (free, open source): everything runs on your machine — your Postgres, your API keys, nothing leaves your laptop.
Option 2 · Rory Plans cloud (managed): nothing to host, no keys — included with every paid Rory Plans plan.
No clone needed — robrain up pulls the published Perception image and generates credentials into ~/.robrain/stack/.env.
Default path uses Anthropic (extraction) + OpenAI (embeddings). Other setups (OpenAI-only, Gemini, other embeddings, fully local) — Concepts — Prefer a different provider setup?.
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 editorsFirst pnpm docker:up auto-creates .env and fills PERCEPTION_API_KEY / POSTGRES_PASSWORD. Perception still needs your LLM + embedding keys before it stays up.
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 LLM + embedding keys for the provider path you chose (default: ANTHROPIC_API_KEY + OPENAI_API_KEY)
pnpm docker:up # second run: Perception now boots
pnpm robrain install --self-hosted --repo-root "$(pwd)"pnpm robrain runs the CLI you just built (node packages/cli/bin/robrain.js).
Use it instead of npx robrain everywhere in this clone — npx resolves to the
published package or a stale global install, not your working tree.
No-clone stack: re-run npx robrain@latest up (pulls the new Perception image and applies startup DB migrations) then npx robrain@latest install --self-hosted. From a clone: git pull → pnpm install && pnpm build → pnpm docker:up:build → pnpm robrain install --self-hosted --repo-root "$(pwd)" → fully restart editors. Full checklist: CLI reference — Upgrading.
Claude Code users on the self-hosted stack can add hook-based capture and pre-task warnings about previously rejected approaches — no CLAUDE.md protocol needed:
claude plugin marketplace add adelinamart/robrain
claude plugin install robrain@robrainDetails: plugins/claude-code. robrain init-project also recommends the plugin to collaborators via the project's .claude/settings.json, so teammates get an install prompt from Claude Code itself (opt out with --skip-claude-plugin).
On any paid Rory Plans plan, RoBrain runs without hosting anything:
npx robrain install # no flags — cloud modeSign in at roryplans.ai, create an API token on your profile page, and paste it when the installer asks. That's the whole setup: no Docker, no database, no LLM or embedding keys — extraction and search run on our side. Your editors (Claude Code, Cursor, Copilot, Codex CLI) are wired automatically, and teammates on your Rory Plans team share the same memory.
Every paid plan qualifies — individual standard or annual, Teams, and enterprise. Solo subscribers get a private memory space; teams share one. Self-hosting stays free and fully supported (see Install above); the comparison table shows what each tier adds.
After either install (self-hosted or cloud):
# Wire capture into an application project (run inside the repo)
cd /path/to/your/project
npx robrain init-project # writes CLAUDE.md, AGENTS.md, .cursor/rules/robrain.mdc
# Capture and recall are automatic from here:
# - every session turn is classified, no tagging
# - prior decisions load at session start via the always-on summary
# Explain any file's decision history
npx robrain explain path/to/file
# Inspect / approve captured rows (both modes)
npx robrain review
# Run corpus judgment — self-hosted only; cloud runs judgment server-side
npx robrain synth # drift, contradictions, entity promotionAfter init-project, every repo gets CLAUDE.md and AGENTS.md (Codex CLI), and Cursor also gets .cursor/rules/robrain.mdc with alwaysApply: true. If captures don't land, run npx robrain doctor — see Troubleshooting.
Synthesis runs three passes over the full decisions table — drift (stance moving without an explicit reversal), contradictions (incompatible decisions from different sessions), and entity promotion (recurring tools/patterns condensed into planning_blocks). It writes flags and edges into your DB; it does not capture new decisions — it judges the corpus you already have.
pnpm synthesis:build && pnpm synthesis:run
# or: npx robrain synthReview what it finds with npx robrain review. Deep dive (three passes, cron, env vars): Concepts — Synthesis.
One cross-tool setup covers Claude Code, Cursor, GitHub Copilot (VS Code), and Codex CLI against the same Postgres store. The classifier LLM is your choice — Anthropic Haiku or OpenAI. Decisions carry a lifecycle (active / superseded / invalidated) and a graph (conflicts_with / extends / related_to).
Codex CLI / IDE also gets hook-based capture and pre-task veto warnings — the same lifecycle hooks as the Claude Code plugin, wired automatically by robrain install into ~/.codex/config.toml (Codex asks you to trust them on first run). Docs: plugins/codex.
Running Hermes? npx robrain install --hermes drops a standalone memory-provider plugin into ~/.hermes/plugins/ — passive capture and veto-aware recall through the same Perception API. Docs: integrations/hermes.
Decision ledger for git (opt-in):
npx robrain export-memory --ledger
# custom path: npx robrain export-memory --ledger docs/decisions.mdVersus Mem0, Cloudflare Agent Memory, and Claude Code Auto-Memory: only RoBrain stores rejected alternatives as structured fields and runs corpus-wide contradiction scans (manual or cron). And we measured what that difference costs: VetoBench found Mem0's ingestion dropped the recorded rejection from 38% of retrieved contexts on identical input. Full comparison →
Feature | Free / self-hosted | Rory Plans cloud |
Passive session capture | ✓ | ✓ |
| ✓ | ✓ |
Decision lifecycle (active / superseded / invalidated) | ✓ | ✓ |
Cross-tool MCP — Claude Code, Cursor, Copilot, Codex CLI, Hermes | ✓ | ✓ |
Classifier LLM choice — Anthropic Haiku or OpenAI | ✓ | ✓ |
Always-on summary at session start | ✓ | ✓ |
| ✓ | ✓ |
Synthesis — drift, contradictions, entity promotion | ✓ | ✓ |
Synthesis prompt rubrics — per-project overrides ( | ✓ | ✓ |
Decision graph ( | ✓ | ✓ |
Provenance on every memory — source session, turn, excerpt; compiled blocks carry source decision ids | ✓ | ✓ |
Memory quality feedback — used/ignored counters, auto-demotion | ✓ | ✓ richer: helpful/pushback per injection |
Outcome linking — git reverts feed back into memory rank | ✓ | ✓ |
Secrets redaction at capture and ingest | ✓ | ✓ |
Memory interchange export ( | ✓ | ✓ |
Open retrieval eval + VetoBench gates in CI | ✓ | same scorer |
Self-host on your infrastructure | ✓ | — |
Your data stays local | ✓ | processed remotely |
Fully-local mode — LLM + embeddings on Ollama/LM Studio/vLLM | ✓ | — |
Calibrated extraction prompt (fewer false positives) | — | ✓ |
Calibrated 4-way contradiction taxonomy | — | ✓ |
Automatic injection at task boundaries | — | ✓ |
Deterministic veto scan ( | ✓ | — |
Pre-task | Claude Code (plugin) + Codex (hooks) + Hermes (provider) | ✓ everywhere |
Disengagement protocol (⚠ acknowledgement) | — | ✓ |
Pre-commit conflict verdict ( | — | ✓ |
5-signal relevance scorer | ✓ on retrieval ( | ✓ applied automatically per task |
Conflict auto-resolution (guard-railed) + dashboard visualizations | — | ✓ |
Vetoes survive supersession — rejection history follows the newest decision | ✓ | ✓ full history merge |
Write-time supersession detection — "we switched X→Y" never dedups away | — | ✓ |
Decision lineage timeline (API + dashboard) | — | ✓ |
Team memory — orgs, API keys, roles, scoped isolation | — | ✓ |
Web dashboard | — | ✓ |
Self-hosted gives capture, judgment batch jobs, outcomes feedback, and session-start recall; you pull focused context with inject when needed. Cloud adds Planning + Control so vetoes and conflicts surface automatically at task boundaries — same CLI surface, wire-compatible with Sensing capture. Details: Concepts — Free / self-hosted vs Rory Plans cloud.
Memory benchmarks usually ask "did the right item come back?" VetoBench asks what that misses: given a task that invites an approach the team already rejected, does the agent propose it again?
Memory condition | Re-proposed a rejected approach | Could cite the prior rejection |
No memory | 8–9 of 10 tasks | 0–10% |
Conventions file (choices only — what most teams have today) | 1–2 of 10 | 80–90%, but inferred: the reasons aren't there |
Mem0 — full pipeline, 5 archived runs | 0–2 of 10 per run | 50–90% |
RoBrain — full pipeline, 5 archived runs | 0 of 10, every run | 100% |
(claude-haiku-4-5, 2026-07-07/08; every condition measured as a five-run archived series, ranges because runs vary. Mem0 and RoBrain ingested byte-identical transcripts, each through its own real production extraction.)
Two findings behind the table. Mem0's ingestion dropped the recorded rejection from 38% of retrieved contexts, and violations concentrated exactly there — 26% when the veto was absent vs 3% when present: the agent avoided Express in all five runs but could never say why, and where the axios veto was lost it re-proposed axios outright in 3 of 5 runs. RoBrain's production extractor, on the same input, kept 100/100 vetoes — keeping the veto is the extraction prompt's job, not a side effect of fact summarization.
Meta Muse Spark 1.1 (2026-07-14, five archived runs). Meta's newly launched agentic flagship, via Vercel AI Gateway. Without memory it re-proposed rejected approaches in 4–6 of 9 tasks per run — Redux, Prisma, Jest, and GraphQL in all five runs. With RoBrain decision memory: 0 violations in all 45 cells, naming the prior rejection every time — quoting the recorded reason and date verbatim where it elaborated. The cleanest cell: asked to cut mobile overfetching, the no-memory run proposed a full GraphQL rollout (the approach the team had ruled out) five runs out of five; with RoBrain in context it proposed REST sparse fieldsets and quoted the recorded rejection. Honest notes: this is not a Muse Spark problem — every frontier model we baselined violates without memory on the same nine scenarios (claude-opus-4.8: 3–4, gpt-5.5: 5, gemini-3-pro-preview: 6–7, Haiku 7–8; Prisma and Jest fell to every model in every run — and with RoBrain context those same three models went 0 violations in 54/54 cells, for 99/99 across four vendors — receipts), a bare conventions file also prevented violations for this model at this corpus size (the RoBrain delta is verbatim citations vs inferences, automatic capture, and retrieval at scale), and one scenario is excluded (n=9) because Meta's content filter deterministically blocks a benign session-caching prompt. Receipts and caveats: results/muse-spark-1.1-series/ · write-up: docs/blog/2026-07-14-muse-spark-forgets-your-vetoes.md.
Every retrieved context, agent reply, and verdict is committed in packages/vetobench/results/ — check the work before quoting it. The retrieval layer runs offline with no API key and gates CI (pnpm --filter @robrain/vetobench bench); judging is deterministic — no LLM judge. Any memory system plugs in through one adapter interface; PRs welcome, including ones that make us look bad. Methodology, honesty caveats, and fixtures: packages/vetobench/README.md.
The memory corpus is guarded by PERCEPTION_API_KEY — a random secret in the repo-root .env that every client (Sensing MCP, CLI, Synthesis) sends as a Bearer token and Perception verifies on every request except /health. It is not issued by any service: pnpm docker:up generates one automatically on first run, or set your own (e.g. openssl rand -hex 32). Installing (pnpm robrain install --self-hosted from a clone, npx robrain install --self-hosted otherwise) copies the same value into your editor configs so clients authenticate.
Perception refuses to start when the key is empty — running unauthenticated requires an explicit opt-in. Upgrading from a version that ran without a key: add one to .env (or re-run pnpm docker:up to auto-fill it), then re-run install (pnpm robrain install --self-hosted from a clone, npx robrain install --self-hosted otherwise) so editors pick it up. Details and the opt-in flag are documented in .env.example.
Also on by default: secrets redaction (API keys, tokens, private keys, connection-string passwords are scrubbed at capture and again at ingest, before anything is embedded or stored), and a fully-local mode where extraction and embeddings run on an OpenAI-compatible local server (Ollama / LM Studio / vLLM) — see CLI — Fully-local LLM and .env.example.
robrain outcomes feeds git reverts back into memory quality on both tiers; next is widening that to incidents and cycle time, so RoBrain can surface when a team is optimizing for the wrong thing in its own codebase.
Docker + Docker Compose (runs Postgres and Perception locally)
Node.js with pnpm (build and CLI)
An LLM key for the classifier — Anthropic Haiku or OpenAI — or a local OpenAI-compatible server (see Fully-local LLM)
An embedding key (e.g. OpenAI) — or the same local server for embeddings
No data leaves your machine in self-hosted mode
Concepts (how it works, two pillars, Synthesis, comparisons) → docs/concepts.md
CLI reference (explain, install, upgrading, editor setup, full command table) → docs/cli.md
Fully-local LLM (Ollama / LM Studio / vLLM, no cloud keys) → docs/cli.md#fully-local-llm-ollama--lm-studio--vllm
Maintainer release checklist (tag → GHCR → npm → MCP registry) → docs/release.md
Troubleshooting (silent 401s, Docker rebuilds, stale summaries, local LLM) → docs/troubleshooting.md
Memory interchange format (robrain export, robrain-memory/v1 JSONL) → docs/memory-interchange.md
VetoBench (does memory stop rejected re-proposals? methodology + archived receipts) → packages/vetobench/README.md
Claude Code plugin (hook-based capture + veto warnings) → plugins/claude-code/README.md
Codex CLI hooks (same lifecycle hooks, wired by robrain install) → plugins/codex/README.md
eve agents (Vercel's agent framework — dynamic-instructions memory, veto tool, capture hook; verified against eve dev) → plugins/eve/README.md
Hermes agent plugin (memory-provider, capture + veto warnings) → integrations/hermes/robrain/README.md
Apache 2.0. PRs welcome for extraction accuracy, new editor integrations, and embedding providers. See Concepts — Reference for tradeoffs and schema.
Apache 2.0 — see LICENSE
Built by Rory Plans
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.
| Name | Required | Description | Default |
|---|---|---|---|
| summary | No | Optional brief summary of what was accomplished this session | |
| session_id | Yes | Session identifier from sensing_start_session |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It discloses the side effect (flush-on-close hook shipping buffered turns), which is valuable beyond what the input schema provides. However, it does not mention idempotency or error states, which would push it to a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no unnecessary words. The first sentence immediately states the purpose, and the second provides necessary behavioral detail. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description explains the core action and side effects adequately. It is missing details on return values or potential errors, but for a simple end-session tool, the current description is reasonably complete. A 5 would require explicit return information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters are already described in the schema. The description adds no new semantic meaning beyond what the schema states (e.g., 'Optional brief summary' is identical). Baseline is 3, and there is no justification to raise it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Signal the end') and resource ('Claude Code session') and explains the triggering of a flush-on-close hook. It distinguishes from siblings like sensing_start_session (which starts a session) and sensing_record_turn (which records turns), leaving no ambiguity about the tool's role.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use at session closure but provides no explicit guidance on when to use versus alternatives, such as when not to use it or prerequisites (e.g., session must be started). An agent can infer from context, but the lack of explicit statements lowers the score from a 4.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the current status of the Sensing buffer for a session. Useful for debugging.
| Name | Required | Description | Default |
|---|---|---|---|
| session_id | Yes | Session identifier |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must disclose behavioral traits. It indicates a read-only operation (getting status) but does not explicitly confirm no side effects, permissions needed, or return format. Minimal transparency beyond the action itself.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise with two short sentences, no filler, and front-loaded with the key action. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description covers basic purpose but lacks detail on what the status contains or how the buffer works, which may be needed for debugging. Adequate but not thorough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already describes the single parameter 'session_id' as a session identifier. The description adds nothing beyond restating that it applies 'for a session', providing no new semantic detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'status of the Sensing buffer for a session'. It distinguishes from sibling tools (end, record, start) by focusing on status retrieval, and provides context for use ('useful for debugging').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers only a vague usage hint ('useful for debugging') without specifying when to use this tool over siblings or any exclusions. There is no comparative guidance or condition for use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| sequence | Yes | Turn number within the session, starting at 1 | |
| session_id | Yes | Session identifier from sensing_start_session | |
| claude_reply | Yes | The full Claude reply text | |
| user_message | Yes | The full user message text | |
| files_touched | No | Files read or modified during this turn | |
| injected_memory_ids | No | IDs of memories Control injected before this turn, for feedback scoring |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool survives server restarts and returns a topic shift flag. However, it could elaborate on persistence guarantees or error scenarios.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tightly written sentences with zero waste. Each sentence adds distinct value: purpose/frequency, cross-session behavior, return value and follow-up action. Front-loaded with the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explains the return value (topic shift boolean) and its implication. It also clarifies the purpose of less obvious parameters like injected_memory_ids. Sibling tool names provide context for the tool's role in a workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions, but the description adds useful context: session_id origin, sequence starting at 1, files_touched as files read/modified, injected_memory_ids for feedback scoring. This enhances understanding beyond schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'record' and the resource 'completed conversation turn', specifying its content (user message + Claude reply). It distinguishes itself from sibling tools (sensing_start_session, sensing_end_session, sensing_get_status) by focusing on recording individual turns rather than session lifecycle.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Call this after every exchange', providing clear when-to-use guidance. Also advises to keep the same session_id across server restarts and explains the conditional follow-up (if topic shift detected, call context injection tool).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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).
| Name | Required | Description | Default |
|---|---|---|---|
| project_id | Yes | Repository name or path hash identifying the project | |
| session_id | No | Unique id for this session. Omit, use null, or "" to let the server generate one (recommended). Otherwise supply a fresh id per chat (e.g. ISO timestamp + 4 hex chars). | |
| working_dir | Yes | Absolute path to the project root directory |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full weight. It discloses that the tool returns a project summary and a session id, and notes that session_id generation is server-side. However, it doesn't mention potential side effects (e.g., creating records) or error states, leaving some behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first states purpose and return, the second provides session_id guidance. It is front-loaded, contains no filler, and every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters, no output schema, and moderate complexity, the description sufficiently explains the tool's role and key behaviors (return of summary and id). It could elaborate on the summary content, but is adequate for an agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all 3 parameters with descriptions (100% coverage). The description adds value by explaining that session_id may be omitted for server generation and that the returned id must be used in sibling calls, which is not in the schema. This extra context improves parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Signal the start of a new Claude Code session.' It uses a specific verb ('signal') and resource ('session'), and distinguishes it from siblings like sensing_end_session and sensing_record_turn by specifying it is called once at the beginning.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says 'Call this once at the beginning of every session,' providing clear when-to-use guidance. It also explains that session_id can be omitted, and that the returned id should be used with sibling tools. It doesn't explicitly mention when not to use or alternatives, but the context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0sensing_end_sessionsensing_get_statussensing_record_turnsensing_start_sessionEach tool has a clearly distinct purpose: start session, record turn, get status, end session. No overlap or confusion.
All tools follow the consistent pattern 'sensing_verb_noun' using snake_case, making them predictable.
Four tools cover the essential session lifecycle (start, record, status, end) without unnecessary extras.
The tool set fully covers session management for sensing, including turn recording and topic shift detection, with no obvious gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Self-hostable shared brain for you and your AI agents — docs, flows, meetings, decisions, rationale
Decision memory for AI agents: record, revisit, and resolve consequential choices.
Shared memory for coding agents. Stop re-explaining your codebase every session.
Persistent memory for AI agents. EU-hosted, privacy-first, hybrid recall, contradiction detection.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/adelinamart/robrain'
If you have feedback or need assistance with the MCP directory API, please join our Discord server