model-detection skill

---
name: model-detection
description: Universal model detection and capability assessment for optimal cross-model compatibility
version: 1.0.0
---

## Overview

This skill provides universal model detection and capability assessment to optimize the Autonomous Agent Plugin across different LLM models (Claude Sonnet, Claude 4.5, GLM-4.6, etc.).

## Model Detection Algorithm

### Primary Detection Methods

1. **System Context Analysis**:
   ```javascript
   // Check for model indicators in system context
   const modelIndicators = {
     'claude-sonnet-4.5': { pattern: /sonnet.*4\.5|4\.5.*sonnet/i, confidence: 0.9 },
     'claude-haiku-4.5': { pattern: /haiku.*4\.5|4\.5.*haiku/i, confidence: 0.9 },
     'claude-opus-4.1': { pattern: /opus.*4\.1|4\.1.*opus/i, confidence: 0.9 },
     'glm-4.6': { pattern: /glm|4\.6/i, confidence: 0.9 },
     'claude-haiku': { pattern: /haiku(?!\.*4\.5)/i, confidence: 0.8 }
   }
   ```

2. **Performance Pattern Recognition**:
   ```javascript
   // Analyze execution patterns to identify model
   const performanceSignatures = {
     'claude-sonnet-4.5': { reasoning: 'nuanced', speed: 'fast', adaptability: 'high' },
     'claude-haiku-4.5': { reasoning: 'focused', speed: 'very_fast', adaptability: 'high' },
     'claude-opus-4.1': { reasoning: 'enhanced', speed: 'very_fast', adaptability: 'very_high' },
     'glm-4.6': { reasoning: 'structured', speed: 'moderate', adaptability: 'medium' }
   }
   ```

3. **Capability Assessment**:
   ```javascript
   // Test specific capabilities
   const capabilityTests = {
     nuanced_reasoning: testAmbiguousScenario,
     structured_execution: testLiteralInterpretation,
     context_switching: testMultiTaskContext,
     adaptive_learning: testPatternRecognition
   }
   ```

## Model-Specific Configurations

### Claude Sonnet 4.5 Configuration
```json
{
  "model_type": "claude-sonnet-4.5",
  "capabilities": {
    "reasoning_style": "nuanced",
    "context_management": "adaptive",
    "skill_loading": "progressive_disclosure",
    "error_handling": "pattern_based",
    "communication_style": "natural_flow"
  },
  "performance_targets": {
    "execution_time_multiplier": 1.0,
    "quality_score_target": 90,
    "autonomy_level": "high",
    "delegation_style": "parallel_context_merge"
  },
  "optimizations": {
    "use_context_switching": true,
    "apply_improvisation": true,
    "weight_based_decisions": true,
    "predictive_delegation": true
  }
}
```

### Claude Haiku 4.5 Configuration
```json
{
  "model_type": "claude-haiku-4.5",
  "capabilities": {
    "reasoning_style": "focused",
    "context_management": "efficient",
    "skill_loading": "selective_disclosure",
    "error_handling": "fast_prevention",
    "communication_style": "concise"
  },
  "performance_targets": {
    "execution_time_multiplier": 0.8,
    "quality_score_target": 88,
    "autonomy_level": "medium",
    "delegation_style": "focused_parallel"
  },
  "optimizations": {
    "use_fast_execution": true,
    "apply_focused_reasoning": true,
    "efficient_delegation": true,
    "streamlined_processing": true
  }
}
```

### Claude Opus 4.1 Configuration
```json
{
  "model_type": "claude-opus-4.1",
  "capabilities": {
    "reasoning_style": "enhanced",
    "context_management": "predictive",
    "skill_loading": "intelligent_progressive",
    "error_handling": "predictive_prevention",
    "communication_style": "insightful"
  },
  "performance_targets": {
    "execution_time_multiplier": 0.9,
    "quality_score_target": 95,
    "autonomy_level": "very_high",
    "delegation_style": "predictive_parallel"
  },
  "optimizations": {
    "use_context_switching": true,
    "apply_improvisation": true,
    "anticipatory_actions": true,
    "enhanced_pattern_learning": true
  }
}
```

