# Swireasoning Switch Thinking Reasoning > Dynamically switch between explicit reasoning and latent computation modes during inference to optimize the trade-off between reasoning quality and token consumption. - Skill: `adu2021/swireasoning-switch-thinking-reasoning` (Agent Skill) - Install (CLI): `npx skillmds@latest add adu2021/swireasoning-switch-thinking-reasoning` - Raw SKILL.md: https://api.skillmd.com/api/skills/adu2021/swireasoning-switch-thinking-reasoning/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/swireasoning-switch-thinking-reasoning --- # Technique: Dynamic Reasoning Mode Switching for Efficiency and Quality Large reasoning models face a fundamental trade-off: more explicit reasoning tokens improve answer quality but increase inference cost and latency. SwiReasoning addresses this by enabling models to switch between two modes: explicit reasoning (verbose step-by-step thinking) and latent reasoning (internal computation without explicit tokens). The key insight is that different reasoning tasks and different portions of reasoning have different mode requirements. Simple arithmetic or routine verification can proceed quickly with latent computation. Complex multi-step logical deductions benefit from explicit reasoning chains. By letting the model choose which mode to use for each segment, SwiReasoning achieves better reasoning quality at lower token cost than either mode alone. ## Core Concept SwiReasoning operates with three core components: 1. **Reasoning Mode Control**: At each step, the model chooses between explicit mode (generating visible reasoning tokens) and latent mode (internal computation hidden from output). 2. **Latent-Explicit Hybrid Processing**: Both modes operate on the same model; latent mode simply does not output tokens to the user but still processes representations. 3. **End-to-End Learning**: The model learns mode selection jointly with reasoning through reinforcement learning or supervised fine-tuning, minimizing token usage while maintaining quality. ## Architecture Overview - **Input**: Reasoning problem or query - **Mode Selector**: Neural module or learned policy deciding explicit vs. latent mode - **Explicit Path**: Generate and output reasoning tokens for complex steps - **Latent Path**: Process representations internally without output tokens - **Integration**: Both paths feed into subsequent reasoning steps - **Output**: Final answer with selectively verbose reasoning ## Implementation Steps Create a mode control mechanism that decides when explicit reasoning is beneficial. This can be implemented as a lightweight head attached to the language model. ```python def create_mode_selector(hidden_dim=768, num_modes=2): """ Create a neural module for selecting between reasoning modes. Args: hidden_dim: Dimension of model hidden states num_modes: Number of modes (2 for explicit/latent) Returns: mode_selector: PyTorch module that outputs mode probabilities """ import torch.nn as nn class ModeSelector(nn.Module): def __init__(self, hidden_dim, num_modes): super().__init__() # Take hidden state and predict mode distribution self.mode_head = nn.Sequential( nn.Linear(hidden_dim, hidden_dim // 2), nn.ReLU(), nn.Linear(hidden_dim // 2, num_modes) ) def forward(self, hidden_states): """ Args: hidden_states: (batch, seq_len, hidden_dim) Returns: mode_logits: (batch, seq_len, num_modes) """ mode_logits = self.mode_head(hidden_states) return mode_logits return ModeSelector(hidden_dim, num_modes) ``` Implement the hybrid reasoning loop that switches between explicit and latent modes. ```python def hybrid_reasoning_loop(model, prompt, max_steps=20, explicit_threshold=0.5, mode_selector=None): """ Generate reasoning while dynamically selecting explicit vs. latent modes. Args: model: Language model prompt: Input problem max_steps: Maximum reasoning steps explicit_threshold: Probability threshold for explicit mode mode_selector: Module for mode selection Returns: output: Generated reasoning and answer mode_sequence: List of modes chosen for each step """ import torch import torch.nn.functional as F reasoning_tokens = [] mode_sequence = [] hidden_state = None current_input = prompt for step in range(max_steps): # Get model output and hidden state with torch.no_grad(): output = model(current_input, output_hidden_states=True) hidden_states = output.hidden_states[-1] # Last layer # Predict mode for this step if mode_selector: mode_logits = mode_selector(hidden_states[:, -1:, :]) mode_probs = F.softmax(mode_logits, dim=-1) chosen_mode = torch.argmax(mode_probs, dim=-1) else: # Default: use explicit mode for odd steps chosen_mode = torch.tensor([[step % 2]]) mode_sequence.append(chosen_mode.item()) # Generate next token(s) if chosen_mode.item() == 1: # Explicit mode # Generate reasoning tokens and add to output next_tokens = model.generate( current_input, max_new_tokens=5, temperature=0.7, return_hidden_states=False ) reasoning_tokens.append(model.tokenizer.decode(next_tokens[0])) current_input += " " + model.tokenizer.decode(next_tokens[0]) else: # Latent mode # Process internally without outputting tokens next_tokens = model.generate( current_input, max_new_tokens=1, temperature=0.7, return_hidden_states=True ) # Update state but don't append to reasoning hidden_state = next_tokens[1][-1] # Keep hidden state current_input += " [LATENT]" output = "".join(reasoning_tokens) return output, mode_sequence ``` Implement the reward signal that encourages efficient mode selection during training. ```python def compute_mode_efficiency_reward(reasoning_output, correctness_reward, mode_sequence, explicit_weight=0.1): """ Compute reward combining answer quality and token efficiency. Args: reasoning_output: Generated reasoning text correctness_reward: Binary/continuous reward for correctness mode_sequence: Sequence of chosen modes explicit_weight: Weight for explicit token cost Returns: total_reward: Combined reward for RL training """ # Token cost: count explicit mode selections explicit_tokens = mode_sequence.count(1) # 1 = explicit mode token_cost = explicit_tokens * explicit_weight # Correctness forms base reward quality_reward = correctness_reward # Combined: maximize quality while minimizing token usage total_reward = quality_reward - token_cost return total_reward ``` Integrate mode switching into an RL training loop. ```python def train_reasoning_with_mode_switching(model, mode_selector, optimizer, prompts, rewards, num_epochs=3): """ Train model and mode selector jointly via reinforcement learning. Args: model: Language model policy mode_selector: Mode selection module optimizer: Combined optimizer for model and selector prompts: Training prompts rewards: Correctness signals for generated outputs num_epochs: Training epochs Returns: losses: Training losses over time """ import torch import torch.nn.functional as F losses = [] for epoch in range(num_epochs): epoch_loss = 0.0 for prompt, reward in zip(prompts, rewards): optimizer.zero_grad() # Generate reasoning with mode switching output, mode_seq = hybrid_reasoning_loop( model, prompt, mode_selector=mode_selector ) # Compute log probabilities of chosen modes with torch.no_grad(): model_output = model(prompt, output_hidden_states=True) hidden_states = model_output.hidden_states[-1] mode_logits = mode_selector(hidden_states) mode_probs = F.softmax(mode_logits, dim=-1) # Log probability of chosen modes mode_log_probs = [] for step, mode in enumerate(mode_seq): lp = torch.log(mode_probs[0, step, mode] + 1e-8) mode_log_probs.append(lp) mode_log_probs_tensor = torch.stack(mode_log_probs).mean() # Efficiency reward combining correctness and token cost eff_reward = compute_mode_efficiency_reward( output, reward, mode_seq ) # Policy gradient loss loss = -mode_log_probs_tensor * eff_reward loss.backward() optimizer.step() epoch_loss += loss.item() losses.append(epoch_loss / len(prompts)) return losses ``` ## Practical Guidance | Aspect | Recommendation | Notes | |--------|---------------|-------| | Explicit threshold | 0.5-0.7 | Moderate threshold; adjust based on desired verbosity | | Mode selector architecture | Lightweight (1-2 layers) | Avoid complex selectors that add significant latency | | Training ratio | 3:1 supervised-to-RL | Start with behavior cloning, then switch to RL | | Explicit token weight | 0.05-0.2 | Balance quality vs. efficiency; higher weight favors latent mode | | When to use | Reasoning tasks with variable complexity | Multi-step math, logic, planning problems | | When NOT to use | Simple factual tasks or streaming inference | Latency overhead of mode selection may dominate | | Common pitfall | Mode collapse to single preferred mode | Use entropy regularization to encourage diversity | ### When to Use SwiReasoning - Multi-step reasoning tasks where some steps are routine and others complex - Cost-conscious inference with token budgets or rate limits - Scenarios where explicit reasoning improves transparency - Pareto optimization important (quality-efficiency trade-offs) ### When NOT to Use SwiReasoning - Simple classification or single-step tasks - Real-time systems requiring minimal latency variability - Domains where explainability is secondary - Models with poor hidden state representations ### Common Pitfalls - **Mode collapse**: Model learns to prefer one mode; use entropy regularization on mode selector - **Inconsistent representations**: Latent mode hidden states may diverge from explicit path; share representations - **Reward misalignment**: Explicit token weight may not reflect true cost; calibrate carefully - **Inference instability**: Mode selection adds stochasticity; use deterministic selection (argmax) at test time - **Training inefficiency**: Large mode selector overhead; keep lightweight ## Reference Paper: https://arxiv.org/abs/2510.05069