Unified Reasoning Engine v2.0

Purpose: Single entry point for all reasoning - automatically selects and applies the best strategy with parallel execution and intelligent caching.

New in v2.0: Framework of Thoughts (FoT) optimization

• Parallel execution of thought branches
• Intelligent caching of intermediate results
• Prompt optimization for speed
• 2-5x faster reasoning on complex problems

Strategies Included

Architecture

┌─────────────────────────────────────────────────┐
│            UNIFIED REASONING ENGINE             │
├─────────────────────────────────────────────────┤
│                                                 │
│  ┌─────────────────────────────────────────┐   │
│  │         META-REASONING LAYER            │   │
│  │  Analyze → Select Strategy → Execute   │   │
│  └─────────────────────────────────────────┘   │
│                      ↓                          │
│  ┌─────────┬─────────┬─────────┬─────────┐     │
│  │   CoT   │   ToT   │   GoT   │   SC    │     │
│  │ Linear  │ Branch  │ Combine │  Vote   │     │
│  └─────────┴─────────┴─────────┴─────────┘     │
│                      ↓                          │
│  ┌─────────────────────────────────────────┐   │
│  │           HYBRID COMBINATION            │   │
│  │  Run multiple → Combine results        │   │
│  └─────────────────────────────────────────┘   │
│                                                 │
└─────────────────────────────────────────────────┘

API

Main Entry Point

# Auto-select best strategy
Invoke-Reasoning -Problem "How should I prioritize my tasks?"

# Specify strategy
Invoke-Reasoning -Problem "..." -Strategy TreeOfThoughts

# With parameters
Invoke-Reasoning -Problem "..." `
    -Strategy MetaReasoning `
    -MaxPaths 7 `
    -ConfidenceThreshold 0.8 `
    -ShowAll

Individual Strategies

# Chain of Thought
Invoke-ChainOfThought -Problem "..."

# Tree of Thoughts
Invoke-TreeOfThoughts -Problem "..." -Branches 5 -Depth 3

# Graph of Thoughts
Invoke-GraphOfThoughts -Problem "..." -Nodes 7

# Self-Consistency Voting
Invoke-SelfConsistency -Problem "..." -NumSolutions 5

# Hybrid (multiple strategies)
Invoke-HybridReasoning -Problem "..." -Strategies @("TreeOfThoughts", "SelfConsistency")

Meta-Reasoning Decision Tree

Problem Analysis:
├── Complexity: simple → ChainOfThought
├── Requires synthesis → GraphOfThoughts
├── Requires verification → SelfConsistency
├── Has multiple solutions → TreeOfThoughts
├── Complex → GraphOfThoughts
└── Default → TreeOfThoughts

Problem Characteristics Detected

Usage Examples

Example 1: Auto Strategy Selection

. skills/unified-reasoning/reasoning-engine.ps1

$result = Invoke-Reasoning -Problem "What's the best approach to learn a new programming language?"

# Output:
# 🧠 Reasoning Engine
# ═══════════════════════════════════
# Problem: What's the best approach...
# Strategy: MetaReasoning
#
# --- RESULT ---
# Solution: Best path: branch_2
# Confidence: 87.3%
# Duration: 45ms

Example 2: Verification Task

$result = Invoke-Reasoning `
    -Problem "Is this calculation correct: 15% of 840 = 126?" `
    -Strategy SelfConsistency `
    -NumSolutions 7 `
    -ShowAll

# Uses voting to verify

Example 3: Synthesis Task

$result = Invoke-Reasoning `
    -Problem "Combine these ideas into a coherent strategy..." `
    -Strategy GraphOfThoughts `
    -MaxPaths 6

# Uses graph-based combination

Performance Comparison

Meta-Reasoning adapts to problem type automatically.

Integration with AGI Controller

The unified reasoning engine integrates with the AGI decision process:

# In AGI Controller decision making
function Invoke-AGIDecision {
    param($Goal, $WorldState)
    
    # Use unified reasoning for complex decisions
    $reasoning = Invoke-Reasoning `
        -Problem "What action best achieves: $Goal" `
        -Strategy MetaReasoning `
        -MaxPaths 5
    
    return @{
        action = $reasoning.solution
        confidence = $reasoning.confidence
        reasoning = $reasoning
    }
}

