Advanced cognitive reasoning engine for AI agents — A Model Context Protocol (MCP) server that enhances AI reasoning with a 6-stage cognitive pipeline, 9-layer anti-hallucination, MCTS quality enforcement, 8-signal Process Reward Model (PRM) with Veto Gate, bias detection, metacognitive analysis, persistent thought sessions, Graph-of-Thought topology with Kahn's DP longest path, mode collapse detection, Softmax Gated Attention reward scoring, CUSUM change-point detection, ONNX semantic embeddings (fastembed), NLI contradiction detection (rust-bert), Flesch-Kincaid readability scoring, and cross-MCP memory symbiosis.

3 tools. Zero cloud dependencies. 186 tests. 9 audit rounds. 16 magic constants formally verified.

AI agents think in flat, unstructured sequences. Cuba-Thinking gives them:

• 6-stage cognitive engine — Bloom's Taxonomy state machine: DEFINE → RESEARCH → ANALYZE → HYPOTHESIZE → VERIFY → SYNTHESIZE
• 9-layer anti-hallucination — Assumption tracking, confidence calibration, CoVe structure with verification question detection, evidence accumulation, claim grounding (per-claim proximity), EWMA threshold enforcement, contradiction detection, warmup guard, anti-overthinking
• 6D quality metrics — Clarity (Root-TTR 40% + Flesch-Kincaid 30% + Sentence Consistency 30%), Depth (clause counting), Breadth (noun diversity), Logic (connective density), Relevance (TF-IDF cosine), Actionability (imperative + specificity)
• Process Reward Model (PRM) — 8-signal code evaluation with V9 Logical Veto Gate: Gate × (0.6×Verify + 0.4×Quality) prevents uncompilable code from scoring high
• Sandboxed execution — PyO3 0.28 sandbox with AST-based security scan, RLIMIT_AS 512MB memory cap, recursion limit 100, nesting depth 100, PEP 578 audit hooks, ReDoS guard, Z3 vacuous truth detector. Supports numpy, sympy, and scipy
• MCTS forced backtracking — Protocol-level rejection (isError: true) when EWMA drops below budget-aware threshold, with hedged rejection zones
• MCTS Graph — Arena-allocated PUCT + Adaptive UCT (variance-based c_puct, correlation_lambda) — superior to standard UCB1
• Graph-of-Thought (GoT) — DAG topology with Kahn's topological sort + DP for correct longest-path depth, Tarjan SCC cycle detection O(V+E) for circular reasoning
• Persistent thought sessions — Cross-call state accumulation: EWMA, novelty, graph, confidence oscillation, depth degradation, root-anchoring, hypothesis drift
• Epistemological rollback — Snapshot/rollback of session state when MCTS rejects a thought, preventing hallucinated premises from poisoning future reasoning
• Mode collapse detection — OrthogonalityGuard: Jaccard similarity + semantic embedding similarity against failed thoughts detects paraphrased rejected ideas
• Bias detection — 5 cognitive biases (Anchoring, Confirmation, Availability, Sunk Cost, Bandwagon) with confidence + actionable suggestions
• Metacognitive analysis — Filler ratio, content-word ratio (Coh-Metrix), claim density, fallacy detection, dialectical reasoning checks
• Corrective directives — 3 severity levels (INFO/WARNING/CORRECTION), prescriptive improvement targeting weak quality dimensions
• Stage-content alignment — Validates thought content matches declared cognitive stage + Logical Validity Score (ReasonEval/RECEVAL 2024)
• Reward Consistency Check — PRM↔EWMA divergence detection (Z≈1.9, P(false alarm)≈2.9%) for reward gaming prevention
• Softmax Gated Attention — Dynamic EWMA weights via softmax with τ=0.5, Bayesian prior initialization (Fin-PRM inspired, Zhou et al. 2025)
• CUSUM change-point detection — Lag-free quality collapse detection replacing MACD (μ=0.70, k=0.05, h=0.15)
• Cross-MCP memory symbiosis — Bridge to cuba-memorys with anti-repetition guard
• EWMA reward tracking — 6-signal composite with adaptive α floor, stage-adaptive weight profiles, CUSUM collapse prediction, Process Advantage Verifier (PAV), stagnation/fatigue detection
• Contradiction detection — NLI zero-shot classification (rust-bert) + direct negation, 30+ antonym pairs, quantifier conflicts with sentence context
• Novelty tracking — Shannon information gain per thought step via Jaccard distance + semantic embedding similarity (fastembed BGE-small, 384-dim) for paraphrase detection
• Depth degradation — Tracks quality.depth history per thought, detects >50% drop vs baseline (KV cache saturation proxy)
• Code-aware metrics — Quality, depth, and directives adapt when input is code vs natural language
• Anti-overthinking — Stagnation detection, fatigue monitoring, mode collapse guard, early stopping signals

