What is ReasonKit? Structured decisions through MCP

ReasonKit Think is a free, open-source add-on for AI coding assistants that makes a decision inspectable. It helps the assistant lay out the options as a map, test each important claim against evidence, stop when critical evidence is missing, and export a record of how the decision was reached. It plugs in through MCP, the open standard that lets AI apps use outside tools, and it runs on your own machine.

ReasonKit is the brand; ReasonKit Think is the product its public site offers today. A plain disclosure: Len P. van der Hof, who writes this site, built it. The ReasonKit site says it is built by him “as a product of LPH98.ventures”, his holding company (reasonkit.sh). Read this page as a maker describing his own tool. Every feature below is taken from the product’s public site and README; nothing is added from memory.

What problem does it address?

When an AI assistant recommends something, you usually get fluent text. You rarely get a record of which claims it checked, which ones it assumed, and what would have changed its mind.

The ReasonKit site frames the problem this way: most AI agents either reason “shallowly (fast but wrong) or deeply but opaquely (slow and unverifiable)”. Its answer is structure. Each decision becomes a set of options, claims, evidence and assumptions that a person can inspect afterwards. The same idea runs through Evaluate the reasoning, not the fluency on this site: a polished answer is not proof that the thinking behind it was checked.

How does it plug in? MCP in two sentences

MCP stands for Model Context Protocol, “an open-source standard for connecting AI applications to external systems” (MCP introduction). An MCP server is a program that offers tools to an AI app over that standard. For the full picture, see MCP meaning.

ReasonKit Think is an MCP server that uses the stdio transport, which the specification describes simply: “The client launches the MCP server as a subprocess” (MCP transports). In plain words, your AI app starts it as a small program on your own computer. Its GitHub README adds: “No daemon, hosted service, or telemetry export is required” (GitHub README).

The public site lists setup paths for Claude Code, Gemini CLI, Codex CLI, Cursor, GitHub Copilot CLI, VS Code, OpenCode, Qwen Code, Zed and others. It claims automatic configuration only for some of them (Claude Code, Gemini CLI, Codex CLI and VS Code on the day this page was checked) and marks the rest as manual or “update in progress”.

Who does the thinking?

Your AI assistant does. This is the most important thing to understand, and the README says it directly: “The host agent remains the semantic engine.” The host agent is the AI assistant you already use.

According to the README, ReasonKit Think records only what the assistant submits through its tools. It does not run a language model to pull facts out of the assistant’s reasoning, it “cannot read a repository, URL, or @mention by itself”, and it “does not expose a model’s private chain of thought”. Its job is to hold the structure, apply the evidence rules, and refuse to sign off when the rules are not met.

The six thinking modes

Mode	What it does, in plain words	Good for
Auto	Picks a suitable path for you (the default)	Most decisions
Quick	A short, linear check of assumptions and conclusion	First passes, simple reviews
Explore	Branches into options, scores them, drops the weak ones	Comparing alternatives
Map	Links dependencies and merges branches into one plan	Architecture and system choices
Sketch	Writes the outline first, then fills in each part	Multi-part plans and documents
Test	Checks the supplied claims and returns a go or no-go route	Release gates, risky changes

One trap in the naming: Test checks claims. It “does not run your project test suite”, as the site puts it.

The evidence gate

Each claim ends up with a status. The site shows labels such as VERIFIED (backed by several strong sources), HEURISTIC (a structural estimate that still needs a human look), DATA_DEFICIT (blocked until evidence arrives) and SOURCE_CONFLICT (sources disagree, so no conclusion).

When a critical claim is missing evidence or has conflicting sources, the decision does not go through. The server returns GATHER_MORE_EVIDENCE instead. That is what fail closed means: when something required is missing, stop and say so. Critical assumptions work the same way. Under the default settings, an assumption recorded as critical and not yet resolved blocks the final answer.

A worked example (hypothetical)

Imagine a three-person software team asking its AI assistant, with ReasonKit Think connected: “Use Auto mode. Should we move our database to a new hosting provider this quarter? Return an auditable recommendation.”

