ReasonKit Think MCP

Auditable decisions and fail-closed evidence gates for MCP agents
Designed, Not Dreamed. Turn prompts into protocols.

ReasonKit Think is a Rust stdio MCP server that helps a host agent turn a decision into an inspectable graph, test critical claims against supplied evidence, stop when required evidence is missing, and export an audit artifact.

The host agent remains the semantic engine. ReasonKit Think does not expose a model's private chain of thought and does not invent model-backed or retrieval-backed findings. It records only content explicitly submitted through its tools, labels deterministic heuristics, and fails closed at unsupported provider boundaries.

• GitHub: https://github.com/reasonkit/ReasonKit-think
• Crate: https://crates.io/crates/reasonkit-think-mcp
• MCP Registry name: mcp-name: io.github.reasonkit/reasonkit-think

Quick start

1. Install the binary on PATH

Prerequisites: Rust 1.95+ and an MCP-compatible host.

git clone https://github.com/reasonkit/ReasonKit-think.git
cd ReasonKit-think
cargo install --locked --path .
reasonkit-think-mcp --version
reasonkit-think-mcp doctor --json

This source-checkout command is the presently verifiable 0.2.0 release candidate path. The Registry metadata is not live yet; after v0.2.0 publication the equivalent crates.io install will be:

cargo install --locked --version 0.2.0 reasonkit-think-mcp

Do not use an unversioned crates.io install to evaluate this release candidate: it currently resolves an older published release. cargo install places the executable in Cargo's binary directory, normally ~/.cargo/bin; add that directory to PATH if the version check cannot find it.

2. Register the stdio server

Use the executable name, not a machine-specific absolute path.

codex mcp add reasonkit-think -- reasonkit-think-mcp
claude mcp add --scope user reasonkit-think -- reasonkit-think-mcp
gemini mcp add --scope user reasonkit-think reasonkit-think-mcp
copilot mcp add reasonkit-think -- reasonkit-think-mcp

For Cursor and other JSON-configured hosts:

{
  "mcpServers": {
    "reasonkit-think": {
      "type": "stdio",
      "command": "reasonkit-think-mcp",
      "args": []
    }
  }
}

See client-specific setup and the reusable configuration examples.

3. Run the auditable decision path

Ask your host agent:

Use reasonkit-think Auto mode. Compare the options, state the critical assumptions, author the decision nodes, attach explicit evidence to risky claims, stop if a critical gap remains, and return the decision plus its audit artifact.

The complete core path is:

1. run_thinking_mode — start in Auto and create the working decision graph.
2. add_thought_node — replace or refine a returned scaffold with the host agent's actual analysis. Consensus never promotes a heuristic scaffold or the original goal into a final answer.
3. verify_thoughts — submit explicit claims and evidence; missing evidence is DATA_DEFICIT, not a guessed success.
4. run_reasoning_checkpoint — evaluate blockers and readiness.
5. consensus_answer — produce a decision only when the configured gates allow it and an agent-authored candidate is on the frontier.
6. export_reasoning_audit — return the graph, verification matrix, route, and recorded limitations.

Use record_assumption before verification when a premise must remain visible and block the decision until resolved.

Tool packs

REASONKIT_TOOL_PACK controls discovery breadth without changing stored data.

Pack	Tools	Intended use
core	13	Default. Complete route → deliberate → evidence → gate → decision → audit path.
standard	33	Adds graph, scoring, pruning, replay, quality, and Skeleton-of-Thought operations.
full	47	compatibility escape hatch for existing clients that depend on the complete legacy inventory.

Keep the default core pack for new installations. Set the environment variable on the MCP server only when a client needs a broader surface:

{
  "mcpServers": {
    "reasonkit-think": {
      "type": "stdio",
      "command": "reasonkit-think-mcp",
      "args": [],
      "env": { "REASONKIT_TOOL_PACK": "full" }
    }
  }
}

The exact lexical inventories are versioned in evals/tool-packs.json and enforced in CI.

Thinking modes

Auto is the recommended entry point. The other names make routing intent explicit while retaining compatibility with the underlying reasoning methods.

Mode	Behavior	Best for
Auto	Selects an appropriate supported path	Most decisions
Quick	Concise linear audit	First passes and simple reviews
Explore	Branch, score, and prune	Options and competing hypotheses
Map	Link dependencies and synthesize	Architecture and system decisions
Sketch	Outline, elaborate, then merge	Multi-part plans and documents
Test	Verification and governance pipeline	Release gates and go/no-go decisions

Test validates supplied claims; it does not run a repository's test suite. The machine-readable mode catalog is available at reasoning://thinking-modes.

Evidence and audit contract

• Claims and evidence come from the host agent or user. The server does not run an LLM to extract facts from hidden reasoning.
• Evidence tiers, independence groups, contradictions, and ambiguity are evaluated deterministically.
• Critical missing or conflicting evidence routes to GATHER_MORE_EVIDENCE.
• Unresolved high/critical assumptions block convergence under the default policy.
• Heuristic scores are structural proxies with provenance and limitations; they are not semantic confidence.
• Mutable tool calls persist submitted state locally so sessions can be replayed and audited.
• The active transport is stdio. No daemon, hosted service, or telemetry export is required.

ReasonKit Think cannot read a repository, URL, or @mention by itself. Have the host use its normal filesystem/browser tools, then pass the relevant evidence packet into ReasonKit Think.

Development and verification

just check       # formatting, clippy, Rust tests, contract unit tests
just build       # release binary
just eval        # exact pack/protocol matrix plus planted fail-closed cases
just audit       # deny vulnerabilities and advisory warnings
just package-check  # build and verify the publishable crate archive
just registry-check # validate server.json against the pinned Registry schema
just dist-check     # validate the workflow-free cargo-dist manifest

The full-pack end-to-end smoke path is:

python3 scripts/smoke_test.py

Architecture, tools, prompts, and resources are indexed in docs/README.md. The deterministic runtime contract is described in evals/README.md.

Distribution status

server.json and dist-workspace.toml describe the 0.2.0 release candidate. This is not yet a live Registry record: crates.io publication must complete first, the Registry manifest must resolve that exact package version, and the post-publish validation must pass. The cargo-dist file is configuration only; this repository intentionally has no active release workflow, tag, or publish automation in this tranche.

Community

See CONTRIBUTING.md for development and contract checks, SECURITY.md for private vulnerability reporting, and features/README.md for the machine-checked planning-record inventory.

License

Apache-2.0. See LICENSE.