Reasonkit Core

ReasonKit

The AI Reasoning Engine

> "Designed, not Dreamed." — From Prompt to Cognitive Engineering.

Auditable Reasoning for Production AI | Rust-Native | Turn Prompts into Protocols

[](https://github.com/reasonkit/reasonkit-core/actions/workflows/ci.yml) [](https://github.com/reasonkit/reasonkit-core/actions/workflows/security.yml) [](https://crates.io/crates/reasonkit-core) [](https://docs.rs/reasonkit-core) [](https://crates.io/crates/reasonkit-core) [](https://github.com/reasonkit/reasonkit-core/blob/main/LICENSE) [](https://www.rust-lang.org/) [](https://modelcontextprotocol.io)

Website | Pro | Docs | Resources | Enterprise | About | GitHub

---

🚀 Quick Install

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

Universal Installer • All Platforms • All Shells • 30 Seconds

📖 Installation Guide • 📦 Crates.io • 📚 Docs.rs

---

The Problem We Solve

Most AI is a slot machine. Insert prompt → pull lever → unclear, hope for coherence, at the mercy of chance.

ReasonKit is a factory. Input data → apply protocol → deeper logic, auditable result, known probabibility.

The Cost of Wrong Decisions: Without structured reasoning, AI decisions lead to financial loss and missed opportunities. Structured protocols catch errors early and prevent costly mistakes before they compound.

LLMs are fundamentally probabilistic. Same prompt → different outputs. This creates critical failures:

| Failure | Impact | Our Solution | | ----------------- | ------------------------- | ------------------------------------------------- | | Inconsistency | Unreliable for production | Deterministic protocol execution | | Hallucination | Dangerous falsehoods | Multi-source triangulation + adversarial critique | | Opacity | No audit trail | Complete execution tracing with confidence scores |

We don't eliminate probability (impossible). We constrain it through structured protocols that force probabilistic outputs into deterministic execution paths.

---

Quick Start

Already installed? Jump to [Choose Your Workflow](#-choose-your-workflow) or [How to Use](#how-to-use).

Need installation help? See the Installation Guide or [Installation Section](#installation) below.

🤖 Choose Your Workflow

🤖 Claude Code (Opus 4.5)

Agentic CLI. No API key required.

claude mcp add reasonkit -- rk serve-mcp
claude "Use ReasonKit to analyze: Should we migrate to microservices?"

Learn more: Claude Code Integration

🌐 ChatGPT (Browser)

Manual MCP Bridge. Injects the reasoning protocol directly into the chat.

# Generate strict protocol
rk protocol "Should we migrate to microservices?" | pbcopy

# → Paste into ChatGPT: "Execute this protocol..."

Learn more: ChatGPT Integration

⚡ Gemini 3.0 Pro (API)

Native CLI integration with Google's latest preview.

export GEMINI_API_KEY=AIza...
rk think --model gemini-3.0-pro-preview "Should we migrate to microservices?"

Learn more: Google Gemini Integration • All Provider Integrations

> Note: The rk command is the shorthand alias for rk.

30 seconds to structured reasoning. See [How to Use](#how-to-use) for more examples.

---

ThinkTools: The 5-Step Reasoning Chain

Each ThinkTool acts as a variance reduction filter, transforming probabilistic outputs into increasingly deterministic reasoning paths.

📖 Full Documentation: ThinkTools Guide • API Reference

| ThinkTool | Operation | What It Does | | ----------------- | ------------ | ----------------------------------------------- | | GigaThink | Diverge() | Generate 10+ perspectives, explore widely | | LaserLogic | Converge() | Detect fallacies, validate logic, find gaps | | BedRock | Ground() | First principles decomposition, identify axioms | | ProofGuard | Verify() | Multi-source triangulation, require 3+ sources | | BrutalHonesty | Critique() | Adversarial red team, attack your own reasoning |

Variance Reduction: The Chain Effect

Result: Raw LLM variance ~85% → Protocol-constrained variance ~28%

---

Reasoning Profiles

Pre-configured chains for different rigor levels. See Reasoning Profiles Guide for detailed documentation.

# Fast analysis (70% confidence target)
rk think --profile quick "Is this email phishing?"

# Standard analysis (80% confidence target)
rk think --profile balanced "Should we use microservices?"

# Thorough analysis (85% confidence target)
rk think --profile deep "Design A/B test for feature X"

# Maximum rigor (95% confidence target)
rk think --profile paranoid "Validate cryptographic implementation"

| Profile | Chain | Confidence | Use Case | | ------------ | ----------------------- | ---------- | ------------------ | | --quick | GigaThink → LaserLogic | 70% | Fast sanity checks | | --balanced | All 5 ThinkTools | 80% | Standard decisions | | --deep | All 5 + meta-cognition | 85% | Complex problems | | --paranoid | All 5 + validation pass | 95% | Critical decisions |

---

See It In Action

$ rk think --profile balanced "Should we migrate to microservices?"

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ThinkTool Chain: GigaThink → LaserLogic → BedRock → ProofGuard
Variance:        85% → 72% → 58% → 42% → 28%
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[GigaThink] 10 PERSPECTIVES GENERATED                         Variance: 85%
  1. OPERATIONAL: Maintenance overhead +40% initially
  2. TEAM TOPOLOGY: Conway's Law - do we have the teams?
  3. COST ANALYSIS: Infrastructure scales non-linearly
  ...
  → Variance after exploration: 72% (-13%)

[LaserLogic] HIDDEN ASSUMPTIONS DETECTED                      Variance: 72%
  ⚠ Assuming network latency is negligible
  ⚠ Assuming team has distributed tracing expertise
  ⚠ Logical gap: No evidence microservices solve stated problem
  → Variance after validation: 58% (-14%)

[BedRock] FIRST PRINCIPLES DECOMPOSITION                      Variance: 58%
  • Axiom: Monoliths are simpler to reason about (empirical)
  • Axiom: Distributed systems introduce partitions (CAP theorem)
  • Gap: Cannot prove maintainability improvement without data
  → Variance after grounding: 42% (-16%)

[ProofGuard] TRIANGULATION RESULT                             Variance: 42%
  • 3/5 sources: Microservices increase complexity initially
  • 2/5 sources: Some teams report success
  • Confidence: 0.72 (MEDIUM) - Mixed evidence
  → Variance after verification: 28% (-14%)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
VERDICT: conditional_yes | Confidence: 87% | Duration: 2.3s
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

What This Shows:

• Transparency: See exactly where confidence comes from
• Auditability: Every step logged and verifiable
• Deterministic Path: Same protocol → same execution flow
• Variance Reduction: Quantified uncertainty reduction at each stage

---

Architecture

The ReasonKit architecture uses a Protocol Engine wrapper to enforce deterministic execution over probabilistic LLM outputs.

📖 Full Documentation: Architecture Guide • API Reference

Three-Layer Architecture:

1. Probabilistic LLM (Unavoidable)

• LLMs generate tokens probabilistically
• Same prompt → different outputs
• We cannot eliminate this

1. Deterministic Protocol Engine (Our Innovation)

• Wraps the probabilistic LLM layer
• Enforces strict execution paths
• Validates outputs against schemas
• State machine ensures consistent flow

1. ThinkTool Chain (Variance Reduction)

• Each ThinkTool reduces variance
• Multi-stage validation catches errors
• Confidence scoring quantifies uncertainty

Key Components:

• Protocol Engine: Orchestrates execution with strict state management
• ThinkTools: Modular cognitive operations with defined contracts
• LLM Integration: Unified client (Claude, GPT, Gemini, 18+ providers)
• Telemetry: Local SQLite for execution traces + variance metrics

Architecture (Mermaid Diagram)

flowchart LR
    subgraph CLI["ReasonKit CLI (rk)"]
      A[User Commandrk think --profile balanced]
    end

    subgraph PROTOCOL["Deterministic Protocol Engine"]
      B1[State MachineExecution Plan]
      B2[ThinkTool Orchestrator]
      B3[(SQLite Trace DB)]
    end

    subgraph LLM["LLM Layer (Probabilistic)"]
      C1[Provider Router]
      C2[Claude / GPT / Gemini / ...]
    end

    subgraph TOOLS["ThinkTools · Variance Reduction"]
      G["GigaThinkDiverge()"]
      LZ["LaserLogicConverge()"]
      BR["BedRockGround()"]
      PG["ProofGuardVerify()"]
      BH["BrutalHonestyCritique()"]
    end

    A --> B1 --> B2 --> G --> LZ --> BR --> PG --> BH --> B3
    B2 --> C1 --> C2 --> B2

    classDef core fill:#030508,stroke:#06b6d4,stroke-width:1px,color:#f9fafb;
    classDef tool fill:#0a0d14,stroke:#10b981,stroke-width:1px,color:#f9fafb;
    classDef llm fill:#111827,stroke:#a855f7,stroke-width:1px,color:#f9fafb;

    class CLI,PROTOCOL core;
    class G,LZ,BR,PG,BH tool;
    class LLM,llm C1,C2;

---

Built for Production

ReasonKit is written in Rust because reasoning infrastructure demands reliability.

| Capability | What It Means for You | | ------------------------ | --------------------------------------------------- | | Predictable Latency |

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

📖 Full Installation Guide: docs.reasonkit.sh/getting-started/installation

Platform Support:

• ✅ Linux (all distributions)
• ✅ macOS (Intel & Apple Silicon)
• ✅ Windows (WSL & Native PowerShell)
• ✅ FreeBSD (experimental)

Shell Support:

• ✅ Bash (auto-detected, PATH configured)
• ✅ Zsh (auto-detected, PATH configured)
• ✅ Fish (auto-detected, PATH configured)
• ✅ Nu (Nushell) (auto-detected, PATH configured)
• ✅ PowerShell (cross-platform, PATH configured)
• ✅ Elvish (auto-detected, PATH configured)
• ✅ tcsh/csh/ksh (basic support)

Features:

• 🎨 Beautiful terminal UI with progress visualization
• ⚡ Fast installation (~30 seconds)
• 🔒 Secure (HTTPS-only, checksum verification)
• 🧠 Smart shell detection and PATH configuration
• 📊 Real-time build progress with ETA
• 🔄 Automatic Rust installation if needed

📖 Learn more: Installation Guide • [Installation Audit Report](.internal/site-docs/INSTALLAUDIT_2026-01-08.md)

Alternative Methods

# Cargo (Rust) - Recommended for Developers
cargo install reasonkit-core

# From Source (Latest Features)
git clone https://github.com/reasonkit/reasonkit-core
cd reasonkit-core && cargo build --release

📦 Package Links: Crates.io • Docs.rs • GitHub Releases

Windows (Native PowerShell):

irm https://get.reasonkit.sh/windows | iex

Python bindings available via PyO3 (build from source with --features python).

---

How to Use

Command Structure: rk [options] [arguments]

📖 Full CLI Reference: CLI Documentation • API Reference

Standard Operations:

# Balanced analysis (5-step protocol)
rk think --profile balanced "Should we migrate our monolith to microservices?"

# Quick sanity check (2-step protocol)
rk think --profile quick "Is this email a phishing attempt?"

# Maximum rigor (paranoid mode)
rk think --profile paranoid "Validate this cryptographic implementation"

# Scientific method (research & experiments)
rk think --profile scientific "Design A/B test for feature X"

With Memory (RAG):

# Ingest documents
rk ingest document.pdf

# Query with RAG
rk query "What are the key findings in the research papers?"

# View execution traces
rk trace list
rk trace export 

📖 Learn more: RAG Guide • Memory Layer Documentation

---

Contributing: The 5 Gates of Quality

We demand excellence. All contributions must pass The 5 Gates of Quality:

📖 Contributing Guide: [CONTRIBUTING.md](CONTRIBUTING.md) • Quality Gates Documentation

# Clone & Setup
git clone https://github.com/reasonkit/reasonkit-core
cd reasonkit-core

# The 5 Gates (MANDATORY)
cargo build --release        # Gate 1: Compilation (Exit 0)
cargo clippy -- -D warnings  # Gate 2: Linting (0 errors)
cargo fmt --check            # Gate 3: Formatting (Pass)
cargo test --all-features    # Gate 4: Testing (100% pass)
cargo bench                  # Gate 5: Performance (

**ReasonKit** — Turn Prompts into Protocols

_Designed, Not Dreamed_

[Website](https://reasonkit.sh) | [Pro](https://reasonkit.sh/pro/) | [Docs](https://docs.reasonkit.sh) | [Resources](https://reasonkit.sh/resources/) | [Enterprise](https://reasonkit.sh/enterprise/) | [About](https://reasonkit.sh/about/) | [GitHub](https://github.com/reasonkit/reasonkit-core)

**📦 Package Links:** [Crates.io](https://crates.io/crates/reasonkit-core) • [Docs.rs](https://docs.rs/reasonkit-core) • [PyPI](https://pypi.org/project/reasonkit/)

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [reasonkit](https://github.com/reasonkit)
- **Source:** [reasonkit/reasonkit-core](https://github.com/reasonkit/reasonkit-core)
- **License:** Apache-2.0
- **Homepage:** https://reasonkit.sh

Install and usage instructions live in the source repository linked above.