model-detection

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:

   // 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:

   // 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:

   // 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

{
  "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

{
  "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

{
  "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

{
  "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:

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

GLM Models:

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

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

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

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

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.