Configuration

unified_reasoning:
  default_strategy: MetaReasoning
  
  chain_of_thought:
    enabled: true
    
  tree_of_thoughts:
    default_branches: 3
    default_depth: 3
    max_branches: 7
    
  graph_of_thoughts:
    default_nodes: 5
    max_nodes: 10
    connection_probability: 0.5
    
  self_consistency:
    default_solutions: 5
    min_solutions: 3
    max_solutions: 10
    min_confidence: 0.6
    
  meta_reasoning:
    complexity_threshold_simple: 10  # words
    complexity_threshold_complex: 30 # words
    
  hybrid:
    default_strategies:
      - TreeOfThoughts
      - SelfConsistency

Return Object

@{
    strategy = "TreeOfThoughts"  # Strategy used
    solution = "Best path: branch_2"  # Final answer
    confidence = 0.87  # 0.0 to 1.0
    duration = 45  # milliseconds
    timestamp = "2026-02-26T22:35:00+02:00"
    metThreshold = $true  # confidence >= threshold
    
    # Strategy-specific data
    tree = @{ ... }  # For ToT
    graph = @{ ... }  # For GoT
    votes = @{ ... }  # For SC
    metaReasoning = @{ ... }  # For Meta
}

Research Foundation

• Chain of Thought: Wei et al. (2022)
• Tree of Thoughts: Yao et al. (2023)
• Graph of Thoughts: Besta et al. (2024)
• Self-Consistency: Wang et al. (2023), ACL 2024 enhancements
• Meta-Reasoning: Custom implementation for strategy selection
• Framework of Thoughts: arXiv (Feb 2026) - Parallel execution + caching

FoT Optimization (v2.0)

Parallel Execution

# Before: Sequential ToT (3 branches = 3x time)
# After: Parallel ToT (3 branches = 1x time)

function Invoke-ParallelTreeOfThoughts {
    param($Problem, $Branches = 3)

    # Execute all branches in parallel
    $jobs = @()
    for ($i = 0; $i -lt $Branches; $i++) {
        $jobs += Start-ThreadJob -ScriptBlock {
            param($p, $idx)
            # Generate branch $idx
            return Invoke-BranchGeneration -Problem $p -BranchIndex $idx
        } -ArgumentList $Problem, $i
    }

    # Wait for all and combine
    $results = $jobs | Wait-Job | Receive-Job
    return $results
}

Intelligent Caching

# Cache intermediate results for reuse
$Global:ReasoningCache = @{}

function Get-CachedOrGenerate {
    param($Key, $Generator)

    if ($Global:ReasoningCache.ContainsKey($Key)) {
        Write-Host "Cache hit: $Key"
        return $Global:ReasoningCache[$Key]
    }

    $result = & $Generator
    $Global:ReasoningCache[$Key] = $result
    return $result
}

# Example usage
$analysis = Get-CachedOrGenerate -Key "problem_analysis" -Generator {
    Invoke-DeepAnalysis -Problem $Problem
}

Prompt Optimization

# Compress prompts for faster execution
function Optimize-Prompt {
    param([string]$Prompt)

    # Remove redundant whitespace
    $optimized = $Prompt -replace '\s+', ' '

    # Extract essential instructions
    $optimized = $optimized.Trim()

    return $optimized
}

Performance Comparison

When to Use FoT

Use FoT (default in v2.0):

• Complex multi-step problems
• Repeated similar queries (caching helps)
• Time-sensitive reasoning
• High compute resources

Disable FoT:

• Simple single-step problems
• Memory-constrained environments
• Debugging (easier to trace sequential)

# Disable parallel execution
Invoke-Reasoning -Problem "..." -NoParallel

# Disable caching
Invoke-Reasoning -Problem "..." -NoCache

# Disable both
Invoke-Reasoning -Problem "..." -Sequential

Unified Reasoning Engine v2.0.0 - Faster AGI-level reasoning with FoT optimization