# Mix Reasoning Switching Modes

> Improve reasoning efficiency by dynamically adjusting elaboration depth within a single response. Difficult steps receive extensive chain-of-thought; straightforward steps use concise inference. Mix reasoning modes to achieve 57-79% token savings under compute budgets while maintaining accuracy on math, STEM, and coding benchmarks.

- Skill: `adu2021/mix-reasoning-switching-modes` (Agent Skill)
- Install (CLI): `npx skillmds@latest add adu2021/mix-reasoning-switching-modes`
- Raw SKILL.md: https://api.skillmd.com/api/skills/adu2021/mix-reasoning-switching-modes/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: adu2021 (https://skillmd.com/u/adu2021)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/adu2021/mix-reasoning-switching-modes

---


# MixReasoning: Switching Modes to Think

## Core Concept

Reasoning models apply uniform elaboration depth to all problem-solving steps despite varying difficulty. MixReasoning detects step complexity and allocates reasoning resources accordingly—providing detailed chain-of-thought for hard steps while using brief inference for simple ones. This adaptive depth adjustment reduces token consumption by 57-79% while preserving accuracy.

## Architecture Overview

- **Mode Detection**: Identify which steps require detailed reasoning vs. simple computation
- **Dynamic Depth Allocation**: Assign elaboration level per step (short, medium, detailed)
- **Mixed Reasoning Chains**: Interleave concise and detailed steps in single response
- **Efficiency Metrics**: Measure token savings under fixed computational budgets
- **Training-Free**: Apply via inference-time prompting without model retraining

## Implementation Steps

### 1. Mode Detection Framework

Classify steps by complexity before deciding reasoning depth.

```python
class StepComplexityClassifier:
    def __init__(self, classification_model='gpt-4.1'):
        self.model = classification_model

    def classify_step_complexity(self, problem_context, step_description):
        """
        Classify a reasoning step as: SIMPLE | MEDIUM | DIFFICULT
        """

        prompt = f"""Problem: {problem_context}

Current step: {step_description}

How complex is this step?
- SIMPLE: Straightforward computation, obvious next action
- MEDIUM: Some reasoning needed, standard technique
- DIFFICULT: Complex logic, novel approach, multiple substeps

Classification: """

        response = self.model.complete(prompt)
        complexity = response.strip().split()[0].upper()

        return complexity

    def analyze_full_problem(self, problem, solution_steps):
        """
        Analyze complexity of all steps in a problem.
        """

        complexities = []
        for step_idx, step in enumerate(solution_steps):
            complexity = self.classify_step_complexity(problem, step)
            complexities.append(complexity)

        return complexities
```

### 2. Mode-Specific Elaboration Strategies

Define reasoning depth for each mode.

```python
class MixReasoningModes:
    """
    Three elaboration modes: BRIEF, STANDARD, DETAILED
    """

    @staticmethod
    def brief_reasoning(step_description, context):
        """
        Concise inference: skip intermediate steps, state conclusion.
        ~20-50 tokens
        """
        prompt = f"""Problem context: {context}

Step (brief mode): {step_description}

Provide a concise answer without detailed reasoning. One line conclusion:"""

        return prompt

    @staticmethod
    def standard_reasoning(step_description, context):
        """
        Normal chain-of-thought: explain key logic.
        ~100-200 tokens
        """
        prompt = f"""Problem context: {context}

Step (standard mode): {step_description}

Explain your reasoning in 2-3 sentences:"""

        return prompt

    @staticmethod
    def detailed_reasoning(step_description, context):
        """
        Detailed elaboration: full chain-of-thought with substeps.
        ~300-500 tokens
        """
        prompt = f"""Problem context: {context}

Step (detailed mode): {step_description}

Provide detailed reasoning:
1. Key insight
2. Substeps
3. Final answer"""

        return prompt

    @staticmethod
    def select_mode_for_complexity(complexity_level):
        """
        Map complexity → elaboration mode
        """
        mapping = {
            'SIMPLE': 'brief',
            'MEDIUM': 'standard',
            'DIFFICULT': 'detailed'
        }
        return mapping.get(complexity_level, 'standard')
```

### 3. Full MixReasoning Pipeline

Orchestrate complexity classification and mode selection.

