Rust 1.95+ MCP rmcp 1.6 run_thinking_mode Auto · Quick · Explore · Map · Sketch · Test fail-closed verification Apache-2.0

Turn AI Thinking into
Structured Protocols

ReasonKit Think is a Model Context Protocol server that gives your AI coding agents practical Thinking Modes — Auto, Quick, Explore, Map, Sketch, and Test — plus fail-closed verification and governance.

Shell

Alt

curl -fsSL https://get.reasonkit.sh/think | bash

Free forever. No credit card. 30-second install. · Works on Linux, macOS, Windows (WSL & Native)
Installer auto-detects your AI clients · Configures MCP in one step

Apache 2.0 Licensed

No Vendor Lock-in

GDPR Compliant

100% Rust — Zero GC pauses

Self-Hostable

The ReasonKit Advantage

Why ReasonKit Think?

Most AI agents reason shallowly (fast but wrong) or deeply but opaquely (slow and unverifiable). ReasonKit Think bridges that gap with structured, auditable, governable reasoning.

🛡️

Anti-Hallucination HARD GATE

Strict evidence-based verification gates. Claims without proof are marked DATA_DEFICIT and fail closed — never silently passed through.

🔍

Traceable Auditability

Every thought, branch, and decision is logged in a stateful DAG for post-mortem analysis. Replay any reasoning session from first principles.

⚡

Dynamic Paradigms

Seamlessly switch between CoT, ToT, and GoT on the fly. Your agent picks the right reasoning mode for the complexity level of each task.

🦴

Skeleton-of-Thought

For multi-aspect problems, route into outline-first skeleton branches, elaborate them in parallel, then merge via GoT checkpoints.

🎯

Honest Provider Boundaries

Heuristic outputs are labeled as heuristic. Model-backed analysis fails closed until real provider bindings exist. No fake confidence.

💾

State Survival

Local snapshots survive process restarts. Telemetry resources expose tool latency, verification outcomes, pruning, and graph-depth metrics.

📋

Assumption Ledger

Critical premises are tracked and can block convergence until resolved. Unresolved high/critical assumptions gate consensus and synthesis.

🔄

Replayable Convergence

Agents can replay session timelines, run checkpoints, and converge only after quality, evidence, and assumption gates pass.

Reasoning Modes

Six Thinking Modes, One MCP Server

Start with Auto by default. Switch modes only when the problem needs more branching, mapping, or verification depth.

Mode 01

⚡

Auto

Adaptive default

Routes your task to the safest practical workflow, executes it, and returns an auditable summary of what happened.

Best for: Most requests when you do not want to pick tools manually.

"Use Auto mode. Compare options, verify risky claims, and return an auditable recommendation."

Mode 02

🏃

Quick

Concise linear audit

A short CoT-style pass with assumptions, checks, and conclusion. Fast and practical without hidden reasoning dump.

Best for: First-pass debugging, lightweight reviews, quick triage.

"Use Quick mode and give a concise audit of likely root causes."

Mode 03

🌳

Explore

Branch and prune

Tree-of-Thoughts branching for alternatives. Score branches, prune weak paths, and keep the strongest options.

Best for: Tradeoffs, migration choices, incident strategy options.

"Use Explore mode. Generate three strategies, score them, and prune the weakest."

Mode 04

🕸️

Map

Graph synthesis

Graph-of-Thoughts mode for dependencies, conflicts, and merged plans with explicit rationale.

Best for: Architecture planning and multi-system rollout design.

"Use Map mode to merge compatible branches into one final plan."

Mode 05

🧩

Sketch

Outline-first reasoning

Skeleton-of-Thought flow: generate structure first, then elaborate sections under suitability gates.

Best for: Big proposals, multi-part plans, independent lenses.

"Use Sketch mode. Build an outline first, then expand each section with checkpoints."

Mode 06

🛡️

Test

Verification-first

Runs CoVe and governance checks, classifies evidence quality, and returns go/no-go route decisions.

Best for: High-risk changes where correctness and evidence matter most.

"Use Test mode. Extract claims, mark evidence gaps, and decide whether we can proceed."

Verification Engine

Reasoning is Useless
Without Evidence

ReasonKit Think enforces CoVe (Chain of Verification) and Triangulation. Every deep deliberation automatically builds a Verification Matrix.

Extract Claims

Pulls out factual or architectural assertions from the AI's reasoning chain automatically.

Evaluate Evidence

Checks if claims are supported by Tier 1 sources: docs, codebase, verified logs, and authoritative references.

Fail Closed

Conflicting sources or missing data trigger GATHER_MORE_EVIDENCE instead of outputting potentially unsafe code.

VERIFIED

3 Tier-1 sources confirmed

TIER_1

HEURISTIC

Structural proxy, review recommended

HEURISTIC

DATA_DEFICIT

Claim blocked — gather evidence first

BLOCKED

SOURCE_CONFLICT

Conflicting sources — cannot synthesize

BLOCKED

ASSUMPTION_RESOLVED

All premises validated, convergence allowed

READY

Autopilot Mode

Speak Human. Think Structured.

You don't need to remember MCP tool names. The reasoning_intent_router and reasoning_autopilot understand natural language. Just talk to your agent normally.

⚡ CoT / Quick

"step by step" "quick think" "linear reasoning" "first pass" "quick CoT"

🌳 ToT / Branching

"explore options" "compare options" "multiple paths" "score by constraints"

🕸️ GoT / Synthesis

"join branches" "merge paths" "refine assumptions" "distill a plan"

🦴 Skeleton-of-Thought

"outline first" "parallel branches" "multi-aspect answer" "skeleton-of-thought"

🛡️ Verification

"fact-check" "cross-check" "validate claims" "verification failure"

🎯 Governance

"go/no-go" "decision gate" "should we proceed" "checkpoint"

📋 Assumption Ledger

"record this assumption" "premise gate" "must be true"

💾 Memory / Replay

"replay the trace" "export memory snapshot" "remember this reasoning"

Compatibility

Works With Your Favorite Tools

The installer auto-detects installed clients and configures each one. Restart your client after install — that's it.

🤖

Claude Code

claude

✨

Gemini CLI

gemini

💠

Codex CLI

codex

🟣

OpenCode.ai

opencode

🖱️

Cursor

cursor / agent

🐙

Copilot CLI

gh copilot

💙

VS Code

code

🌊

Qwen Code

qwen

⚡

Zed Editor

zed

🌬️

Windsurf

windsurf

Get Started

Up and Running in 30 Seconds

Install the MCP Server

One command installs the binary, detects your AI clients, and patches their MCP configs automatically. No manual JSON editing.

curl -fsSL https://get.reasonkit.sh/think | bash

Restart Your Client

Restart Claude Code, Cursor, VS Code, or whichever AI client you use. The MCP server starts automatically via stdio transport.

claude # or cursor, code, gemini…

Think Differently

Ask your agent to use Auto, Quick, Explore, Map, Sketch, or Test mode depending on the depth and verification you need.

"Use Auto mode and return an auditable recommendation."

Make Your AI Agent
Actually Think

Stop trusting shallow reasoning. Install ReasonKit Think in 30 seconds and give your agent a structured, auditable, governable mind.