8 tools. Zero deps. One ecosystem.

Your team makes technical decisions on gut feel. It does not have to be that way.

grainulation turns questions into typed, evidence-graded claims and compiles them into decision briefs. Research that holds up to scrutiny.

grainulation is an ecosystem of eight command-line tools for structured technical research. You start with a question — "Should we migrate to GraphQL?" — and the tools guide you through research, adversarial challenge, and compilation into a decision brief.

Every finding is tracked as a typed claim with an evidence tier (from "someone said it" to "we measured it in production"). The system forces you to challenge your own assumptions before shipping a recommendation.

You need Claude Code, Node.js 18+, and npx. No accounts, no cloud services, no npm install. Everything runs locally, everything is plain JSON and HTML.


From question to shipped decision

Start with wheat. Add tools only when you need them. Most sprints need just the core engine.

Wheat
Research
Farmer
Permissions
Mill
Export
Harvest
Analytics
Barn
Shared utilities
Silo
Knowledge packs
Orchard
Orchestration

Three commands. One decision.

No install. No signup. Just npx and a question.

1

Initialize a sprint

Start with the question you need answered. wheat creates a claims file and config.

$ npx @grainulation/wheat init
Sprint initialized. claims.json created (0 claims) wheat.config.json ready
2

Research and challenge

Gather evidence, then stress-test it. Every finding becomes a typed, graded claim.

wheat> /research "topic"
wheat> /challenge r001
r001 [factual|documented] ... x001 [risk|documented] ...
3

Compile and ship

The compiler resolves conflicts, checks evidence, and produces a decision brief.

wheat> /brief
Compiled 12 claims (2 conflicts resolved) Written: output/brief.html

Question to decision in 10 minutes

A team needs to decide whether to migrate from REST to GraphQL. Here is the full sprint, start to finish.

$ npx @grainulation/wheat init Question: Should we migrate from REST to GraphQL? Audience: Backend team + mobile leads Constraints: Must support existing iOS/Android clients Sprint created. claims.json + wheat.config.json ready.
wheat> /research "GraphQL performance, migration cost, mobile payload" r001 [factual|documented] GraphQL reduces mobile payload 15-25% r002 [risk|documented] REST CDN caching doesn't transfer r003 [estimate|web] Migration effort: 3-5 weeks r004 [factual|documented] Apollo Client adds 35KB gzipped
wheat> /challenge r001 x001 [risk|documented] Payload reduction varies by endpoint — some REST responses already lean
wheat> /prototype p001 [factual|tested] Measured 18% reduction on /api/feed p002 [risk|tested] N+1 query problem on nested resolvers
wheat> /brief Compiled 8 claims (1 conflict resolved) Written: output/brief.html Recommendation: Adopt GraphQL for new endpoints only. Migrate existing REST endpoints opportunistically.

Eight tools. Each does one thing well.

Start with wheat. Everything else is optional. Add tools as your research practice grows.


Built on four principles

The decisions behind the tools.

Satisficing over maximizing

You will never have perfect information. The goal is enough evidence to make a defensible decision, not a perfect one.

Claims over opinions

Every finding is a typed claim with an evidence tier and provenance. "I think" becomes a traceable claim ID with a grade.

Adversarial pressure

Comfortable agreement is the enemy of good decisions. The system forces you to challenge, witness, and stress-test every claim.

Zero dependencies

Standard library only. No supply chain anxiety. No left-pad. Every tool ships what it needs and nothing more.


Common questions

Do I need Node.js?

Yes. Node.js 18+ is required. That is the only system dependency. Everything runs via npx with zero npm install required — packages are fetched and cached automatically.

Does this work with my programming language / framework?

grainulation is language-agnostic. It researches decisions about any technology — databases, APIs, infrastructure, architecture. The tools run locally, but the research can be about anything.

How does this compare to writing an RFC or ADR?

RFCs and ADRs document a decision after it is made. grainulation captures the research process — the evidence gathering, adversarial testing, and conflict resolution that leads to the decision. The output brief can serve as your ADR.

Do I need all eight tools?

No. Start with wheat alone — it handles the full research-to-decision workflow. Add other tools only when you need specific capabilities: farmer for AI permissions, mill for export, silo for reusable knowledge, and so on.