# Reasonkit Core

> The Reasoning Engine — Auditable Reasoning for Production AI | Rust-Native | Turn Prompts into Protocols

- **Type:** MCP server
- **Install:** `agentstack add mcp-reasonkit-reasonkit-core`
- **Verified:** Pending review
- **Seller:** [reasonkit](https://agentstack.voostack.com/s/reasonkit)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [reasonkit](https://github.com/reasonkit)
- **Source:** https://github.com/reasonkit/reasonkit-core
- **Website:** https://reasonkit.sh

## Install

```sh
agentstack add mcp-reasonkit-reasonkit-core
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# 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](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)

---

## 🚀 Quick Install

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

**Universal Installer** • All Platforms • All Shells • 30 Seconds

[📖 Installation Guide](https://docs.reasonkit.sh/getting-started/installation) • [📦 Crates.io](https://crates.io/crates/reasonkit-core) • [📚 Docs.rs](https://docs.rs/reasonkit-core)

---

## 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](https://docs.reasonkit.sh/getting-started/installation) or [Installation Section](#installation) below.

### 🤖 Choose Your Workflow

### 🤖 Claude Code (Opus 4.5)

_Agentic CLI. No API key required._

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

**Learn more:** [Claude Code Integration](https://docs.reasonkit.sh/integrations/claude-code)

### 🌐 ChatGPT (Browser)

_Manual MCP Bridge. Injects the reasoning protocol directly into the chat._

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

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

**Learn more:** [ChatGPT Integration](https://docs.reasonkit.sh/integrations/chatgpt)

### ⚡ Gemini 3.0 Pro (API)

_Native CLI integration with Google's latest preview._

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

**Learn more:** [Google Gemini Integration](https://docs.reasonkit.sh/integrations/google-gemini) • [All Provider Integrations](https://docs.reasonkit.sh/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](https://docs.reasonkit.sh/thinktools) • [API Reference](https://docs.rs/reasonkit-core/latest/reasonkit_core/thinktool/)

| 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](https://docs.reasonkit.sh/profiles) for detailed documentation.

```bash
# 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

```text
$ 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](https://docs.reasonkit.sh/architecture) • [API Reference](https://docs.rs/reasonkit-core/)

**Three-Layer Architecture:**

1. **Probabilistic LLM** (Unavoidable)
   - LLMs generate tokens probabilistically
   - Same prompt → different outputs
   - We **cannot eliminate** this

2. **Deterministic Protocol Engine** (Our Innovation)
   - Wraps the probabilistic LLM layer
   - Enforces strict execution paths
   - Validates outputs against schemas
   - State machine ensures consistent flow

3. **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)

```mermaid
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**  | 

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

**📖 Full Installation Guide:** [docs.reasonkit.sh/getting-started/installation](https://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](https://docs.reasonkit.sh/getting-started/installation) • [Installation Audit Report](.internal/site-docs/INSTALL_AUDIT_2026-01-08.md)

Alternative Methods

```bash
# 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](https://crates.io/crates/reasonkit-core) • [Docs.rs](https://docs.rs/reasonkit-core) • [GitHub Releases](https://github.com/reasonkit/reasonkit-core/releases)

**Windows (Native PowerShell):**

```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](https://docs.reasonkit.sh/reference/cli) • [API Reference](https://docs.rs/reasonkit-core/)

**Standard Operations:**

```bash
# 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):**

```bash
# 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](https://docs.reasonkit.sh/memory/rag) • [Memory Layer Documentation](https://docs.reasonkit.sh/memory)

---

## 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](https://docs.reasonkit.sh/contributing/quality-gates)

```bash
# 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.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-reasonkit-reasonkit-core
- Seller: https://agentstack.voostack.com/s/reasonkit
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.