Grainulator

Research that compiles.

Ask a question. Get a multi-pass investigation with typed claims, tension detection, and a confidence-graded answer. Not a chatbot — a research sprint that runs in under 60 seconds.

What it does

• Multi-pass investigation — 3 research passes build evidence from different angles before synthesizing an answer
• Typed claims, not vibes — every finding is tagged as factual, constraint, risk, recommendation, or estimate with an evidence tier (stated / web / documented / tested / production)
• Tension detection — the compiler finds contradictions between claims and surfaces them before generating output
• Confidence scoring — a 7-pass compiler grades evidence strength, type coverage, and bias to produce a 0-100 confidence score

Try the demo

grainulator.app runs a sprint in your browser. Type a question, watch three research passes execute, and see the compiled answer with claim breakdown.

What to expect from a single sprint:

The demo runs client-side to show the pipeline. The real tool (installed as a plugin) uses Claude for substantially higher quality research and deeper evidence.

Install

Step 1 — Add the marketplace (one-time setup):

/plugin marketplace add https://github.com/grainulation/grainulator/blob/main/.claude-plugin/marketplace.json

Step 2 — Install the plugin:

/plugin install grainulator

That's it. The plugin registers MCP servers, skills, hooks, and an autonomous agent.

Requirements: Claude Code with Node.js >= 20.

git clone https://github.com/grainulation/grainulator.git ~/.claude/plugins/grainulator
claude plugin add ~/.claude/plugins/grainulator

git config --global url."https://github.com/".insteadOf "git@github.com:"

{
  "enabledPlugins": ["grainulator@grainulation-marketplace"]
}

How it works

You ask a question. Grainulator runs a research sprint.

The sprint has two phases:

1. Investigation (3 passes)

Each pass approaches the question from a different angle — constraints, risks, alternatives — and produces typed claims. Claims accumulate in claims.json, the sprint's evidence ledger.

2. Compilation (7 passes)

The compiler runs seven analysis passes over the collected claims:

1. Type coverage — are there enough claim types to avoid blind spots?
2. Evidence strength — are claims grounded in documentation, or just stated?
3. Conflict detection — do any claims contradict each other?
4. Bias scan — is the evidence skewed toward one conclusion?
5. Gap analysis — what topics have thin coverage?
6. Confidence scoring — weighted score from all the above
7. Synthesis — final answer that acknowledges tensions and trade-offs

If unresolved conflicts exist, the compiler blocks output until you resolve them. The confidence score tells you how much to trust the answer.

Commands

Once installed, just talk to Claude. The intent router detects what you want.

Or use slash commands directly:

Autonomous agent

The grainulator subagent runs full research sprints without intervention. It reads compiler output to decide what to do next — research, challenge, witness, blind-spot — until confidence is high enough for output.

Launch it: "research X using grainulator"

Architecture

grainulator/
  .claude-plugin/     Plugin manifest + permissions
  skills/             13 prompt-engineered workflows
  agents/             Autonomous sprint subagent
  hooks/              Auto-compile on claim mutation
  lib/                Shared utilities
  site/               grainulator.app landing page + demo

MCP servers: wheat (claims engine), mill (format conversion), silo (knowledge store), DeepWiki (codebase research)

Hooks: Auto-compile fires on every claim mutation. Write-guards protect claims.json and compilation.json from manual edits.

Orchard: Multi-sprint orchestration via orchard.json dependency graphs for complex investigations that span multiple questions.

The ecosystem

Grainulator is part of the grainulation ecosystem. Eight tools, each does one thing.

You don't need all eight. /plugin install grainulator gives you everything.

Zero dependencies

Every grainulation tool runs on Node built-ins only. No npm install waterfall. No left-pad. No supply chain anxiety. MCP servers download on first use via npx.

License

MIT