I measured how much my coding agent actually knows about my stack. It was 40%.

My coding agent answers every question about my stack with total confidence. Last month I finally asked the question that should have been first: how much of that is true?

The experiment

I took the platform docs my agents rely on daily — a games platform's RGS API, its math SDK, the approval checklist — wrote down what an agent should be able to answer, generated ~30 control questions from that, and graded the agent's answers against the actual docs.

It scored around 40%. The worst part wasn't the score — it was that every wrong answer sounded exactly like every right one. Same confidence, same fluency, same code blocks. The model's training data was simply older than the docs, and nothing in the conversation could tell me which answers were from 2024.

Context files don't fix this

The standard fix is a CLAUDE.md / skills folder / a memory MCP server. I had all three. Three problems survived:

1. You pay for every word, every session — the whole file rides along whether the task needs it or not.
2. They rot silently. A file written in March is confidently wrong by June, and nothing tells you.
3. You can't measure them. Nobody knows what a folder of markdown actually covers until the agent fails in production.

So I made the knowledge sit an exam

I built mozg around one mechanism: every knowledge base ('brain') is scored against its own purpose.

• Paste one docs URL. The crawler finds every page (GitHub tree, llms.txt, sitemap, or a link walk) and extracts it into atomic, searchable notes.
• The goal you wrote becomes ~30 exam questions. The brain sits them after every ingest. 'Trained 87%' is a measured number, and the failed questions are listed right on the brain's page.
• The exam deliberately asks about things the brain does NOT cover yet. The failures are the point — they tell you exactly what to feed it next.

Agents connect over MCP (one command in Claude Code / Codex / Cursor) and search server-side — the context cost of an answer is the three notes it actually needed, not the 700 the brain holds.

The part I didn't plan: it learns from being used

Once real agents were querying brains, the logs contained something better than any test I could write: the questions the brain failed to answer. Now every search that returns nothing becomes an exam question automatically, and the next re-read of the sources goes hunting for it. Corrections agents file become owner-reviewed notes. The tenth user gets a measurably better brain than the first.

That same exam turned out to be a curriculum: learn.mozg.sh serves any brain as a spaced-repetition course — read, recall, quiz — with the brain's exam as the final. The scoreboard shows your percentage next to your agent's. Beating your own agent is weirdly motivating.

Honest limitations

• The judge is a model, so scores wobble ±3-4 points (majority voting tames most of it).
• A brain is only as good as its sources — the exam tells you that material is missing, not where to find it.
• For stable, well-known knowledge (Python stdlib), a brain adds nothing — models know it. Brains earn their keep where docs move faster than training cutoffs.

And now it's open source

The whole product is on GitHub under AGPL: https://github.com/egorfedorov/mozg — self-host it with your own keys and everything works. The entire official catalogue is free. The cloud earns one honest way: plans cover the inference our servers spend building your brains — or you bring your own API key and pay nobody.

Try it

The catalogue has free, no-card brains for exactly those fast-moving stacks: Next.js App Router, Expo/React Native, Svelte 5, Tailwind v4, the MCP spec itself. Connect one to your agent in a minute: https://mozg.sh — or study one yourself at https://learn.mozg.sh. It's in beta; the chat button inside goes straight to me.