adu2021 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.
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.
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.
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.
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.