Code intelligence, not grep
Code intelligence your agents cite, not grep.
RepoBrain indexes your repositories, any git repo, local or remote, and gives agents structure-first retrieval. A query returns the right lines of code with a file:line citation, not a file to read end to end.
RepoBrain · your code, mapped
In plain words
What it is, where it lives, when to reach for it
- What is it
- A code search index for your repositories that returns cited file and line snippets, not whole files.
- Where do I use it
- In the RepoBrain view of the dashboard, and from your terminal through the quox CLI.
- When would I use it
- When you or an agent needs to find where something lives in a codebase before reading files.
- How do I use it
- Run
quox nucleus query "<question>"in your terminal and read the cited file and line snippets.
Not a search box, a map
Not a search box. A map of how your code connects.
Grep finds strings. Vector search alone finds nearby text. Neither knows that a function is a definition, or that two files are connected by an import. RepoBrain indexes the structure up front, so a query returns the right code, not everything that happens to match.
Blind
Matches text, not meaning. It cannot tell a definition from a comment, so it returns whole files for an agent to re-read from scratch.
Guesses
Everything gets embedded and nothing gets weighed. Retrieval returns whatever is nearby, missing exact symbol names and import edges.
Indexes and connects
FTS5, a symbol index, and the import graph, together. It knows what things are and how they connect, so a query returns the right lines of code with a file:line citation, not a file to read end to end.
One index, four steps
Index any repo. Query it from anywhere.
Connect a repo once. RepoBrain builds the index in a single pass, Nucleus is the query face every agent calls, and the answer comes back grounded in your actual code.
Any repo
Local or remote, any git repo, picked from GitHub or pointed at a path.
RepoBrain
Builds FTS5, a symbol index, and the import graph, all in one pass.
Nucleus
The query face: `repobrain query "..."` from a CLI, or the governed API.
Agent
Gets the right lines of code, cited by file and line.
Index once, query as many times as you like, from a terminal, a script, or another agent.
Grounded, not guessed
Agents cite code with file and line, not guesses.
A structure-first query does not paraphrase an answer from memory. It returns real snippets, each tagged with the file, the line range, and the repo it came from, so a human or another agent can check the claim in seconds.
An agent that greps burns your context window on file dumps and then guesses; you pay for the tokens either way. Under the hood the retrieval is structure-first: FTS5, a symbol index, and the import graph.
The CLI is `repobrain query "..."`, targeting a single repo by default, or any repo with `-t <repo>`.
Explore the import graph
It sees the shape of your codebase.
This is demonstration data, not a live repo, but the shape is the same one you would see for real: files gathering by directory, hub files standing out as the ones most imported, and edges forming wherever an import actually connects two files.
Structure beats brute force
The right code, not a file dump.
A structure-first query returns the right lines of code, not a file to read end to end. Agents reach RepoBrain the same way every time: one shared tool, org-scoped, with the file and line attached to the answer.
One shared tool, every agent, no whole-file dumps burning the context budget.
You
Where do we validate the webhook signature?
querying RepoBrain
Agent
Signature validation happens in the webhook handler, before the payload is parsed, using a constant-time HMAC comparison against the stored secret.
tool repobrain_query("webhook signature validation")
The real interface
Query it from a CLI, or a governed API.
Not a mockup. Real output from two `repobrain query` runs against a live Quox codebase, captured tonight.
$ repobrain query "where is the AEE envelope schema defined"
→ src/lib/aee/envelope.js:41-90 (Definition of AEE)
→ src/lib/aee/envelope.js:361-410 (Matches: AEE, envelope)
→ src/lib/aee/envelope.js:161-210 (Matches: AEE, envelope)
$ repobrain query "what imports agentRegistry"
→ src/config/agentRegistry.js:1-50 (Definition of agentRegistry)
→ src/lib/aee/capabilities.js:1-50 (Definition of agentRegistry)
→ src/test/agentRegistry.test.js:1-50 (Contains agentRegistry)
Two real queries, six results, each an exact file and line range: no file to open and read end to end.
The difference that matters
Governed, org-scoped, provenanced.
A grep alias or a local index does not know who is asking or what they are allowed to see. RepoBrain does. Every query stays inside your organisation's connected repos, every result carries where it came from, and every request is logged as evidence, not just claimed.
Scoped
Results are limited to the repos your organisation has connected. Nobody queries across a scope they are not in.
Provenanced
Every snippet returned carries the repo, file, and exact line range it came from.
Licence-gated and audited
Access to the query API is gated per organisation, and every query is logged as governed evidence.
Watch it fill in
From first index to full graph.
Connect a repo and RepoBrain moves through the same stages every time, from a first pass to agents citing it every day, and finally into Brain2's own graph.
Connected
A repo is linked, local or remote, not yet indexed.
Indexed
FTS5, the symbol index, and the import graph are built in one pass.
Queried
Agents are citing file:line answers from it in everyday work.
Bridged
The index feeds Brain2: files as neurons, imports as axons.
Explore the import graph node by node above, or query it directly with `repobrain query "..."`.
What is live today
Live now, and in progress.
Live now
- Structure-first retrieval: FTS5, the symbol index, and the import graph
- The `repobrain query` CLI, with `-t <repo>` and cross-repo `-x a,b`
- Connect any repo, local or remote, including a GitHub picker
- The governed per-org API, scoped, provenanced, and audited
- The import graph explorer
- The Brain2 bridge: your codebase as neurons and axons in the living graph
In progress
- Deeper cross-repo ranking for the `-x` cross-repo query mode
- Broader language coverage for the symbol index
Straight answer: a cold query took 42 to 54 seconds against this instance tonight, and 22 seconds against the newer v2 host. Indexing is per target, not instant across every connected repo at once, and RepoBrain runs as a separate host from the agent asking the question, one that can be down: it was, earlier this evening.
Two brains
RepoBrain reads code. Brain2 remembers everything.
One plugin, two names, and a peer product it feeds. Here is what each part actually does, and where the lines are.
The code intelligence engine
Indexes any repo, local or remote, into FTS5, a symbol index, and the import graph. This is the product you enable and connect repos to.
The query face
What agents actually call: the `repobrain query "..."` CLI, or the governed per-org API. Same index, two ways in.
The memory layer
Remembers everything else: conversations, docs, team logs, evidence. Your codebase feeds into it as neurons and axons alongside everything it already knows.
How they fit: RepoBrain indexes your code and exposes Nucleus as the query face every agent calls, and the same index feeds Brain2, so your codebase shows up in the living graph as neurons and axons alongside everything else the platform knows.
The answer, cited
Ask where something lives, get file and line
- services/collector/lib/skillPackInstaller.js:237-241score 1.46
function resolvePackForCapabilities(enabledCapabilities) { const caps = sanitizeCapabilities(enabledCapabilities); if (!caps.includes('dev.register')) return null; return CORE_DEV_PACK; } - services/collector/lib/skillPackInstaller.js:406-409score 1.46
function buildStatusCheckCommand(pack) { const base = remoteBaseDir(pack.subdir); return `cat "$HOME/${base}/${PACK_VERSION_MARKER_FILE}" ...`; } - services/collector/lib/skillPackInstaller.js:427-428score 1.46
async function fetchPackVerification(packId, orgId) { const url = `${QUOXFLOW_URL}/api/skill-packs/${packId}/verify`;
How you get it
In the store today, and in the bundle
On its own
RepoBrain is the founding Dev Suite member and the proof the model works: a live store listing paid for by real customers, installed on your own QuoxCORE instance with the quox CLI verbs included.
In the Dev Suite
RepoBrain also belongs to the Dev Suite, alongside the plan, the loops, the verdict and the rest of the toolbox. The suite does not have its own store listing yet, so today you buy the members you want individually.
Give your agents code they can cite.
Connect a repo, index it once, and query it from anywhere. Every agent gets targeted snippets with file and line, not a whole file to read end to end.