Decision Analysis with ReasonKit

Make better decisions using structured reasoning protocols.

Problem

Traditional decision-making is prone to:

• Confirmation bias: Seeking evidence that supports pre-existing beliefs
• Analysis paralysis: Overthinking without clear framework
• Groupthink: Conforming to team consensus without critical evaluation
• Short-term focus: Ignoring long-term consequences

Solution Overview

ReasonKit provides structured decision-making through:

1. GigaThink: Generate diverse perspectives (avoids blind spots)
2. LaserLogic: Validate logical consistency (catches fallacies)
3. BedRock: Ground in first principles (removes assumptions)
4. ProofGuard: Verify with evidence (requires triangulation)
5. BrutalHonesty: Stress-test conclusions (adversarial review)

Prerequisites

• ReasonKit CLI installed: cargo install reasonkit-core
• API key set: export ANTHROPIC_API_KEY="your-key"
• Decision context and constraints defined

Step-by-Step

Step 1: Frame the Decision

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

What this does:

• Generates 10+ perspectives on the decision
• Validates logical consistency
• Decomposes to first principles

Step 2: Deep Dive on Options

Analyze each major option separately:

# Option A: Stay with monolith
rk think --profile deep "What are the long-term consequences of staying with our monolith architecture?"

# Option B: Migrate to microservices
rk think --profile deep "What are the risks and benefits of migrating to microservices?"

# Option C: Hybrid approach
rk think --profile deep "Could we adopt a modular monolith as an intermediate step?"

Step 3: Verify Key Assumptions

rk verify "Microservices always improve team scalability"

What this does:

• Searches for evidence supporting/contradicting the claim
• Requires 3+ independent sources
• Returns confidence score

Step 4: Stress-Test the Decision

rk think --profile paranoid "What could go wrong with microservices migration that we haven't considered?"

What this does:

• Adversarial red-teaming of your decision
• Maximum rigor (95% confidence target)
• Catches hidden risks

Example: Complete Decision Workflow

#![allow(unused)]
fn main() {
use reasonkit::prelude::*;

async fn analyze_decision(decision: &str) -> Result<DecisionAnalysis> {
    // Step 1: Generate perspectives
    let perspectives = Protocol::builder()
        .add_tool(GigaThink::new().perspectives(10))
        .build()
        .execute(decision)
        .await?;

    // Step 2: Validate logic
    let validation = Protocol::builder()
        .add_tool(LaserLogic::new().strict_mode(true))
        .build()
        .execute(&perspectives.content)
        .await?;

    // Step 3: Ground in principles
    let principles = Protocol::builder()
        .add_tool(BedRock::new())
        .build()
        .execute(decision)
        .await?;

    // Step 4: Final verdict
    let verdict = Protocol::builder()
        .profile(Profile::Balanced)
        .build()
        .execute(&format!(
            "Decision: {}\n\nPerspectives: {}\n\nValidation: {}\n\nPrinciples: {}",
            decision, perspectives.content, validation.content, principles.content
        ))
        .await?;

    Ok(DecisionAnalysis {
        verdict: verdict.content,
        confidence: verdict.confidence,
        duration: verdict.duration,
    })
}

struct DecisionAnalysis {
    verdict: String,
    confidence: f64,
    duration: Duration,
}
}

Variations

Quick Decision (Low Stakes)

rk think --profile quick "Should we use React or Vue for this prototype?"

• Time: ~30 seconds
• Confidence: 70%
• Use for: Prototypes, experiments, reversible decisions

Important Decision (Medium Stakes)

rk think --profile balanced "Should we invest $50K in this marketing campaign?"

• Time: ~2-3 minutes
• Confidence: 80%
• Use for: Budget decisions, hiring, feature prioritization

Critical Decision (High Stakes)

rk think --profile paranoid "Should we accept this acquisition offer?"

• Time: ~5-8 minutes
• Confidence: 95%
• Use for: M&A, architectural changes, strategic pivots

Integration

With Claude Code

claude "Use ReasonKit to analyze: Should we prioritize performance or features for Q3?"

With ChatGPT

# Generate strict protocol
rk protocol "Should we open a new office in Berlin?" | pbcopy

# Paste into ChatGPT: "Execute this protocol and provide analysis..."

As Library

#![allow(unused)]
fn main() {
let decision = "Should we rewrite our API in Rust?";
let result = reasonkit::think(decision)
    .profile(Profile::Balanced)
    .await?;
}

Tips & Best Practices

Do

• ✓ Frame decisions as questions
• ✓ Include constraints in the prompt
• ✓ Run multiple profiles for comparison
• ✓ Verify key assumptions
• ✓ Document the reasoning for future reference

Don’t

• ✗ Rush critical decisions with –quick profile
• ✗ Ignore the confidence score
• ✗ Skip verification of controversial claims
• ✗ Make decisions without considering alternatives

Example Decision Log

# Decision Log: Microservices Migration

**Date**: 2026-02-18
**Decision**: Should we migrate to microservices?
**Confidence**: 78%
**Verdict**: Conditional Yes

## Reasoning

### Perspectives Generated
1. Operational: Maintenance overhead +40%
2. Team: Conway's Law alignment
3. Cost: Non-linear infrastructure scaling
...

### Key Assumptions Validated
✓ Microservices increase complexity (3 sources confirm)
✓ Team has distributed systems experience (verified)
⚠ Network latency assumption not tested

### Risks Identified
- Migration will take 6-12 months
- Performance may degrade initially
- Team learning curve

## Action Items
- [ ] Create proof-of-concept
- [ ] Measure current monolith performance
- [ ] Define migration milestones

See Also

• Risk Assessment - Evaluate decision risks
• Option Comparison - Compare multiple alternatives
• Architecture Decisions - Technical decision records