Build 9 months ahead.
Without being Ruv.

Meet Maya — a capable developer, brand-new to rUv’s tools. She opens Claude Code and asks the obvious thing: “Set up vector search for this project using RuVector.”

Without the Brain. Claude has never been trained on RuVector. So it does what classical training taught it — it reaches for Pinecone, or pgvector, or hand-rolls cosine similarity in JSON. It even gently argues with her: “a managed vector DB would be more standard.” Maya, nervous and new, assumes Claude knows best. She ends up far from rUv’s actual stack — slower, heavier, wrong.

With the Brain. Claude reads rUv’s real RuVector source first, sees RVF binary vector files + HNSW, and writes the correct RvfDatabase.open(...).query(...) code — the way rUv would. No argument. No drift. Maya ships the front-edge version on her first try.

Technical view — the same question, two paths

Claude is trained on the public history of software — millions of classical-dev examples. rUv works ~9 months ahead of that frontier.

His tools are the prototypes of what becomes mainstream AI tooling — much of it lands in Claude Code 8–9 months later. So when you ask Claude to use today’s front-edge rUv tool, you’re asking about its own future — and it defaults to the past it was trained on. It doubts. It substitutes. It “falls asleep at the switch.”

This is not Claude being dumb. It’s a training-horizon problem. The newcomer gets the worst of both worlds: a revolutionary toolset with no manual, and an assistant that argues against it.

Technical view — the timeline, and the gap

Plenty of people tried to build a RuvNet knowledge base so AI could use rUv’s tools. They failed — not from lack of effort, but wrong architecture.

What failed: flat JSON embeddings + naive RAG + matching on repo names. Ask “how do I do cheap LLM routing” without naming the repo and it returns nothing useful. Brittle, shallow, drifts.

What we did differently — why this one passes:

1. RuVector .rvf single-file HNSW — the whole vector index is one file: no server, no Docker, crash-safe (a crash never permanently corrupts it), and post-quantum-signed. Real HNSW search in rUv’s own format — not hand-rolled cosine over JSON.
2. Dual embeddings — MiniLM-384 and bge-768, plus a cross-encoder rerank. Two readings of meaning catch what a single keyword match misses.
3. Source-chunked, not doc-scraped — 75,509 chunks of rUv’s real source code, not docs or a blog about the code. The brain knows the actual lines.
4. Capability cards — the breakthrough. A high-signal “what this tool is FOR” card per building block, so a newcomer who describes a need (“grade research for trustworthiness”) routes to the right repo without knowing its name.

The measured result: routing by described need went from 33% → 96%. That jump is the architecture difference.

Technical view — their architecture vs this one

No. It’s automatic. You don’t call anything. You don’t remember anything. Once installed, the Brain works on every prompt in every repo.

It grabs the wheel at two moments — intent and action:

1. At intent — the grounding hook. It fires on every prompt and tells Claude “ground in rUv’s real source before you assert anything.” Even when you never say the word “RuvNet,” it speaks up the moment you reach for a classical default — pinecone, pgvector, langchain — and points Claude at rUv’s way instead.
2. At action — the interception. The instant Claude tries to write import pinecone or run npm i langchain, the Brain catches it and injects the rUv replacement before the code lands. The drift is corrected at the keystroke, not after.

Behind both, a search_ruvnet tool pulls the exact source passage on demand — so the correction always comes with rUv’s real code attached, not a guess. You just talk to Claude like normal; the Brain makes it behave like it finally read rUv’s whole library.

Technical view — the grounding loop

18 of rUv’s building blocks, 75,509 source chunks, in a real vector brain (RVF). Not docs — the source.

Coverage map — everything gathered in one brain

Plus human-written primers and the capability cards that make routing work. Everything is read once, up front, so Claude can be pointed straight at the exact line of code instead of skimming and giving up.

You never choose between these and you never read their docs — Claude reaches for the right one automatically. Here’s the whole toolkit, in plain terms, grouped five ways. Open any one for the human version and the one thing it does that nobody else does yet.

Orchestration — running the agents

Vectors + memory — what the agents know

Agents + tooling — building & running them well

Safety + security — trust, measured

Specialized — the wild edge

Same question, asked two ways. Left: Claude alone (drifts). Right: Claude + Brain (grounded in rUv’s source). Watch the difference.

Real, measured numbers — not faith. Re-run them yourself on your own machine.

Now set expectations honestly — this is comfort, not hype:

• What it WILL do, every time: ground Claude in rUv’s real source, stop name-blind drift, cite actual code, route by description.
• Where it shines: anything touching rUv’s stack — vectors/RVF, Ruflo orchestration, SPARC, agent memory.
• Where it won’t help (honest): it’s not a general coding oracle; for non-RuvNet topics Claude works normally. ~1 in 25 described queries still routes imperfectly (we show it: 27/28).

The install is phenomenal — one line.

# one command — downloads the Brain + wires the Claude Code plugin
npx github:stuinfla/ruvnet-brain

1. Install once. Run the one line above. Watch it download and wire itself up — you’ll see it confirm each step. (Constant feedback = confidence.)
2. Open Claude Code in any repo. Your own, anything. Nothing to copy in. The Brain is user-scoped — it travels with you, not the project.
3. Just ask, normally. “Use RuVector for search.” “Set this up the way rUv would.” The Brain grounds Claude automatically. You’ll see Claude cite rUv’s real source instead of guessing. That’s how you know it’s working.

The nervous questions, answered directly

The Brain isn’t copied into a repo. Install once, and every Claude session in every folder has it.

Point it at a fresh repo — your own product, say — and Claude builds there as if rUv were pairing with you.

# what shipped — portable, user-scoped
~/.cache/ruvnet-brain/kb/            # the Brain (RVF) — travels with you, not the repo
 ├ capability-cards.md          # route by need, not by name
 ├ concepts/                    # plain-English primers per building block
 ├ *.rvf                        # 75,509 source chunks · HNSW vector index
 └ forge-mcp-all.mjs            # the search_ruvnet tool — one tool, all repos
claude-code-plugin/              # the grounding hook — fires on every prompt