Index the code.
Keep the rules.Answer in one query.

A model that has read everything knows nothing about your repo.

Training data contains every version of every library and none of your decisions. Left alone, an agent averages over all of it. These are the four ways that shows up in a diff.

Version contamination

The agent writes React 16 in a React 18 codebase. ContextBrain serves library docs filtered to the major version in your tech stack, so the wrong one is never in context.

Rules that evaporate

"Orders over $10k need manager approval" survives one session. Rules live in L2 with domain, priority and relationships to each other, and any agent can query them before it writes code.

Patterns nobody enforces

One agent uses the repository layer, the next writes raw SQL. Architecture patterns live in L3 and are boosted 1.5× in every search, so they surface ahead of everything else.

Knowledge that quietly rots

The rule was true six months ago. Knowledge is anchored to the files it describes, re-verified against current code, and reported as gaps, staleness and contradictions instead of being trusted forever.

Your agent is the brain. This is the memory.

ContextBrain does no reasoning about your task. It doesn't rank your intent, plan your work or summarise your code into something lossy. It stores, indexes and returns — the agent decides what to ask for and what to do with it.

Every fact belongs to exactly one layer.

The layer decides where a fact comes from, whether it can change, and how it is weighted at retrieval time. Nothing is stored without one.

The repository, parsed into symbols and edges.

Tree-sitter parses TypeScript, JavaScript, Python and Java — including .tsx and .jsx — into files, symbols, imports, calls and dependency edges. Everything else about your repo is built on top of that table.

Search that admits when it's stale.

Lexical and semantic search run against Elasticsearch and merge by reciprocal rank fusion. What comes back is graded, traceable, and checkable against the code it claims to describe.

Documents, diagrams and shared knowledge.

Point it at a repo. It stays current after that.

GitHub, GitLab, Gitea and Bitbucket, public or private. Credentials are encrypted at rest, and a push webhook can be registered for you so new commits re-index without anyone remembering to.

Every tool an agent can call.

Served over MCP, and each one also reachable from the cb command line. Single purpose, composable in any order, no hidden orchestration.

Add it to an agent in one config block.

The MCP server speaks streamable HTTP, so any MCP client — Claude Code, Claude Desktop, your own runner — connects with a URL and a key. People sign in through BitBot's device flow; agents and CI use a project API key.

// .mcp.json
{
  "mcpServers": {
    "contextbrain": {
      "type": "http",
      "url": "https://my.contextbrain.ai/api/mcp",
      "headers": {
        "X-API-Key": "proj_yourproject_…"
      }
    }
  }
}

# install; the checksum is verified before anything lands
curl -fsSL https://contextbrain.ai/cli/install.sh | bash

# sign in, pick a project, look around
cb login
cb project join myapp
cb status

# the same tools your agents call
cb symbols createOrder
cb impact src/services/order-service.ts
cb rules --domain billing
cb search "how do we handle refunds" -o json | jq

Boring infrastructure, on purpose.

A TypeScript monorepo: API, MCP server, background worker, web dashboard and CLI, over Postgres, Elasticsearch and Redis. Nothing in the hot path waits on a model.