### GLM-4.6 Configuration
```json
{
  "model_type": "glm-4.6",
  "capabilities": {
    "reasoning_style": "structured",
    "context_management": "sequential",
    "skill_loading": "complete_loading",
    "error_handling": "rule_based",
    "communication_style": "structured_explicit"
  },
  "performance_targets": {
    "execution_time_multiplier": 1.25,
    "quality_score_target": 88,
    "autonomy_level": "medium",
    "delegation_style": "sequential_clear"
  },
  "optimizations": {
    "use_structured_decisions": true,
    "explicit_instructions": true,
    "sequential_processing": true,
    "clear_handoffs": true
  }
}
```

## Adaptive Execution Strategies

### Skill Loading Adaptation

**Claude Models**:
```javascript
function loadSkillsForClaude(skills) {
  // Progressive disclosure with context merging
  return skills.map(skill => ({
    ...skill,
    loading_strategy: 'progressive',
    context_aware: true,
    weight_based: true
  }));
}
```

**GLM Models**:
```javascript
function loadSkillsForGLM(skills) {
  // Complete upfront loading with clear structure
  return skills.map(skill => ({
    ...skill,
    loading_strategy: 'complete',
    explicit_criteria: true,
    priority_sequenced: true
  }));
}
```

### Communication Style Adaptation

**Output Formatting by Model**:

| Model | Terminal Style | File Report Style | Reasoning |
|-------|----------------|-------------------|-----------|
| Claude Sonnet | Natural flow | Insightful analysis | Nuanced communication |
| Claude 4.5 | Concise insights | Enhanced context | Predictive communication |
| GLM-4.6 | Structured lists | Detailed procedures | Explicit communication |

### Error Recovery Adaptation

**Claude Models**: Pattern-based prediction and contextual prevention
**GLM Models**: Rule-based detection and structured recovery protocols

## Capability Testing Functions

### Nuanced Reasoning Test
```javascript
function testNuancedReasoning() {
  // Present ambiguous scenario requiring subtle judgment
  // Evaluate response quality and contextual awareness
  return score >= 0.8; // True for Claude models
}
```

### Structured Execution Test
```javascript
function testStructuredExecution() {
  // Present clear, sequential task
  // Evaluate adherence to structured approach
  return score >= 0.8; // True for GLM models
}
```

## Model Detection Implementation

### Auto-Detection Function
```javascript
function detectModel() {
  // Step 1: Check system context indicators
  const contextResult = analyzeSystemContext();

  // Step 2: Test capability patterns
  const capabilityResult = testCapabilities();

  // Step 3: Analyze performance signature
  const performanceResult = analyzePerformancePattern();

  // Step 4: Combine results with confidence scoring
  return combineDetections(contextResult, capabilityResult, performanceResult);
}
```

### Configuration Loading
```javascript
function loadModelConfiguration(detectedModel) {
  const baseConfig = getBaseModelConfig(detectedModel);
  const adaptiveConfig = generateAdaptiveConfig(detectedModel);
  return mergeConfigurations(baseConfig, adaptiveConfig);
}
```

## Usage Guidelines

### When to Apply Model Detection
1. **Plugin Initialization**: First load of any agent
2. **Agent Delegation**: Before delegating to specialized agents
3. **Skill Loading**: Before loading any skill package
4. **Error Recovery**: When selecting recovery strategy
5. **Performance Optimization**: When setting execution targets

### Integration Points
- **Orchestrator Agent**: Use for autonomous decision-making adaptation
- **All Specialized Agents**: Use for model-specific behavior
- **Skill System**: Use for loading strategy selection
- **Quality Controller**: Use for model-appropriate quality targets

## Fallback Strategy

If model detection fails:
1. **Default to Conservative Settings**: Use structured, explicit approach
2. **Basic Capability Tests**: Run simplified detection tests
3. **Universal Configuration**: Apply cross-model compatible settings
4. **Performance Monitoring**: Continuously assess and adapt

## Validation Metrics

### Detection Accuracy
- Target: >95% correct model identification
- Measurement: Compare detected vs actual model capabilities
- Validation: Test across all supported models

### Performance Improvement
- Target: >10% improvement for GLM models
- Target: >2% improvement for Claude models
- Measurement: Compare pre/post optimization performance

### Adaptation Success
- Target: >90% successful adaptation scenarios
- Measurement: Monitor successful autonomous operations
- Validation: Test with diverse task types

This skill ensures the Autonomous Agent Plugin performs optimally across all supported LLM models while maintaining backward compatibility and future-proofing for new models.