chain-of-mindset-adaptive-reasoning

name	chain-of-mindset-adaptive-reasoning
title	Chain of Mindset: Reasoning with Adaptive Cognitive Modes
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2602.10063
keywords	["Adaptive Reasoning","Multi-Modal Thinking","Step-Level Orchestration","Training-Free","Meta-Agent"]
description	Enable language models to dynamically switch between four cognitive modes (spatial, convergent, divergent, algorithmic) during problem-solving. Meta-agent observes state and selects optimal mode per step, improving reasoning across math, coding, and spatial tasks without requiring model training.

Chain of Mindset: Adaptive Multi-Modal Reasoning

Single problem-solving strategies fail across diverse task types. Mathematical derivations need convergent logic; creative ideation needs divergent exploration; spatial tasks need visualization; calculations need algorithmic precision. Chain of Mindset (CoM) enables training-free dynamic mode switching, where the model selects appropriate cognitive approaches per reasoning step rather than committing upfront to one strategy.

A Meta-Agent observes reasoning progress and decides which of four specialized mindsets to engage next: Spatial (visualization), Convergent (focused analysis), Divergent (parallel exploration), Algorithmic (precise calculation). Context Gates prevent information pollution between modes while maintaining efficiency.

Core Concept

Standard approach: apply single reasoning strategy throughout problem. Inefficient for multi-faceted problems.

CoM approach: decompose problem into steps, use Meta-Agent to assign optimal cognitive mode per step. Modes collaborate asynchronously: spatial mode generates diagrams, convergent mode analyzes alternatives, divergent mode explores options, algorithmic mode executes calculations.

Key insight: problem-solving naturally decomposes into stages requiring different cognitive approaches. No training needed—just better prompting structure.

Architecture Overview

• Four Cognitive Modes:

  • Spatial: Visualize abstract concepts through diagrams, spatial relationships
  • Convergent: Focused logical analysis on specific questions
  • Divergent: Parallel exploration of multiple solution paths
  • Algorithmic: Precise calculations, symbolic manipulation, code

• Meta-Agent: Observes current reasoning state, selects appropriate next mode

• Context Gates: Filter information flow between modes, prevent context pollution

• Step-Level Orchestration: Dynamically revise reasoning plan when intermediate results suggest better paths

• Training-Free: All logic implemented via prompting; no model updates

Implementation

Define mode-specific prompts and context management:

MODE_PROMPTS = {
    'spatial': """You are a spatial reasoning mode. Visualize the problem using diagrams,
coordinate systems, or visual representations. Describe spatial relationships, positions, and geometric patterns.
Output: ASCII diagram or detailed spatial description.""",

    'convergent': ,

    : ,

    : 
}

 ():
    
     meta_agent_prompt  :
        meta_agent_prompt = 

    
    response = query_model(
        meta_agent_prompt.(state=reasoning_state)
    )

    
    modes = [, , , ]
     mode  modes:
         mode  response.lower():
             mode

       

 :
    

     ():
        .mode_contexts = {}

     ():
        
        
         target_mode == :
            
            filtered = .join([
                line  line  full_context.split()
                  (x  line.lower()  x  [, , ])
            ])
         target_mode == :
            
            filtered = .join([
                line  line  full_context.split()
                  (x  line.lower()  x  [, , ])
            ])
        :
            filtered = full_context

         filtered

 :
    

     ():
        .model = base_model
        .max_iterations = max_iterations
        .context_gate = ContextGate()
        .full_reasoning = 
        .mode_history = []

     ():
        
        reasoning = 

         iteration  (.max_iterations):
            
            selected_mode = select_cognitive_mode(reasoning)
            .mode_history.append(selected_mode)

            
            filtered_context = .context_gate.filter_for_mode(reasoning, selected_mode)

            
            mode_prompt = MODE_PROMPTS[selected_mode]
            full_prompt = 

            mode_output = .model.generate(full_prompt, max_tokens=)
            reasoning += 

            
             (x  mode_output.lower()  x  [, , ]):
                

        .full_reasoning = reasoning
         reasoning

     ():
        
         re

        
        patterns = [
            ,
            ,
            ,
            
        ]

         pattern  patterns:
             = re.search(pattern, .full_reasoning, re.IGNORECASE)
             :
                 .group().strip()

        
        lines = [l.strip()  l  .full_reasoning.split()  l.strip()]
         lines[-]  lines