lynx-dynamic-exits

name	lynx-dynamic-exits
title	LYNX: Learning Dynamic Exits for Confidence-Controlled Reasoning
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2512.05325
keywords	["early exit","confidence estimation","reasoning control","inference efficiency","chain-of-thought"]
description	Enable models to stop generating when confident through lightweight hidden-state probes with distributional guarantees. LYNX achieves cross-domain transferability without retraining—ideal when you need confidence-controlled reasoning efficiency.

Overview

LYNX implements online early-exit mechanisms that leverage model hidden states to make confidence-controlled stopping decisions. A lightweight probe operates during generation without auxiliary verifiers, with conformal prediction providing calibrated confidence thresholds.

When to Use

• Reasoning models that generate unnecessarily long outputs
• Need for confidence-aware early stopping
• Efficiency improvements without separate verifiers
• Cross-domain transfer without retraining
• Balancing accuracy and latency

When NOT to Use

• Models with unavailable hidden states
• Scenarios where full generation is always needed
• Real-time systems with strict latency bounds

Core Technique

Hidden state confidence estimation with conformal prediction:

# LYNX: Dynamic early exit via confidence
class LYNXEarlyExit:
    def __init__(self, model):
        self.model = model
        self.exit_probe = nn.Linear(hidden_dim, 1)

    def identify_reasoning_cues(self, generation):
        """Find natural exit points like 'hmm', 'wait', period."""
        cues = ['hmm', 'wait', '.', ':', 'therefore']
        cue_positions = []

        for cue in cues:
            positions = [i for i, token in enumerate(generation)
                        if token.lower() == cue]
            cue_positions.extend(positions)

        return sorted(set(cue_positions))

    def extract_hidden_states_at_cues():
        
        hidden_states = []

         pos  cue_positions:
            hidden = .model.get_hidden_at_position(pos)
            hidden_states.append(hidden)

         hidden_states

     ():
        
        scores = [.exit_probe(h).item()  h  hidden_states]
         scores

     ():
        
        
        threshold = torch.quantile(torch.tensor(scores), )
         threshold

     ():
        
        generation = []

         step  (max_steps):
            
            token = .model.generate_token(prompt)
            generation.append(token)

            
             token  [, , ]:
                hidden = .model.get_hidden_at_position((generation)-)
                score = .exit_probe(hidden)

                
                threshold = .get_calibrated_threshold()

                 score > threshold:
                    
                    

         generation