home / skills / zpankz / mcp-skillset / reasoning-router

reasoning-router skill

safe

This skill routes formal reasoning and deep analysis tasks to targeted sub-skills, enabling precise thinking, proofs, and multi-scale cognition.

npx playbooks add skill zpankz/mcp-skillset --skill reasoning-router

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.1 KB

---
name: reasoning-router
description: Routes formal reasoning, thinking, and analysis tasks. Triggers on reason, prove, verify, formal, atomic, logic, think, analyze-deeply, decompose, validate.
---

# Reasoning Router

Routes formal reasoning, cognitive enhancement, and deep analysis tasks.

## Subcategories

### Cognitive Enhancement
```yaml
triggers: [think, mental-models, non-linear, literate-programming]
skills:
  - think: Cognitive enhancement toolkit
  - goals: Process goals optimization
```

### Formal Reasoning
```yaml
triggers: [prove, verify, formal, atomic, decompose]
skills:
  - AoT: Atom of Thoughts (full)
  - AoT-light: Lightweight AoT
  - reason: Recursive decomposition
```

### Universal Frameworks
```yaml
triggers: [universal, multi-scale, holarchic, complex-system]
skills:
  - urf: Universal Reasoning Framework
  - ontolog: Holarchic reasoning
```

### Domain-Specific
```yaml
triggers: [physiology, biology, medical, quantitative]
skills:
  - telos: Teleological physiology analysis
  - qp: Quantitative physiology calculations
```

## Routing Decision Tree

```
reasoning request
    │
    ├── Cognitive/Thinking?
    │   ├── General? → think
    │   └── Optimization → goals
    │
    ├── Formal proof?
    │   ├── Full analysis? → AoT
    │   ├── Quick? → AoT-light
    │   └── Decomposition → reason
    │
    ├── Universal/Complex?
    │   ├── Multi-scale? → urf
    │   └── Holarchic → ontolog
    │
    └── Domain-specific?
        ├── Physiology? → telos | qp
        └── Other → think
```

## Managed Skills

| Skill | Purpose | Trigger |
|-------|---------|---------|
| think | Cognitive toolkit | "think", "analyze" |
| AoT | Atom of Thoughts | "prove", "atomic" |
| AoT-light | Fast AoT | "quick analysis" |
| reason | Decomposition | "decompose", "understand" |
| urf | Universal framework | "complex", "multi-scale" |
| ontolog | Holarchic | "ontology", "holons" |
| telos | Physiology | "physiology", "biological" |
| qp | Quantitative phys | "calculate", "physiological" |

Overview

This skill routes formal reasoning, deep analysis, and cognitive enhancement tasks to specialized routines. It classifies requests by intent—thinking, proving, decomposing, or domain-specific—and dispatches the most suitable reasoning module. The router is optimized for clarity, traceable decision paths, and rapid selection of heavyweight or lightweight analysis modes.

How this skill works

The router inspects trigger keywords and the high-level goal of the request, then follows a decision tree to assign one of several sub-skills: cognitive toolkits, full formal proofs, lightweight proofs, decomposition engines, universal frameworks, or domain-specific analyzers. When a request matches domain terms (e.g., physiology), it delegates to quantitative or teleological modules; when it matches formal reasoning terms (e.g., prove, atomic) it routes to Atom of Thoughts variants. The router returns the chosen skill name, the rationale for selection, and any recommended analysis mode.

When to use it

You need to decompose a complex problem into logically atomic steps.
You want a full formal proof or stepwise verification of an argument.
You need fast, lightweight reasoning or a quick sanity-check.
You require multi-scale or holarchic analysis of a complex system.
You have physiology or quantitative biological questions needing domain logic.

Best practices

Provide a clear intent statement and include relevant trigger words (reason, prove, decompose).
State desired depth (quick vs full) to choose lightweight or full analysis.
Include domain context when applicable (physiology, quantitative) to enable correct routing.
Request explicit deliverables (proof outline, atomic steps, validation checklist) for traceable outputs.
Prefer structured prompts (goal, constraints, known facts) to speed accurate routing.

Example use cases

Decompose a complex software correctness claim into minimal atomic lemmas for verification.
Run a full Atom of Thoughts proof for a formal logic proposition with stepwise justification.
Perform a fast, heuristic AoT-light check to validate a hypothesis before deeper analysis.
Apply the Universal Reasoning Framework to model multi-scale interactions in a socio-technical system.
Route a physiological modeling question to quantitative physiology for calculations and teleological interpretation.

FAQ

How do I force a specific sub-skill?

Include the sub-skill name or an explicit depth instruction (e.g., 'use AoT' or 'quick analysis') in your prompt.

What happens if triggers overlap?

The router prioritizes intent hierarchy: formal proof triggers (prove, atomic) take precedence for verification tasks; domain-specific terms route to relevant domain modules.