```python
class MixReasoningOrchestrator:
    def __init__(self, classifier_model, reasoning_model):
        self.classifier = StepComplexityClassifier(classifier_model)
        self.modes = MixReasoningModes()
        self.reasoning_model = reasoning_model

    def solve_with_mixed_reasoning(self, problem, proposed_steps, budget_tokens=4096):
        """
        Solve problem with mixed reasoning depths.
        Allocate tokens based on step complexity.
        """

        # Step 1: Classify complexity of all steps
        complexities = []
        for step in proposed_steps:
            complexity = self.classifier.classify_step_complexity(problem, step)
            complexities.append(complexity)

        # Step 2: Allocate reasoning depth per step
        allocated_tokens = self._allocate_tokens(complexities, budget_tokens)

        # Step 3: Generate solutions with appropriate depth
        full_reasoning = f"Problem: {problem}\n\n"
        used_tokens = 0

        for step_idx, (step, complexity, token_limit) in enumerate(
            zip(proposed_steps, complexities, allocated_tokens)
        ):
            # Select mode based on complexity
            mode = self.modes.select_mode_for_complexity(complexity)

            # Generate elaboration with token budget
            if mode == 'brief':
                elaboration = self.reasoning_model.generate(
                    self.modes.brief_reasoning(step, problem),
                    max_tokens=50
                )
            elif mode == 'standard':
                elaboration = self.reasoning_model.generate(
                    self.modes.standard_reasoning(step, problem),
                    max_tokens=200
                )
            else:  # detailed
                elaboration = self.reasoning_model.generate(
                    self.modes.detailed_reasoning(step, problem),
                    max_tokens=500
                )

            full_reasoning += f"Step {step_idx+1} ({complexity}): {elaboration}\n\n"
            used_tokens += len(elaboration.split())

        return {
            'full_reasoning': full_reasoning,
            'complexities': complexities,
            'tokens_used': used_tokens,
            'budget': budget_tokens,
            'efficiency': 1 - (used_tokens / budget_tokens)
        }

    def _allocate_tokens(self, complexities, total_budget):
        """
        Allocate token budget based on step complexities.
        Difficult steps get more tokens.
        """

        # Weight by complexity: SIMPLE=1, MEDIUM=2, DIFFICULT=3
        weights = {
            'SIMPLE': 1,
            'MEDIUM': 2,
            'DIFFICULT': 3
        }

        complexity_weights = [weights.get(c, 2) for c in complexities]
        total_weight = sum(complexity_weights)

        # Proportional allocation
        allocation = [
            int((w / total_weight) * total_budget)
            for w in complexity_weights
        ]

        return allocation
```

### 4. Benchmark Evaluation

Test on math, STEM, and coding tasks with fixed compute budgets.

```python
def evaluate_mix_reasoning(benchmark_name, problems, gold_solutions):
    """
    Evaluate mixed reasoning on benchmarks: GSM8K, MATH-500, AIME, CodeElo
    """

    orchestrator = MixReasoningOrchestrator(
        classifier_model='gpt-4.1',
        reasoning_model='deepseek-r1'
    )

    results = {
        'accuracy': 0,
        'token_efficiency': 0,
        'avg_reasoning_length': 0
    }

    for problem, gold_solution in zip(problems, gold_solutions):
        # Parse solution into steps
        solution_steps = parse_solution(gold_solution)

        # Solve with mixed reasoning
        result = orchestrator.solve_with_mixed_reasoning(
            problem,
            solution_steps,
            budget_tokens=4096
        )

        # Evaluate correctness and efficiency
        final_answer = extract_answer(result['full_reasoning'])
        is_correct = final_answer == gold_solution

        if is_correct:
            results['accuracy'] += 1

        results['token_efficiency'] += result['efficiency']
        results['avg_reasoning_length'] += len(result['full_reasoning'].split())

    # Normalize
    n = len(problems)
    results['accuracy'] /= n
    results['token_efficiency'] /= n
    results['avg_reasoning_length'] /= n

    return results

# Example results
benchmark_results = {
    'gsm8k': {
        'accuracy': '94.2%',
        'token_savings': '67%',
        'vs_uniform_reasoning': '+3-5% accuracy at same token budget'
    },
    'math_500': {
        'accuracy': '89.3%',
        'token_savings': '71%',
    },
    'aime': {
        'accuracy': '68.5%',
        'token_savings': '57%',
    },
    'codeelo': {
        'accuracy': '73.1%',
        'token_savings': '79%',
    }
}
```

## Practical Guidance

**Complexity Detection**: Use small classifier model (GPT-4.1-mini) to detect step complexity cost-effectively. False classifications have modest impact; algorithm self-corrects via step failure.

**Token Budget**: Fix total tokens and allocate proportionally to complexity. Under constrained budgets, mixed reasoning outperforms uniform depth by 5-15% accuracy.

**Mode Thresholds**: Simple/Medium split at problem-solving clarity. Medium/Difficult at requiring novel combinations. Tune thresholds per domain.

**Training-Free**: MixReasoning applies at inference time via prompting. No model retraining needed; works with any reasoning model.

## When to Use / When NOT to Use

**Use When**:
- Reasoning problems with variable step difficulty (math, STEM, coding)
- Fixed inference token budgets are critical (constrained deployments)
- Mixed elaboration is acceptable (some steps less detailed than others)
- You can classify step complexity reliably

**NOT For**:
- Problems requiring uniform depth reasoning (safety-critical systems)
- Domains without clear step structure
- Open-ended generation (creativity benefits from consistent depth)

## Reference

This skill synthesizes findings from "MixReasoning: Switching Modes to Think" (arXiv:2510.06052). Adaptive reasoning depth reduces token consumption 57-79% while preserving accuracy on standard benchmarks.