Raven MCP
44 tools, 8 knowledge layers — a canonical design graph any AI assistant can query. Free, open source, one command to install.
I built Raven because I needed it. Three hours into a session, trying to defend a layout, I'd reach for a heuristic and blank on the name. Is it Jakob's law? Fitts'? Hick's? Every time, the same five-minute detour — open a tab, search, scan, paste, get back to work. The cost wasn't the search. It was the thread I dropped while searching.
Origin.
Three pains, repeatedly, in my own work.
First: the principle-recall detour. Fast design under fatigue, blanking on the name of the law I needed, losing the thread to go look it up.
Second: self-audit. I wanted something that could look at what I'd just made and tell me, in plain terms, where the spacing was off, where it contradicted the design system I said I was following, where the content pattern violated voice. Cited. Against named principles. Not vibes.
Third: setup. Every project that needs research starts with the same blank page — pick a method, pick a sample, pick a script. I wanted that scaffolded too.
I built a tool that solved all three, then opened it so anyone with the same friction could use it.
Why open source.
When I was coming up — making web apps, learning to design, learning to build — I lived on free open source software. Other people's libraries, frameworks, plugins, snippets, write-ups. Stuff that didn't owe me anything and was there anyway.
I told myself, somewhere along the way, that if I ever made anything worth giving back, I would. Raven is that. The canon doesn't belong to anyone. The graph is public, the server is public, the install path is one command, and there is nothing behind a login.
The assistant doesn't need another haystack to search. It needs named operations that produce a defensible answer.
Approach.
Eight knowledge layers. Design, content, brand, research, service, business strategy, metrics, and the connective tissue between them. Each indexes canonical references and exposes them as discrete tools.
Tools, not documents. A docs site puts the burden on the human (or model) to read and synthesize. Raven inverts that. Ask `get_principles` for 'form design' and the heuristics come back scoped — shaped for the model to act on, not read. Ask `evaluate_design` and you get a critique against named principles.
Audit on demand. `audit_page`, `audit_layout`, `evaluate_design`, `raven_reflect` — the tools I built for myself first. Run them on a draft and the assistant comes back with cited, specific feedback. I folded the end-of-session audit pass into the assistant itself — the AI critiques its own draft against named principles before the human sees it.
Compose, don't just retrieve. `compose_system`, `generate_design_system`, `generate_service_blueprint` — the assistant can stand up scaffolding from primitives, not just hand back facts.
What shipped.
44 tools across 8 knowledge layers.
129 design principles drawn from Nielsen, Laws of UX, Gestalt, WCAG, typography, and color theory.
22 pattern libraries spanning UI, content, and service design.
12 production design systems with their tokens — Material, Polaris, HIG, Carbon, and others.
5 brand voice systems: Mailchimp, GOV.UK, Polaris, Atlassian, and Intuit.
6 metrics frameworks, 14 service design standards, plus `raven_reflect` — a tool that lets the assistant self-critique its own output against principles before showing it to me.
Design tokens.
What changed.
2,000+
Installs across Claude, Cursor, and Codex in just over a month — people running Raven inside their AI assistant.
44
Tools across 8 knowledge layers.
129
Design principles, all canon, all cited.
Free
Open source. One-command install. Nothing behind a login.
The decision that mattered most was the shape of the surface — tools, not documents. Every time I considered making Raven a docs site with an API, I came back to the same thing: the assistant doesn't need another haystack to search. It needs named operations that produce a defensible answer.
The second decision was scope discipline. There are no original principles in Raven. Everything it returns is canon, or a synthesis of canon with a citation. The temptation to inject my own opinions was constant. The value of resisting it was that an AI calling Raven gets the field's answer, not mine.
One more thing, not strictly about design. I made Raven free because the things I learned on were free. That's the only lineage that matters.
[Next case study]