1# Context Degradation Patterns: Technical Reference
2 
3This document provides technical details on diagnosing and measuring context degradation.
4 
5## Attention Distribution Analysis
6 
7### U-Shaped Curve Measurement
8 
9Measure attention distribution across context positions:
10 
11```python
12def measure_attention_distribution(model, context_tokens, query):
13    """
14    Measure how attention varies across context positions.
15    
16    Returns distribution showing attention weight by position.
17    """
18    attention_by_position = []
19    
20    for position in range(len(context_tokens)):
21        # Measure model's attention to this position
22        attention = get_attention_weights(model, context_tokens, query, position)
23        attention_by_position.append({
24            "position": position,
25            "attention": attention,
26            "is_beginning": position < len(context_tokens) * 0.1,
27            "is_end": position > len(context_tokens) * 0.9,
28            "is_middle": True  # Will be overwritten
29        })
30    
31    # Classify positions
32    for item in attention_by_position:
33        if item["is_beginning"] or item["is_end"]:
34            item["region"] = "attention_favored"
35        else:
36            item["region"] = "attention_degraded"
37    
38    return attention_by_position
39```
40 
41### Lost-in-Middle Detection
42 
43Detect when critical information falls in degraded attention regions:
44 
45```python
46def detect_lost_in_middle(critical_positions, attention_distribution):
47    """
48    Check if critical information is in attention-favored positions.
49    
50    Args:
51        critical_positions: List of positions containing critical info
52        attention_distribution: Output from measure_attention_distribution
53    
54    Returns:
55        Dictionary with detection results and recommendations
56    """
57    results = {
58        "at_risk": [],
59        "safe": [],
60        "recommendations": []
61    }
62    
63    for pos in critical_positions:
64        region = attention_distribution[pos]["region"]
65        if region == "attention_degraded":
66            results["at_risk"].append(pos)
67        else:
68            results["safe"].append(pos)
69    
70    # Generate recommendations
71    if results["at_risk"]:
72        results["recommendations"].extend([
73            "Move critical information to attention-favored positions",
74            "Use explicit markers to highlight critical information",
75            "Consider splitting context to reduce middle section"
76        ])
77    
78    return results
79```
80 
81## Context Poisoning Detection
82 
83### Hallucination Tracking
84 
85Track potential hallucinations across conversation turns:
86 
87```python
88class HallucinationTracker:
89    def __init__(self):
90        self.claims = []
91        self.verifications = []
92    
93    def add_claims(self, text):
94        """Extract claims from text for later verification."""
95        claims = extract_claims(text)
96        self.claims.extend([{"text": c, "verified": None} for c in claims])
97    
98    def verify_claims(self, ground_truth):
99        """Verify claims against ground truth."""
100        for claim in self.claims:
101            if claim["verified"] is None:
102                claim["verified"] = check_claim(claim["text"], ground_truth)
103    
104    def get_poisoning_indicators(self):
105        """
106        Return indicators of potential context poisoning.
107        
108        High ratio of unverified claims suggests poisoning risk.
109        """
110        unverified = sum(1 for c in self.claims if not c["verified"])
111        verified_false = sum(1 for c in self.claims if c["verified"] == False)
112        
113        return {
114            "unverified_count": unverified,
115            "false_count": verified_false,
116            "poisoning_risk": verified_false > 0 or unverified > len(self.claims) * 0.3
117        }
118```
119 
120### Error Propagation Analysis
121 
122Track how errors flow through context:
123 
124```python
125def analyze_error_propagation(context, error_points):
126    """
127    Analyze how errors at specific points affect downstream context.
128 
129    Returns visualization of error spread and impact assessment.
130    """
131    impact_map = {}
132 
133    for error_point in error_points:
134        # Find all references to content after error point
135        downstream_refs = find_references(context, after=error_point)
136 
137        for ref in downstream_refs:
138            if ref not in impact_map:
139                impact_map[ref] = []
140            impact_map[ref].append({
141                "source": error_point,
142                "type": classify_error_type(context[error_point])
143            })
144 
145    # Assess severity
146    high_impact_areas = [k for k, v in impact_map.items() if len(v) > 3]
147 
148    return {
149        "impact_map": impact_map,
150        "high_impact_areas": high_impact_areas,
151        "requires_intervention": len(high_impact_areas) > 0
152    }
153```
154 
155## Distraction Metrics
156 
157### Relevance Scoring
158 
159Score relevance of context elements to current task:
160 
161```python
162def score_context_relevance(context_elements, task_description):
163    """
164    Score each context element for relevance to current task.
165    
166    Returns scores and identifies high-distraction elements.
167    """
168    task_embedding = embed(task_description)
169    
170    scored_elements = []
171    for i, element in enumerate(context_elements):
172        element_embedding = embed(element)
173        relevance = cosine_similarity(task_embedding, element_embedding)
174        scored_elements.append({
175            "index": i,
176            "content_preview": element[:100],
177            "relevance_score": relevance
178        })
179    
180    # Sort by relevance
181    scored_elements.sort(key=lambda x: x["relevance_score"], reverse=True)
182    
183    # Identify potential distractors
184    threshold = calculate_relevance_threshold(scored_elements)
185    distractors = [e for e in scored_elements if e["relevance_score"] < threshold]
186    
187    return {
188        "scored_elements": scored_elements,
189        "distractors": distractors,
190        "recommendation": f"Consider removing {len(distractors)} low-relevance elements"
191    }
192```
193 
194## Degradation Monitoring System
195 
196### Context Health Dashboard
197 
198Implement continuous monitoring of context health:
199 
200```python
201class ContextHealthMonitor:
202    def __init__(self, model, context_window_limit):
203        self.model = model
204        self.limit = context_window_limit
205        self.metrics = []
206    
207    def assess_health(self, context, task):
208        """
209        Assess overall context health for current task.
210        
211        Returns composite score and component metrics.
212        """
213        metrics = {
214            "token_count": len(context),
215            "utilization_ratio": len(context) / self.limit,
216            "attention_distribution": measure_attention_distribution(self.model, context, task),
217            "relevance_scores": score_context_relevance(context, task),
218            "age_tokens": count_recent_tokens(context)
219        }
220        
221        # Calculate composite health score
222        health_score = self._calculate_composite(metrics)
223        
224        result = {
225            "health_score": health_score,
226            "metrics": metrics,
227            "status": self._interpret_score(health_score),
228            "recommendations": self._generate_recommendations(metrics)
229        }
230        
231        self.metrics.append(result)
232        return result
233    
234    def _calculate_composite(self, metrics):
235        """Calculate composite health score from components."""
236        # Weighted combination of metrics
237        utilization_penalty = min(metrics["utilization_ratio"] * 0.5, 0.3)
238        attention_penalty = self._calculate_attention_penalty(metrics["attention_distribution"])
239        relevance_penalty = self._calculate_relevance_penalty(metrics["relevance_scores"])
240        
241        base_score = 1.0
242        score = base_score - utilization_penalty - attention_penalty - relevance_penalty
243        return max(0, score)
244    
245    def _interpret_score(self, score):
246        """Interpret health score and return status."""
247        if score > 0.8:
248            return "healthy"
249        elif score > 0.6:
250            return "warning"
251        elif score > 0.4:
252            return "degraded"
253        else:
254            return "critical"
255```
256 
257### Alert Thresholds
258 
259Configure appropriate alert thresholds:
260 
261```python
262CONTEXT_ALERTS = {
263    "utilization_warning": 0.7,      # 70% of context limit
264    "utilization_critical": 0.9,     # 90% of context limit
265    "attention_degraded_ratio": 0.3, # 30% in middle region
266    "relevance_threshold": 0.3,      # Below 30% relevance
267    "consecutive_warnings": 3        # Three warnings triggers alert
268}
269```
270 
271## Recovery Procedures
272 
273### Context Truncation Strategy
274 
275When context degrades beyond recovery, truncate strategically:
276 
277```python
278def truncate_context_for_recovery(context, preserved_elements, target_size):
279    """
280    Truncate context while preserving critical elements.
281    
282    Strategy:
283    1. Preserve system prompt and tool definitions
284    2. Preserve recent conversation turns
285    3. Preserve critical retrieved documents
286    4. Summarize older content if needed
287    5. Truncate from middle if still over target
288    """
289    truncated = []
290    
291    # Category 1: Critical system elements (preserve always)
292    system_elements = extract_system_elements(context)
293    truncated.extend(system_elements)
294    
295    # Category 2: Recent conversation (preserve more)
296    recent_turns = extract_recent_turns(context, num_turns=10)
297    truncated.extend(recent_turns)
298    
299    # Category 3: Critical documents (preserve key ones)
300    critical_docs = extract_critical_documents(context, preserved_elements)
301    truncated.extend(critical_docs)
302    
303    # Check size and summarize if needed
304    while len(truncated) > target_size:
305        # Summarize oldest category 3 elements
306        truncated = summarize_oldest(truncated, category="documents")
307        
308        # If still too large, truncate oldest turns
309        if len(truncated) > target_size:
310            truncated = truncate_oldest_turns(truncated, keep_recent=5)
311    
312    return truncated
313```
314 
315