wyattowalsh Reasoning Router
Meta-reasoning layer: classify problems, dispatch to the optimal thinking MCP, monitor progress, re-route on stall. Minimize total tokens to a high-confidence conclusion.
Always uses the most advanced model (currently Opus 4.6). Meta-reasoning about how to think is the highest-leverage reasoning task.
Dispatch
$ARGUMENTS |
Action |
|---|---|
| Problem or question text | Route — classify and dispatch to optimal thinking method |
compare <problem> |
Compare — run 2-3 strategies on the same problem, pick best |
status |
Status — show current thinking session state |
switch <method> |
Switch — re-route to specified method mid-session |
recap |
Recap — summarize reasoning so far across all methods used |
methods |
Methods — show available methods with when-to-use cheatsheet |
| Empty | Guide — show routing cheatsheet and token tier table |
Classification
Run !uv run python scripts/problem-classifier.py "$ARGUMENTS"
for deterministic pre-scan, then refine with LLM judgment.
Axis 1 — Structure (what shape is the reasoning?)
| Structure | Signals | Primary Method |
|---|---|---|
| Decomposable | "break down", multi-hop, sub-questions | atom-of-thoughts |
| Sequential | "step by step", ordered process, debugging | sequential-thinking |
| Branching | "explore options", "what if", alternatives | cascade-thinking |
| Constrained | "given that", requirements, formal specs | shannon-thinking |
| Interconnected | dependencies, circular, complex system | atom-of-thoughts (full) |
| Creative | "brainstorm", "novel", "stuck", "reframe" | creative-thinking |
| Contradictory | paradox, "both true", tension, dilemma | lotus-wisdom |
| Investigative | "why did", root cause, debug, diagnose | crash |
Axis 2 — Complexity (how deep?)
| Complexity | Signals | Depth Control |
|---|---|---|
| Simple (1-3 steps) | Short input, single concept, "quick" | Tier 1 ONLY: aot-light or sequential |
| Moderate (4-8 steps) | Multiple factors, some uncertainty | Default depth, structure-matched method |
| Complex (9+ steps) | Cross-domain, high uncertainty | Full depth, extended steps |
| Wicked (open-ended) | No clear solution, values conflict | Composition patterns allowed |
Axis 3 — Domain (what kind?)
| Domain | Method | Why |
|---|---|---|
| Engineering/architecture | shannon-thinking |
Constraints → model → proof |
| Debugging | crash |
Tool-aware investigation |
| Research | cascade-thinking |
Parallel perspectives |
| Math/logic | atom-of-thoughts |
Dependency DAG |
| Strategy | think-strategies |
Strategy comparison |
| Creative/design | creative-thinking |
Lateral techniques |
| Philosophy/ethics | lotus-wisdom |
Non-dual integration |
| Planning | sequential-thinking |
Linear progression |
| Pattern tracking | structured-thinking |
Persistent memory |
Routing Algorithm
Optimize for minimum total tokens to reach a high-confidence conclusion.
1. Run problem-classifier.py for deterministic signals
2. Score each axis (structure × complexity × domain)
3. Apply efficiency gate:
- Simple: ALWAYS Tier 1 (aot-light or sequential-thinking)
- Moderate: structure-matched method at default depth
- Complex: full method with extended depth
- Wicked: composition patterns allowed
4. Resolve conflicts:
- Structure > domain (HOW > WHAT)
- Complexity modulates depth AND tier
- Ties: ALWAYS prefer lower token cost
5. Select primary + fallback
6. Present: "Using [method] — [why]. Fallback: [method]." (1 line)
7. Invoke with minimum viable totalThoughts
8. Monitor for stalls — escalate only on evidence
Token Cost Tiers
Tier 1 (lightest): aot-light, sequential-thinking
Tier 2 (moderate): structured-thinking, cascade-thinking, crash
Tier 3 (heavy): shannon-thinking, atom-of-thoughts (full), think-strategies
Tier 4 (heaviest): creative-thinking, deep-lucid-3d, lotus-wisdom
Efficiency Rules
- Never Tier 3-4 for a problem Tier 1-2 can handle
- Start with lowest viable
totalThoughts; expand only onneedsMoreThoughts cascade-thinking: start 2 branches max; add only if coverage insufficientcreative-thinking: usetimeframe: "quick"unless wickedthink-strategies: start withlinearorchain_of_thoughtbefore heavier strategies
Stall Detection
Read references/stall-detection.md when any stall signal fires.
4 stall signals:
- Confidence plateau — no increase >0.05 in 3+ steps
- Circular reasoning — same claim restated
- Step overrun — exceeds 2× initial estimate
- User signal — "try something else" or
/think switch
Re-routing by block type:
| Block | New Method | Why |
|---|---|---|
| Stuck in depth | cascade-thinking |
Broaden |
| Too broad | atom-of-thoughts |
Decompose |
| Too formal | creative-thinking |
Reframe |
| Too abstract | crash |
Ground in evidence |
| Contradictions | lotus-wisdom |
Integrate |
| Wrong method | Reclassify | Start routing over |
Hard limits: Max 3 re-routes per session. Max 3× step estimate. No ping-pong (can't return to a method already re-routed from). After 3 re-routes → recovery protocol: present findings, ask user to guide.
Composition Patterns
Read references/composition-patterns.md for full protocols.
| Pattern | Sequence | When |
|---|---|---|
| Sketch→Detail | aot-light → aot (full) |
Quick outline then deep dive |
| Diverge→Converge | creative-thinking → sequential |
Generate options then evaluate |
| Explore→Formalize | cascade-thinking → shannon |
Survey landscape then prove |
| Decompose→Investigate | aot → crash (per atom) |
Break down then debug each |
| Analyze→Integrate | cascade-thinking → lotus-wisdom |
Surface contradictions then synthesize |
| Strategize→Plan | think-strategies → sequential |
Step back then plan forward |
Context transfer: At every method transition, produce ≤100 word summary of key findings with confidence scores. Carry claims, drop scaffolding.
When NOT to compose: Simple/moderate complexity, first method is converging, time pressure is high.
Compare Mode
When invoked with compare <problem>:
- Classify the problem normally
- Select 2-3 candidate methods (primary + 1-2 plausible alternatives)
- Run each for 3-5 steps on the same problem
- Compare: which produced higher-confidence findings with fewer tokens?
- Present comparison table and recommend the winner
- Continue with the winning method if user agrees
Methods Quick Reference
When invoked with methods or for the routing cheatsheet:
| Method | MCP Tool | Tier | Sweet Spot |
|---|---|---|---|
| sequential-thinking | sequentialthinking |
1 | Linear, ordered reasoning |
| aot-light | aot-light |
1 | Quick atomic sketches |
| structured-thinking | capture_thought |
2 | Cross-session memory |
| cascade-thinking | cascade_thinking |
2 | Multi-perspective exploration |
| crash | crash |
2 | Debugging with tool integration |
| shannon-thinking | shannonthinking |
3 | Formal proof under constraints |
| atom-of-thoughts | aot + atomcommands |
3 | Deep decomposition with DAG |
| think-strategies | think-strategies |
3 | Named strategy frameworks |
| creative-thinking | discover_techniques → plan → execute |
4 | Lateral thinking (3-step required) |
| deep-lucid-3d | analyze_problem |
4 | Holistic UCPF analysis |
| lotus-wisdom | lotuswisdom (start: tag: begin) |
4 | Paradox and contradiction |
Read references/capability-map.md for full tool parameters and workflows.
Reference File Index
| File | Read When |
|---|---|
references/capability-map.md |
First invocation or unfamiliar with a tool's parameters |
references/routing-matrix.md |
Resolving routing conflicts, ties, or edge cases |
references/composition-patterns.md |
Problem needs a multi-tool sequence |
references/stall-detection.md |
Stall signal fires or session exceeds expected steps |
Load ONE reference at a time. Do not preload.
Scope Boundaries
In scope: Problem classification, thinking MCP dispatch, stall detection, re-routing, composition pattern selection, method comparison.
Out of scope: Actually performing the reasoning (the thinking MCP does that), running tools or writing code (use appropriate skills), code review (review), research (research), debugging implementation (use crash MCP directly).
Canonical Vocabulary
| Term | Meaning |
|---|---|
| method | A specific thinking MCP tool (e.g., cascade-thinking) |
| tier | Token cost classification (1=lightest, 4=heaviest) |
| structure | The shape of reasoning a problem requires |
| routing | Selecting the best method for a classified problem |
| stall | When a method stops making progress (confidence plateau, circular reasoning) |
| re-route | Switching to a different method mid-session |
| composition | Chaining 2+ methods sequentially for complex problems |
| efficiency gate | Override that forces Tier 1 methods for simple problems |
| context transfer | Summarizing findings when switching between methods |
Critical Rules
- Always use the most advanced model —
model: opus. Never downgrade. - Minimize total tokens to conclusion — pick the lightest method that handles the problem. Escalate only on evidence of stall.
- Present routing decision before invoking — 1 line: method, why, fallback.
- Never invoke without classification — even if user names a method, validate fit.
- Carry forward on re-route — summarize findings ≤100 words, don't restart.
- Simple gets simple — Tier 1 for simple problems, always. No exceptions.
- Token cost breaks ties — equal fit → lower tier wins.
- Start minimal, expand on evidence — lowest
totalThoughts, expand only when the tool requests more or stall detected. - One method at a time — no simultaneous thinking MCPs. Composition is sequential.
- Router ≠ thinker — classify, dispatch, monitor. Don't duplicate reasoning.
- Respect tool workflows — creative-thinking: discover→plan→execute.
lotus-wisdom: start with
tag: begin. aot: useatomcommandsfor control. - Track token spend — note approximate tokens per session to refine routing.