rebalance-efficient-reasoning

name	rebalance-efficient-reasoning
title	ReBalance: Efficient Reasoning with Balanced Thinking
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2603.12372
keywords	["Reasoning Models","Computational Efficiency","Confidence-Guided Steering","Training-Free Optimization"]
description	Diagnose and correct reasoning inefficiencies (overthinking and underthinking) in large reasoning models using confidence-based steering vectors, without retraining. Enables optimal reasoning budgets across model scales.

ReBalance: Efficient Reasoning with Balanced Thinking

Large reasoning models often face a critical tradeoff: they either "overthink" simple problems (wasting computation) or "underthink" difficult ones (producing weak results). Existing approaches require either retraining or task-specific tuning, making them impractical for deployment. ReBalance solves this through confidence monitoring and dynamic steering—a training-free framework that adapts reasoning behavior in real-time.

The core insight is elegant: confidence signals encode reasoning dynamics. High variance in confidence indicates overthinking (the model keeps revising answers), while sustained overconfidence signals underthinking (the model moves forward without adequate exploration). By monitoring these patterns and steering the model's hidden states, ReBalance balances computational efficiency with reasoning quality.

Core Concept

ReBalance operates via confidence-conditioned steering vectors derived from small-scale reference datasets. The approach diagnoses two pathological reasoning modes and corrects them dynamically:

• Overthinking Detection: Identified through coefficient of variation in confidence scores across reasoning steps
• Underthinking Detection: Recognized via consistent but misaligned confidence (high confidence, low correctness)
• Dynamic Steering: Real-time activation magnitude and direction modulation based on detected mode

The framework aggregates hidden states from reference examples to create "reasoning mode prototypes"—compact representations of optimal reasoning trajectories. These prototypes generate steering vectors that guide the model's internal representations without modifying weights.

Architecture Overview

• Reference Dataset Processing: Small auxiliary dataset (100-500 examples) to extract reasoning mode prototypes
• Confidence Tracking: Real-time monitoring of prediction uncertainty across reasoning steps
• Hidden State Aggregation: Collecting and averaging activations from reference examples at each layer
• Dynamic Steering Vector: Computed from layer-wise prototype differences, scaled by confidence signals
• Inference-Time Modulation: Apply steering amplified by confidence variance (overthinking) or dampened (underthinking)

Implementation Steps

Step 1: Build Reasoning Mode Prototypes

Extract hidden state activations from a reference dataset for correct and incorrect reasoning trajectories. For each layer, compute the mean hidden states across successful completions.

import torch
 numpy  np

 ():
    
    prototypes = {layer_idx: []  layer_idx  (num_layers)}

     example  reference_dataset:
        prompt = example[]
        correct_output = example[]

        
         torch.no_grad():
            outputs = model.generate(
                prompt,
                max_new_tokens=,
                output_hidden_states=,
                return_dict_in_generate=
            )
            hidden_states = outputs.hidden_states

        
         layer_idx  (num_layers):
            layer_hidden = hidden_states[layer_idx]
            prototypes[layer_idx].append(layer_hidden)

    
     layer_idx  (num_layers):
        prototypes[layer_idx] = torch.mean(
            torch.stack(prototypes[layer_idx]), dim=
        )

     prototypes