1. Options. The assistant lays out three branches: stay, move now, move after the current contract renews.
2. Claims. “The new provider’s import tool handles our database size.” The assistant attaches the provider’s documentation page as evidence, and the claim gets a status based on that source. “The move fits in one weekend.” Nobody has evidence, so it is marked DATA_DEFICIT.
3. Assumption. “No customer contract requires the data to stay in the EU” is recorded as critical. Nobody has checked the contracts yet.
4. Checkpoint. With a critical gap and an unresolved critical assumption, the route comes back as GATHER_MORE_EVIDENCE.
5. Record. The team exports the audit: the option map, the claims with their evidence, the route, and the stated limitations.

Without the structure, it is easy to get a confident paragraph recommending the move. With it, the answer is “not yet”, plus the two things to find out first: a timed test migration, and a look at the customer contracts.

What ReasonKit is not

• Not a model. Your assistant still does the reasoning. ReasonKit holds the structure and applies the rules.
• Not a web or code fact-checker. It cannot fetch pages or read your repository. Your assistant has to bring the evidence to it.
• Not a benchmark claim. Its public pages publish no accuracy numbers, and this page claims none.
• Not an official MCP reference server. It is a first-party tool from this site’s author.
• Not a test runner. The Test mode checks claims, not code.

Install, licence and status (checked 26 September 2026)

Licence. Apache-2.0, a permissive open-source licence. The site says “Free forever. No credit card.”

Install. The site offers a one-line installer (curl -fsSL https://get.reasonkit.sh/think | bash), which downloads and runs a script, so read the script before you run it. The installer pins version 0.2.0: on Linux x86_64 it downloads the prebuilt binary from the GitHub release and checks its SHA-256 checksum; elsewhere it builds from source, which needs Rust (the README lists Rust 1.95 or newer). The manual alternative is cargo install --locked --git https://github.com/reasonkit/ReasonKit-think reasonkit-think-mcp, where cargo is the package tool of the Rust programming language.

Status. Check which version you get. crates.io, the Rust package registry, lists 0.1.1 from May 2026 as the latest published release. Version 0.2.0 is a release candidate: GitHub carries it as a prerelease (26 September 2026) with a Linux binary, and the one-line installer pins it. An unversioned cargo install reasonkit-think-mcp from crates.io still resolves the older 0.1.1.

Where it sits in your setup: STACK

STACK is a framework for organising a code repository so that people and AI coding agents can work in it safely. It comes from The Agentic Codebase, which is available now. Its five layers:

1. Structure. The layout, entry points and boundaries an agent can find its way through in its first minute.
2. Toolchain. The shells and commands an agent may run, written down instead of remembered.
3. Agent configuration. Instruction files such as AGENTS.md and CLAUDE.md, rules and skills, versioned like code.
4. Connection. MCP servers, tool contracts, hooks and guardrails, with least privilege (only the access the job needs) and a known failure story.
5. Knowledge and quality. Memory, context budgets, evals (automated tests of AI output) and CI, so a model upgrade does not quietly lower the bar.

You do not need the book to use this. ReasonKit Think belongs in the Connection layer, and it deserves the same short contract as any other server: what it can reach (only what the assistant submits), where it runs (locally, over stdio), where its records live (the README says submitted state is stored locally so sessions can be replayed), who owns it on your team, and which decisions must go through it. The book itself mentions Len’s ReasonKit tooling as part of his own setup and tells readers to “read it as the author’s stack, not as a recommendation you must adopt”.

Try this today: the paper version in fifteen minutes

You do not need to install anything to test the idea. Pick one decision you face this week and write:

1. two or three options,
2. the three claims the best option depends on,
3. next to each claim, the evidence you actually have (a link, a number, a document) or the words “no evidence”,
4. one assumption that must be true, marked critical,
5. the rule: any critical claim with no evidence, or any unresolved critical assumption, means “not yet”.

If the rule says “not yet”, you have your to-do list. That is the protocol ReasonKit Think runs inside an AI assistant. If you already use an MCP-capable coding tool, run the same decision through it in Auto mode afterwards and compare the two records.

Cite this:What is ReasonKit? Structured decisions through MCP.Len P. van der Hof. https://lenvanderhof.com/en/blog/what-is-reasonkit/ · Published 4 October 2026.