• Rust 1.83+ & Cargo
• Python 3.10+ (for PRM sandbox execution)
• libtorch — auto-downloaded by rust-bert during build (~2GB, CPU-only)

git clone https://github.com/LeandroPG19/cuba-thinking.git
cd cuba-thinking/cuba_cognitive_engine
cargo build --release

Note: First build downloads ONNX model files (~33MB for fastembed) and libtorch (~2GB for rust-bert). Subsequent builds are cached.

Add to your MCP configuration (e.g., mcp_config.json). You must set LD_LIBRARY_PATH to the libtorch directory inside the build artifacts:

{
  "mcpServers": {
    "cuba-thinking": {
      "command": "/path/to/cuba-thinking/cuba_cognitive_engine/target/release/cuba_cognitive_engine",
      "args": [],
      "env": {
        "LD_LIBRARY_PATH": "/path/to/cuba-thinking/cuba_cognitive_engine/target/release/build/torch-sys-<hash>/out/libtorch/libtorch/lib"
      }
    }
  }
}

To find the exact path:

find target/release/build -path '*/torch-sys-*/out/libtorch/libtorch/lib' -type d

Alternatively, use the included wrapper script:

{
  "mcpServers": {
    "cuba-thinking": {
      "command": "/path/to/cuba-thinking/run_mcp.sh",
      "args": []
    }
  }
}

Zero cloud API keys. Runs 100% locally. Models auto-download on first run.

The core cognitive engine. Evaluates each thought step through the full analysis pipeline.

Required parameters:

Optional parameters:

Output includes: EWMA reward %, trust score, calibrated confidence, quality scores, contradiction warnings, bias alerts, corrective directives, memory instructions, trend indicators, reward consistency warnings.

Executes Python code in a sandboxed environment and evaluates 8 quality signals.

Parameters:

8 PRM Signals:

V9 Veto Gate: Gate = (E1×0.7 + E4×0.3).max(0.05) — uncompilable code gets near-zero score regardless of other signals.

Verdicts: EXCELLENT (≥85%), GOOD (≥65%), ACCEPTABLE (≥45%), INSUFFICIENT (<45%)

Analyzes a multi-step reasoning chain for coherence, contradictions, novelty decay, and grounding quality.

Parameters:

Based on Bloom's Revised Taxonomy (Anderson & Krathwohl, 2001):

DEFINE ──→ RESEARCH ──→ ANALYZE ──→ HYPOTHESIZE ──→ VERIFY ──→ SYNTHESIZE
  📋          🔍          🔬           💡             ✅          🎯

Zero LLM calls. All verification runs locally:

Anti-Overthinking (R10): Detects stagnation (3+ similar EWMA), fatigue (3+ consecutive drops), and mode collapse (paraphrasing rejected thoughts). Triggers early stopping signals.

Trust Score:

trust = quality×0.40 + evidence×0.20 + grounding×0.20 + calibrated×0.10 + ewma_ok×0.10

6-signal composite with dynamic weighting via softmax (τ=0.5) and CUSUM change-point detection:

EWMA_t = α · reward_t + (1 - α) · EWMA_{t-1}
α = max(2/(n+1), α_floor)    — budget-aware floor

Softmax Gated Attention (V9):
  w_i = prior_i × exp(|x_i - μ| / τ)  — signals deviating from mean get higher weight
  reward = Σ(normalize(w_i) × x_i)

CUSUM change-point detection (V9):
  S_t = max(0, S_{t-1} + (x_t - μ) - k)  — cumulative sum, k=0.05, h=0.15
  Change detected when S_t > h (lag-free, replaces MACD)

• Reward history: Capped at 20 entries (VecDeque ring buffer)
• Stagnation detection: 3+ steps with <2% EWMA change
• Fatigue detection: 3+ consecutive quality drops
• CUSUM collapse detection (V9): Lag-free quality degradation tracking
• Process Advantage Verifier (PAV): Measures advantage over baseline
• Reward Consistency (N3): PRM↔EWMA divergence >0.4 → warning (Z≈1.9, P≈2.9%)

DAG topology tracking across reasoning chains:

• Nodes: Each thought step becomes a node
• Edges: Sequential and revision dependencies
• Longest path: Kahn's topological sort + dynamic programming (convergence-safe)
• Cycle detection: Tarjan's SCC algorithm O(V+E) detects circular reasoning

Arena-allocated MCTS with PUCT scoring (superior to standard UCB1):

