AI SRE vs SRE Copilot vs Agentic SRE: What's the Difference?

# incident_router.py - Unified AI SRE Response System

from enum import Enum
from typing import Optional

class IncidentComplexity(Enum):
    KNOWN_PATTERN = "known"       # Handled by AI SRE
    EXPLORATORY = "exploratory"   # Escalate to Copilot
    STRATEGIC = "strategic"       # Delegate to Agentic

def route_incident(alert: dict) -> dict:
    """
    Route incidents to appropriate AI system based on:
    - Pattern recognition (known runbooks?)
    - Blast radius (how many services affected?)
    - Historical data (seen this before?)
    """
    
    # Step 1: Check if AI SRE has a known remediation
    ai_sre_confidence = check_runbook_match(alert)
    
    if ai_sre_confidence > 0.90 and alert['blast_radius'] < 5:
        # Let AI SRE handle it autonomously
        return {
            'handler': 'ai_sre_platform',
            'action': 'auto_remediate',
            'approval_required': False,
            'expected_mttr': '2 minutes'
        }
    
    elif ai_sre_confidence > 0.70:
        # AI SRE can suggest, but needs human approval
        return {
            'handler': 'ai_sre_platform',
            'action': 'suggest_with_approval',
            'approval_required': True,
            'copilot_assist': True  # Activate copilot for review
        }
    
    elif is_novel_incident(alert):
        # Complex exploration needed - human + copilot
        return {
            'handler': 'sre_copilot',
            'action': 'assist_human_investigation',
            'context': {
                'relevant_docs': fetch_similar_incidents(alert),
                'suggested_queries': generate_exploration_queries(alert),
                'topology_graph': get_affected_services(alert)
            }
        }
    
    elif is_strategic_goal(alert):
        # Long-running optimization task
        return {
            'handler': 'agentic_sre',
            'action': 'multi_step_optimization',
            'agents': ['planner', 'executor', 'monitor'],
            'goal': alert['strategic_goal']
        }

def check_runbook_match(alert: dict) -> float:
    """
    ML model returns confidence that this alert matches 
    a known, verified runbook
    """
    # Example: 0.95 = "OOM kill on payment-service"
    #          0.40 = "Unknown Redis timeout pattern"
    return ml_model.predict(alert['symptoms'])

def is_novel_incident(alert: dict) -> bool:
    """
    Check if incident pattern hasn't been seen in last 90 days
    """
    similar = search_incident_history(
        symptoms=alert['symptoms'], 
        lookback_days=90
    )
    return len(similar) < 2  # Novel if <2 similar incidents

def is_strategic_goal(alert: dict) -> bool:
    """
    Strategic goals like "reduce p99 latency by 20%" or
    "optimize AWS costs by $5k/month"
    """
    return 'strategic_goal' in alert

# Example Usage
alert = {
    'service': 'payment-api',
    'symptom': 'OOMKilled',
    'blast_radius': 2,
    'memory_usage': '4GB / 4GB'
}

response = route_incident(alert)
print(f"Handler: {response['handler']}")
# Output: "Handler: ai_sre_platform" (auto-remediate)