entropy-guided-regeneration

name	entropy-guided-regeneration
title	ERGO: Entropy-guided Resetting for Generation Optimization in Multi-turn Language Models
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.14077
keywords	["multi-turn dialogue","entropy monitoring","context reset","uncertainty detection","prompt consolidation"]
description	Monitor Shannon entropy in LLM token distributions to detect sudden uncertainty spikes, then trigger adaptive prompt consolidation to realign conversation context and improve accuracy by 56.6% and reliability by 35.3%.

Technique: Entropy-Guided Resetting — Uncertainty-Driven Context Consolidation

Multi-turn conversations with LLMs degrade over time as context accumulates and the model loses track of earlier instructions or goals. Rather than treating uncertainty as noise to eliminate, ERGO uses entropy—the model's own uncertainty signal—to detect when the conversation has drifted, then triggers guided context consolidation.

The key insight is that sharp entropy spikes indicate critical moments: when the model suddenly becomes uncertain about what to do next, that's a signal that instructions have become misaligned or context has become incoherent. By monitoring per-token entropy and consolidating context when entropy spikes, ERGO prevents compounding errors while maintaining conversation flow.

Core Concept

ERGO operates on three principles:

• Entropy Monitoring: Track Shannon entropy of next-token probability distributions at each step
• Spike Detection: Identify sudden increases in entropy (threshold-based or learned)
• Prompt Consolidation: When entropy spikes, synthesize conversation state and reinject clear instructions
• Adaptive Thresholds: Learn task-specific entropy baselines during warm-up phase

The method improves multi-turn reasoning tasks where instructions are revealed incrementally by detecting when the model has lost context and automatically recovering.

Architecture Overview

• Token-Level Entropy Computation: Calculate H(P) for each generated token
• Entropy Baseline Tracker: Maintain running exponential moving average of baseline entropy
• Spike Detector: Compare current entropy to baseline; flag when difference exceeds threshold
• Context Compressor: Summarize conversation history to essential information
• Instruction Injector: Synthesize high-level task state and goals
• Prompt Rewriter: Insert consolidated context + original instructions back into conversation

Implementation Steps

The core algorithm computes entropy per token and triggers consolidation when entropy spikes. This example shows entropy monitoring and context reset.

import numpy as np
from collections import deque

class EntropyGuidedContextManager:
    

     ():
        .entropy_window = deque(maxlen=entropy_window_size)
        .baseline_entropy = 
        .baseline_alpha = baseline_alpha  
        .spike_threshold = spike_threshold
        .consolidation_interval = consolidation_interval
        .turn_counter = 

     ():
        
        probs = np.softmax(token_logits, axis=-)
        entropy = -np.(probs * np.log(np.maximum(probs, )), axis=-)
         entropy

     ():
        
        
        .entropy_window.append(token_entropy)

        
         .baseline_entropy    (.entropy_window) >= :
            .baseline_entropy = np.mean((.entropy_window))

        
         (.entropy_window) > :
            current_avg = np.mean((.entropy_window))
             .baseline_entropy   :
                .baseline_entropy = (
                    .baseline_alpha * .baseline_entropy +
                    ( - .baseline_alpha) * current_avg
                )

        
         .baseline_entropy   :
            entropy_increase = token_entropy - .baseline_entropy
            spike_detected = entropy_increase > .spike_threshold
        :
            spike_detected = 

        
        .turn_counter += 
        forced_consolidation = (
            .turn_counter >= .consolidation_interval
        )

        should_reset = spike_detected  forced_consolidation
         should_reset, entropy_increase  .baseline_entropy  


 ():
    
    
    summary_prompt = 
    summary = summarizer_model.generate(summary_prompt, max_tokens=)

    
    state_prompt = 
    current_state = summarizer_model.generate(state_prompt, max_tokens=)

    
    consolidated = 
     consolidated


 ():
    
    conversation = []
    current_context = initial_prompt

     turn_idx, user_input  (user_turns):
        
        conversation.append((, user_input))

        
        response_tokens = []
         token_idx  ():  
            
            next_token, logits = model.generate_next(
                current_context,
                return_logits=
            )

            response_tokens.append(next_token)

            
            token_entropy = entropy_manager.compute_entropy(logits)

            
            should_consolidate, entropy_delta = entropy_manager.should_consolidate(
                token_entropy,
                (conversation)
            )

             should_consolidate:
                (
                      )

                
                consolidated = consolidate_conversation_context(
                    conversation,
                    initial_prompt,
                    summarizer_model=model
                )

                current_context = consolidated + .join(response_tokens)

        
        response_text = model.tokenizer.decode(response_tokens)
        conversation.append((, response_text))
        current_context += response_text + 

     conversation