PUCT(s,a) = Q(s,a) + c_puct × P(s,a) × √(N_parent) / (1 + N_child)
c_puct adapts based on variance of child Q-values

Sessions maintain state across multiple MCP tool calls sharing the same hypothesis:

• EWMA accumulation: Quality tracking persists across calls
• Novelty tracking: Vocabulary grows across calls
• Graph-of-Thought: DAG builds across calls
• Trend indicator: ↗️ Improving, → Stable, ↘️ Declining
• Hypothesis drift (G11): Semantic distance from original hypothesis
• Root-anchoring: Combined drift detection (hypothesis + first thought)
• Confidence oscillation: Detects rapidly alternating confidence (>3 sign changes in 5 readings)
• Depth degradation: Tracks quality.depth history, detects >50% drop vs baseline
• Epistemological rollback: Snapshot/rollback when MCTS rejects a thought
• Mode collapse guard: Stores rejected thoughts, detects paraphrasing via Jaccard > 0.6
• Auto-expire: TTL 600s to prevent memory leaks

Multi-layered Python sandbox via PyO3:

Validates that thought content actually matches its declared cognitive stage:

• 6 keyword pattern sets: Bilingual (English/Spanish) for each stage
• Alignment score: Ratio of declared vs detected stage patterns
• Logical Validity Score: 4 dimensions — Premise reference (30%), Conclusion support (30%), Backward reference (20%), No logic gaps (20%)
• Warning: Fires when alignment < 0.5 with >2 detected patterns

Each detected bias includes confidence level, explanation, and actionable suggestion.

Cross-MCP bridge to cuba-memorys:

Analogous to the cortex-hippocampus consolidation cycle (McClelland et al., 1995).

cuba-thinking/
└── cuba_cognitive_engine/
    ├── Cargo.toml
    └── src/
        ├── main.rs                          # Entry point
        ├── server/
        │   ├── mcp_protocol.rs              # JSON-RPC 2.0, tool dispatch, progress streaming
        │   └── observability.rs             # Prometheus metrics, tool timing
        └── engine/
            ├── mod.rs                       # Module registry
            │
            ├── ── Cognitive Core ──
            ├── stage_engine.rs              # 6-stage state machine (Bloom's Taxonomy)
            ├── quality_metrics.rs           # 6D quality + Shannon entropy + LZ76 + Root-TTR
            ├── ewma_reward.rs               # Softmax Gated Attention + CUSUM + PAV
            ├── budget.rs                    # 4 budget modes with optimal stopping (Wald 1945)
            ├── anti_hallucination.rs         # 9-layer trust verification + Pareto L2 norm
            ├── bias_detector.rs             # 5 cognitive bias detectors (Kahneman & Tversky)
            ├── metacognition.rs             # Filler, CWR (Coh-Metrix), fallacies, dialectics
            ├── thought_graph.rs             # GoT DAG + Kahn DP + Tarjan SCC O(V+E)
            ├── memory_bridge.rs             # Cross-MCP memory symbiosis + anti-repetition
            ├── formatter.rs                 # Output formatting
            │
            ├── ── Semantics ──
            ├── semantic_similarity.rs       # ONNX embeddings (fastembed BGE-small, 384-dim) + TF-IDF fallback + LRU cache
            ├── contradiction_detector.rs    # NLI zero-shot (rust-bert) + negation, 30+ antonyms, quantifiers
            ├── novelty_tracker.rs           # Jaccard distance + semantic embedding similarity (paraphrase detection)
            ├── claim_grounding.rs           # ROSCOE faithfulness + specificity
            │
            ├── ── Deep Reasoning ──
            ├── thought_session.rs           # Persistent sessions + rollback + trends + drift
            ├── corrective_directives.rs     # 3-level prescriptive corrections (SEAL/FS-C)
            ├── stage_validator.rs           # Stage alignment + Logical Validity (ReasonEval 2024)
            │
            ├── ── Execution ──
            ├── micro_prm.rs                 # 8-signal PRM + Veto Gate (V9)
            ├── sandbox.rs                   # PyO3 sandbox + AST + RLIMIT + PEP 578
            ├── mcts_graph.rs                # PUCT + Adaptive UCT (arena-allocated)
            └── shared_utils.rs              # Centralized stopwords, UTF-8 truncation

Features only appear when actionable:

Every formula verified with unit tests and formal analysis:

Together, they give AI agents memory + reasoning + search + execution.

CC BY-NC 4.0 — Free to use and modify, not for commercial use.

Leandro Pérez G.

• GitHub: @LeandroPG19
• Email: leandropatodo@gmail.com