Auto Trigger Configuration

Dynamic Capability Router

When to Use This Skill

Use this skill when implementing dynamic capability router patterns in your codebase.

How to Use This Skill

1. Review the patterns and examples below
2. Apply the relevant patterns to your implementation
3. Follow the best practices outlined in this skill

Intelligent routing system that analyzes use cases and dynamically selects the optimal combination of agents and skills from the full CODITECT inventory. Replaces hardcoded agent lists with capability-based discovery.

Routing Decision Tree

User Request Received
│
├─ Is agent explicitly specified?
│  └─ YES → Use specified agent directly (bypass routing)
│
├─ Extract keywords and detect intent
│  ├─ Implementation verbs (implement, create, build) → code_generation domain
│  ├─ Analysis verbs (analyze, review, understand) → code_analysis domain
│  ├─ Operations verbs (deploy, configure, monitor) → devops domain
│  └─ Security verbs (audit, secure, scan) → security domain
│
├─ Assess complexity
│  ├─ SIMPLE (1-2 keywords, <3 capabilities) → 1 agent, sequential
│  ├─ MODERATE (3-4 keywords, 3-5 capabilities) → 2-3 agents, parallel
│  └─ COMPLEX (5+ keywords, >5 capabilities) → 4-5 agents, phased
│
├─ Query capability registry
│  ├─ Score = (required_match × 0.7) + (optional_match × 0.3)
│  ├─ Filter by constraints (tech, quality_level)
│  └─ Prefer expert agents (1-2 caps) over generalists
│
└─ Return RoutingDecision
   ├─ primary_agents: Top N by score
   ├─ supporting_skills: Top 3 complementary skills
   ├─ execution_plan: sequential | parallel | phased
   └─ rationale: Human-readable explanation

Quick Reference:

Request Pattern	Detected Intent	Primary Domain	Typical Agents
"implement X"	implementation	code_generation	backend-dev, frontend-expert
"fix bug in X"	debugging	code_analysis	codebase-analyzer, debugger
"deploy to K8s"	deployment	devops	devops-engineer, k8s-specialist
"security audit"	security	security	security-auditor, pen-testing
"document API"	documentation	documentation	codi-documentation-writer
"research X"	research	research	web-search-researcher

Problem Statement

Current State (Static Routing):

# Orchestrator hardcodes 7 agents
subagents:
  - codebase-analyzer
  - codebase-locator
  - codebase-pattern-finder
  - project-organizer
  - thoughts-analyzer
  - thoughts-locator
  - web-search-researcher

Available Resources:

• 118 specialized agents
• 76 production skills
• ~200 total capabilities

Lost Opportunity: 94% of resources never considered!

Solution: Capability-Based Dynamic Routing

Architecture

┌──────────────────────────────────────────────────────────────────┐
│                     DYNAMIC CAPABILITY ROUTER                     │
├──────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌─────────────┐    ┌──────────────┐    ┌───────────────────┐   │
│  │ Use Case    │───▶│ Capability   │───▶│ Agent/Skill       │   │
│  │ Analyzer    │    │ Matcher      │    │ Selector          │   │
│  └─────────────┘    └──────────────┘    └───────────────────┘   │
│        │                   │                      │              │
│        ▼                   ▼                      ▼              │
│  ┌─────────────┐    ┌──────────────┐    ┌───────────────────┐   │
│  │ Extract     │    │ Query        │    │ Rank by:          │   │
│  │ - Keywords  │    │ Capability   │    │ - Capability fit  │   │
│  │ - Intent    │    │ Registry     │    │ - Specialization  │   │
│  │ - Domain    │    │              │    │ - Availability    │   │
│  │ - Complexity│    │              │    │ - Token cost      │   │
│  └─────────────┘    └──────────────┘    └───────────────────┘   │
│                                                                   │
└──────────────────────────────────────────────────────────────────┘

Capability Taxonomy

Level 1: Domains (12 Categories)

capability_taxonomy:
  # Development Capabilities
  code_analysis:
    description: "Understanding, analyzing, and reviewing code"
    sub_capabilities:
      - code_reading
      - pattern_detection
      - architecture_analysis
      - dependency_analysis
      - code_review
      - quality_assessment

  code_generation:
    description: "Creating new code and implementations"
    sub_capabilities:
      - backend_development
      - frontend_development
      - api_implementation
      - database_design
      - test_generation
      - refactoring

  # Operations Capabilities
  devops:
    description: "Infrastructure, deployment, and operations"
    sub_capabilities:
      - ci_cd_pipelines
      - container_orchestration
      - infrastructure_as_code
      - monitoring_setup
      - deployment_automation
      - cloud_management

  security:
    description: "Security analysis, hardening, and compliance"
    sub_capabilities:
      - vulnerability_scanning
      - security_audit
      - penetration_testing
      - secrets_detection
      - compliance_validation
      - threat_modeling

  # Research Capabilities
  research:
    description: "Information gathering and analysis"
    sub_capabilities:
      - web_research
      - market_analysis
      - competitive_intelligence
      - documentation_research
      - biographical_research
      - technical_research

  documentation:
    description: "Creating and maintaining documentation"
    sub_capabilities:
      - api_documentation
      - user_guides
      - architecture_docs
      - readme_generation
      - changelog_automation
      - knowledge_base

  # Quality Capabilities
  testing:
    description: "Test creation and quality assurance"
    sub_capabilities:
      - unit_testing
      - integration_testing
      - e2e_testing
      - performance_testing
      - security_testing
      - visual_regression

  quality_assurance:
    description: "Code quality and standards enforcement"
    sub_capabilities:
      - code_review
      - adr_compliance
      - quality_scoring
      - best_practices
      - technical_debt
      - accessibility

  # Project Capabilities
  project_management:
    description: "Planning, tracking, and organization"
    sub_capabilities:
      - task_planning
      - progress_tracking
      - resource_allocation
      - timeline_management
      - risk_assessment
      - milestone_tracking

  architecture:
    description: "System design and architectural decisions"
    sub_capabilities:
      - system_design
      - api_design
      - database_architecture
      - microservices
      - event_driven
      - distributed_systems

  # Optimization Capabilities
  optimization:
    description: "Performance and resource optimization"
    sub_capabilities:
      - performance_profiling
      - query_optimization
      - memory_management
      - token_optimization
      - cost_optimization
      - load_balancing

  # Domain-Specific Capabilities
  specialized:
    description: "Domain-specific expertise"
    sub_capabilities:
      - rust_development
      - react_development
      - kubernetes
      - foundationdb
      - graphql
      - websockets

Use Case Analyzer

from typing import List, Dict, Set, Tuple
from dataclasses import dataclass
from enum import Enum
import re


class TaskComplexity(Enum):
    SIMPLE = "simple"      # Single agent, <30 min
    MODERATE = "moderate"  # 2-3 agents, <60 min
    COMPLEX = "complex"    # 4+ agents, multi-phase


@dataclass
class UseCaseAnalysis:
    """Result of analyzing a use case"""
    raw_request: str
    detected_intent: str
    required_capabilities: List[str]
    optional_capabilities: List[str]
    domain: str
    complexity: TaskComplexity
    keywords: List[str]
    constraints: Dict[str, any]


class UseCaseAnalyzer:
    """
    Analyzes user requests to extract required capabilities.

    Uses keyword matching, intent detection, and domain classification
    to determine what capabilities are needed for the task.
    """

    # Keyword to capability mappings
    CAPABILITY_KEYWORDS = {
        # Code Analysis
        "analyze": ["code_analysis", "architecture_analysis"],
        "review": ["code_review", "quality_assessment"],
        "understand": ["code_reading", "architecture_analysis"],
        "find": ["pattern_detection", "code_reading"],
        "locate": ["code_reading", "pattern_detection"],
        "search": ["code_reading", "web_research"],

        # Code Generation
        "implement": ["code_generation", "backend_development"],
        "create": ["code_generation", "api_implementation"],
        "build": ["code_generation", "frontend_development"],
        "add": ["code_generation", "refactoring"],
        "write": ["code_generation", "test_generation"],
        "develop": ["code_generation", "backend_development"],

        # DevOps
        "deploy": ["deployment_automation", "ci_cd_pipelines"],
        "configure": ["infrastructure_as_code", "container_orchestration"],
        "monitor": ["monitoring_setup", "performance_profiling"],
        "pipeline": ["ci_cd_pipelines", "deployment_automation"],

        # Security
        "security": ["security_audit", "vulnerability_scanning"],
        "vulnerab": ["vulnerability_scanning", "security_audit"],
        "audit": ["security_audit", "compliance_validation"],
        "penetration": ["penetration_testing", "vulnerability_scanning"],
        "secrets": ["secrets_detection", "security_audit"],

        # Research
        "research": ["web_research", "documentation_research"],
        "market": ["market_analysis", "competitive_intelligence"],
        "competitor": ["competitive_intelligence", "market_analysis"],
        "investigate": ["technical_research", "documentation_research"],

        # Documentation
        "document": ["api_documentation", "readme_generation"],
        "readme": ["readme_generation", "documentation"],
        "changelog": ["changelog_automation", "documentation"],
        "guide": ["user_guides", "documentation"],

        # Testing
        "test": ["unit_testing", "test_generation"],
        "e2e": ["e2e_testing", "integration_testing"],
        "performance": ["performance_testing", "performance_profiling"],

        # Architecture
        "architecture": ["system_design", "architecture_analysis"],
        "design": ["system_design", "api_design"],
        "scale": ["distributed_systems", "performance_profiling"],
        "microservice": ["microservices", "api_design"],

        # Optimization
        "optimize": ["performance_profiling", "query_optimization"],
        "performance": ["performance_profiling", "optimization"],
        "speed": ["performance_profiling", "query_optimization"],
        "memory": ["memory_management", "optimization"],

        # Domain-specific
        "rust": ["rust_development", "backend_development"],
        "react": ["react_development", "frontend_development"],
        "kubernetes": ["kubernetes", "container_orchestration"],
        "k8s": ["kubernetes", "container_orchestration"],
        "graphql": ["graphql", "api_design"],
        "websocket": ["websockets", "api_implementation"],
    }

    # Intent patterns
    INTENT_PATTERNS = {
        r"fix|debug|resolve|error|bug": "debugging",
        r"implement|create|build|add|write": "implementation",
        r"analyze|review|understand|assess": "analysis",
        r"deploy|release|ship|launch": "deployment",
        r"test|verify|validate|check": "testing",
        r"document|explain|describe": "documentation",
        r"research|investigate|find out|learn": "research",
        r"optimize|improve|speed up|enhance": "optimization",
        r"refactor|clean|reorganize": "refactoring",
        r"secure|harden|protect|audit": "security",
        r"design|architect|plan": "design",
        r"migrate|upgrade|convert": "migration",
    }

    def analyze(self, request: str) -> UseCaseAnalysis:
        """
        Analyze a user request to extract required capabilities.

        Args:
            request: The user's task request

        Returns:
            UseCaseAnalysis with detected capabilities and metadata
        """
        request_lower = request.lower()

        # Extract keywords
        keywords = self._extract_keywords(request_lower)

        # Detect intent
        intent = self._detect_intent(request_lower)

        # Map keywords to capabilities
        required_caps, optional_caps = self._map_capabilities(keywords, intent)

        # Classify domain
        domain = self._classify_domain(required_caps)

        # Assess complexity
        complexity = self._assess_complexity(required_caps, request_lower)

        # Extract constraints
        constraints = self._extract_constraints(request_lower)

        return UseCaseAnalysis(
            raw_request=request,
            detected_intent=intent,
            required_capabilities=required_caps,
            optional_capabilities=optional_caps,
            domain=domain,
            complexity=complexity,
            keywords=keywords,
            constraints=constraints
        )

    def _extract_keywords(self, text: str) -> List[str]:
        """Extract relevant keywords from text"""
        found = []
        for keyword in self.CAPABILITY_KEYWORDS.keys():
            if keyword in text:
                found.append(keyword)
        return found

    def _detect_intent(self, text: str) -> str:
        """Detect primary intent from text"""
        for pattern, intent in self.INTENT_PATTERNS.items():
            if re.search(pattern, text):
                return intent
        return "general"

    def _map_capabilities(
        self,
        keywords: List[str],
        intent: str
    ) -> Tuple[List[str], List[str]]:
        """Map keywords to required and optional capabilities"""
        required = set()
        optional = set()

        for keyword in keywords:
            caps = self.CAPABILITY_KEYWORDS.get(keyword, [])
            if caps:
                required.add(caps[0])  # Primary capability
                optional.update(caps[1:])  # Secondary capabilities

        # Add intent-based capabilities
        intent_caps = {
            "debugging": ["code_analysis", "test_generation"],
            "implementation": ["code_generation", "test_generation"],
            "analysis": ["code_analysis", "architecture_analysis"],
            "deployment": ["deployment_automation", "ci_cd_pipelines"],
            "testing": ["test_generation", "quality_assessment"],
            "documentation": ["documentation", "api_documentation"],
            "research": ["web_research", "documentation_research"],
            "optimization": ["performance_profiling", "query_optimization"],
            "security": ["security_audit", "vulnerability_scanning"],
            "design": ["system_design", "architecture_analysis"],
        }

        if intent in intent_caps:
            required.add(intent_caps[intent][0])
            optional.update(intent_caps[intent][1:])

        return list(required), list(optional - required)

    def _classify_domain(self, capabilities: List[str]) -> str:
        """Classify the primary domain"""
        domain_weights = {
            "development": ["code_generation", "backend_development", "frontend_development"],
            "operations": ["deployment_automation", "ci_cd_pipelines", "kubernetes"],
            "security": ["security_audit", "vulnerability_scanning", "penetration_testing"],
            "research": ["web_research", "market_analysis", "competitive_intelligence"],
            "quality": ["code_review", "test_generation", "quality_assessment"],
            "architecture": ["system_design", "architecture_analysis", "api_design"],
        }

        scores = {domain: 0 for domain in domain_weights}
        for cap in capabilities:
            for domain, domain_caps in domain_weights.items():
                if cap in domain_caps:
                    scores[domain] += 1

        return max(scores, key=scores.get) if any(scores.values()) else "general"

    def _assess_complexity(self, capabilities: List[str], text: str) -> TaskComplexity:
        """Assess task complexity"""
        # Complexity indicators
        complex_keywords = ["full-stack", "multi-file", "comprehensive", "complete",
                          "entire", "all", "end-to-end", "migration", "refactor"]
        moderate_keywords = ["multiple", "several", "few", "some", "update"]

        if any(kw in text for kw in complex_keywords) or len(capabilities) >= 4:
            return TaskComplexity.COMPLEX
        elif any(kw in text for kw in moderate_keywords) or len(capabilities) >= 2:
            return TaskComplexity.MODERATE
        return TaskComplexity.SIMPLE

    def _extract_constraints(self, text: str) -> Dict[str, any]:
        """Extract constraints from request"""
        constraints = {}

        # Time constraints
        if "quick" in text or "fast" in text:
            constraints["time_priority"] = "fast"
        elif "thorough" in text or "comprehensive" in text:
            constraints["time_priority"] = "thorough"

        # Quality constraints
        if "production" in text or "prod" in text:
            constraints["quality_level"] = "production"

        # Technology constraints
        tech_patterns = {
            r"rust|cargo": "rust",
            r"react|typescript|ts": "typescript",
            r"python|py": "python",
            r"kubernetes|k8s": "kubernetes",
        }
        for pattern, tech in tech_patterns.items():
            if re.search(pattern, text):
                constraints.setdefault("technologies", []).append(tech)

        return constraints

Agent/Skill Matcher

from typing import List, Dict, Optional
from dataclasses import dataclass


@dataclass
class ComponentMatch:
    """A matched component with relevance score"""
    component_type: str  # "agent" or "skill"
    component_id: str
    name: str
    relevance_score: float  # 0.0 - 1.0
    matched_capabilities: List[str]
    specialization_level: str  # "general", "specialized", "expert"


class CapabilityMatcher:
    """
    Matches required capabilities to available agents and skills.

    Uses the capability registry to find the best resources for a task.
    """

    def __init__(self, registry_path: str = "config/capability-registry.json"):
        self.registry = self._load_registry(registry_path)

    def _load_registry(self, path: str) -> Dict:
        """Load capability registry"""
        import json
        try:
            with open(path) as f:
                return json.load(f)
        except FileNotFoundError:
            return {"agents": {}, "skills": {}}

    def find_matches(
        self,
        required_capabilities: List[str],
        optional_capabilities: List[str] = None,
        constraints: Dict = None,
        limit: int = 10
    ) -> List[ComponentMatch]:
        """
        Find components matching required capabilities.

        Args:
            required_capabilities: Must-have capabilities
            optional_capabilities: Nice-to-have capabilities
            constraints: Filtering constraints (tech, quality, etc.)
            limit: Maximum number of matches to return

        Returns:
            List of ComponentMatch sorted by relevance
        """
        optional_capabilities = optional_capabilities or []
        constraints = constraints or {}

        matches = []

        # Score all agents
        for agent_id, agent_data in self.registry.get("agents", {}).items():
            score = self._score_component(
                agent_data.get("capabilities", []),
                required_capabilities,
                optional_capabilities
            )

            if score > 0:
                # Apply constraints
                if self._passes_constraints(agent_data, constraints):
                    matches.append(ComponentMatch(
                        component_type="agent",
                        component_id=agent_id,
                        name=agent_data.get("name", agent_id),
                        relevance_score=score,
                        matched_capabilities=self._get_matched_caps(
                            agent_data.get("capabilities", []),
                            required_capabilities + optional_capabilities
                        ),
                        specialization_level=self._get_specialization(agent_data)
                    ))

        # Score all skills
        for skill_id, skill_data in self.registry.get("skills", {}).items():
            score = self._score_component(
                skill_data.get("capabilities", []),
                required_capabilities,
                optional_capabilities
            )

            if score > 0:
                if self._passes_constraints(skill_data, constraints):
                    matches.append(ComponentMatch(
                        component_type="skill",
                        component_id=skill_id,
                        name=skill_data.get("name", skill_id),
                        relevance_score=score,
                        matched_capabilities=self._get_matched_caps(
                            skill_data.get("capabilities", []),
                            required_capabilities + optional_capabilities
                        ),
                        specialization_level=self._get_specialization(skill_data)
                    ))

        # Sort by relevance and return top matches
        matches.sort(key=lambda m: m.relevance_score, reverse=True)
        return matches[:limit]

    def _score_component(
        self,
        component_caps: List[str],
        required: List[str],
        optional: List[str]
    ) -> float:
        """Score a component based on capability match"""
        if not component_caps:
            return 0.0

        component_caps_set = set(component_caps)
        required_set = set(required)
        optional_set = set(optional)

        # Must have at least one required capability
        required_matches = len(component_caps_set & required_set)
        if required_matches == 0 and required:
            return 0.0

        # Score: weighted sum of required (0.7) and optional (0.3) matches
        required_score = required_matches / len(required) if required else 1.0
        optional_matches = len(component_caps_set & optional_set)
        optional_score = optional_matches / len(optional) if optional else 0.0

        return (required_score * 0.7) + (optional_score * 0.3)

    def _passes_constraints(self, component_data: Dict, constraints: Dict) -> bool:
        """Check if component passes constraints"""
        if not constraints:
            return True

        # Technology constraints
        if "technologies" in constraints:
            component_tags = component_data.get("tags", [])
            if not any(tech in component_tags for tech in constraints["technologies"]):
                # Soft constraint - don't exclude, but could lower score
                pass

        # Quality level constraints
        if constraints.get("quality_level") == "production":
            if component_data.get("status") not in ["production", "stable"]:
                return False

        return True

    def _get_matched_caps(self, component_caps: List[str], all_caps: List[str]) -> List[str]:
        """Get list of matched capabilities"""
        return list(set(component_caps) & set(all_caps))

    def _get_specialization(self, component_data: Dict) -> str:
        """Determine specialization level"""
        caps = component_data.get("capabilities", [])
        if len(caps) <= 2:
            return "expert"  # Highly specialized
        elif len(caps) <= 5:
            return "specialized"
        return "general"

Dynamic Router

from typing import List, Dict, Tuple
from dataclasses import dataclass


@dataclass
class RoutingDecision:
    """Final routing decision"""
    primary_agents: List[ComponentMatch]
    supporting_skills: List[ComponentMatch]
    execution_plan: str  # "sequential", "parallel", "phased"
    estimated_complexity: TaskComplexity
    rationale: str


class DynamicCapabilityRouter:
    """
    Main router that combines use case analysis with capability matching.

    Usage:
        router = DynamicCapabilityRouter()
        decision = router.route("Implement user authentication with JWT")

        # Use the routing decision
        for agent in decision.primary_agents:
            Task(subagent_type=agent.component_id, prompt="...")
    """

    def __init__(self):
        self.analyzer = UseCaseAnalyzer()
        self.matcher = CapabilityMatcher()

    def route(self, request: str) -> RoutingDecision:
        """
        Route a request to optimal agents and skills.

        Args:
            request: User's task request

        Returns:
            RoutingDecision with selected components and execution plan
        """
        # Step 1: Analyze use case
        analysis = self.analyzer.analyze(request)

        # Step 2: Find matching components
        all_matches = self.matcher.find_matches(
            required_capabilities=analysis.required_capabilities,
            optional_capabilities=analysis.optional_capabilities,
            constraints=analysis.constraints,
            limit=15
        )

        # Step 3: Separate agents and skills
        agents = [m for m in all_matches if m.component_type == "agent"]
        skills = [m for m in all_matches if m.component_type == "skill"]

        # Step 4: Select primary agents based on complexity
        if analysis.complexity == TaskComplexity.SIMPLE:
            primary_agents = agents[:1]  # Single best agent
        elif analysis.complexity == TaskComplexity.MODERATE:
            primary_agents = agents[:3]  # Top 3 agents
        else:
            primary_agents = agents[:5]  # Top 5 for complex tasks

        # Step 5: Select supporting skills
        supporting_skills = skills[:3]  # Top 3 skills

        # Step 6: Determine execution plan
        execution_plan = self._determine_execution_plan(analysis, primary_agents)

        # Step 7: Generate rationale
        rationale = self._generate_rationale(analysis, primary_agents, supporting_skills)

        return RoutingDecision(
            primary_agents=primary_agents,
            supporting_skills=supporting_skills,
            execution_plan=execution_plan,
            estimated_complexity=analysis.complexity,
            rationale=rationale
        )

    def _determine_execution_plan(
        self,
        analysis: UseCaseAnalysis,
        agents: List[ComponentMatch]
    ) -> str:
        """Determine optimal execution plan"""
        if analysis.complexity == TaskComplexity.SIMPLE:
            return "sequential"

        # Check for dependencies between agents
        # If no dependencies, can run in parallel
        if len(agents) <= 2:
            return "parallel"

        # Complex tasks with many agents need phased execution
        return "phased"

    def _generate_rationale(
        self,
        analysis: UseCaseAnalysis,
        agents: List[ComponentMatch],
        skills: List[ComponentMatch]
    ) -> str:
        """Generate human-readable rationale for routing decision"""
        agent_names = [a.name for a in agents]
        skill_names = [s.name for s in skills]

        return f"""
Routing Analysis:
- Intent: {analysis.detected_intent}
- Domain: {analysis.domain}
- Complexity: {analysis.complexity.value}
- Required capabilities: {', '.join(analysis.required_capabilities)}

Selected Agents ({len(agents)}):
{chr(10).join(f'  - {a.name} (score: {a.relevance_score:.2f}, matched: {a.matched_capabilities})' for a in agents)}

Supporting Skills ({len(skills)}):
{chr(10).join(f'  - {s.name} (score: {s.relevance_score:.2f})' for s in skills)}
"""

Orchestrator Integration

The router replaces hardcoded agent lists in orchestrators:

# OLD: Hardcoded in orchestrator.md
subagents = ["codebase-analyzer", "codebase-locator", "thoughts-analyzer"]

# NEW: Dynamic routing
router = DynamicCapabilityRouter()
decision = router.route(user_request)

for agent in decision.primary_agents:
    Task(
        subagent_type=agent.component_id,
        prompt=f"Use {agent.component_id} subagent to {task_description}"
    )

Capability Registry Population

To make this work, we need to populate capabilities for all components:

# Run the capability population script
python3 scripts/populate-capability-registry.py

# Output: config/capability-registry.json

Success Metrics

Metric	Target
Resource utilization	100% (all agents/skills discoverable)
Routing accuracy	>90% (correct agent selection)
False negatives	<5% (capable agents missed)
Routing latency	<100ms
Orchestration token savings	40%

Integration with Auto-Trigger Framework

The dynamic router integrates with auto-triggers:

# In orchestrator.md
auto_trigger_integration:
  pre_execution:
    - dynamic-capability-router  # Analyzes and routes before execution

  capability_routing:
    enabled: true
    fallback: "general-purpose"  # Default if no match

Usage Examples

Example 1: Security Audit Request

router = DynamicCapabilityRouter()
decision = router.route("Run comprehensive security audit on authentication")

# Result:
# primary_agents: [security-auditor, penetration-testing-agent, security-scanning]
# supporting_skills: [security-audit, secrets-detection, dependency-security]
# execution_plan: "phased"

Example 2: Simple Code Analysis

decision = router.route("Find where error handling is implemented")

# Result:
# primary_agents: [codebase-pattern-finder]
# supporting_skills: [search-strategies]
# execution_plan: "sequential"

Example 3: Full-Stack Feature

decision = router.route("Implement user profile with avatar upload, React frontend and Rust backend")

# Result:
# primary_agents: [backend-development, frontend-react-typescript-expert, cloud-architect]
# supporting_skills: [rust-backend-patterns, restful-api-design, test-automation]
# execution_plan: "phased"

---

Success Output

When successful, this skill MUST output:

✅ SKILL COMPLETE: dynamic-capability-router

Completed:
- [x] UseCaseAnalyzer implemented with 12 domain categories
- [x] Capability taxonomy defined (60+ capabilities)
- [x] CapabilityMatcher scoring algorithm operational
- [x] DynamicCapabilityRouter integrates analysis + matching
- [x] Capability registry populated with 118 agents + 76 skills
- [x] Routing decisions include rationale and execution plan

Outputs:
- src/router/use_case_analyzer.py (Intent detection + capability mapping)
- src/router/capability_matcher.py (Component scoring and ranking)
- src/router/dynamic_router.py (Full routing orchestration)
- config/capability-registry.json (Agent and skill capability mappings)
- config/capability-taxonomy.yaml (12 domain categories with sub-capabilities)
- scripts/populate-capability-registry.py (Registry generation script)

Routing Metrics:
- Resource utilization: 100% (all 194 components discoverable)
- Routing accuracy: 94% (correct agent selection validated)
- False negatives: 2% (capable agents missed, below 5% target)
- Routing latency: 68ms (under 100ms target)
- Token savings: 42% (vs hardcoded orchestrator lists)

Completion Checklist

Before marking this skill as complete, verify:

• UseCaseAnalyzer extracts keywords from user request
• Intent detection classifies request (debugging, implementation, analysis, etc.)
• Capability mapping converts keywords to required/optional capabilities
• Domain classification determines primary domain (development, operations, security, etc.)
• Complexity assessment (simple, moderate, complex) based on keywords and capability count
• CapabilityMatcher loads registry from JSON file
• Scoring algorithm calculates weighted match (70% required, 30% optional)
• Constraint filtering applies (technology, quality_level, etc.)
• Specialization level determined (expert, specialized, general)
• DynamicCapabilityRouter separates agents from skills
• Primary agent selection scales with complexity (1 for simple, 3 for moderate, 5 for complex)
• Execution plan chosen (sequential, parallel, phased)
• Rationale generated with matched capabilities and scores
• Capability registry contains all 118 agents and 76 skills with capability tags
• All outputs exist at expected locations and pass validation

Failure Indicators

This skill has FAILED if:

• ❌ UseCaseAnalyzer returns empty required_capabilities for valid requests
• ❌ Intent detection always returns "general" (not classifying correctly)
• ❌ Capability mapping misses obvious keywords (e.g., "security" not mapping to security_audit)
• ❌ Domain classification incorrect for clear requests
• ❌ Complexity always assessed as "simple" or "complex" (no moderate)
• ❌ CapabilityMatcher returns no matches when capable components exist
• ❌ Scoring algorithm returns 0.0 for components with matching capabilities
• ❌ Constraint filtering excludes all candidates
• ❌ Router selects agents without matching required capabilities
• ❌ Execution plan always "sequential" regardless of complexity
• ❌ Rationale missing or generic ("selected best agents")
• ❌ Capability registry incomplete (<90% of components)

When NOT to Use

Do NOT use this skill when:

• Using hardcoded agent list is sufficient (single-purpose orchestrator)
• Capability discovery overhead not justified (fewer than 10 agents total)
• All agents already known and manually selected for task
• Deterministic agent selection required (testing, validation)
• Capability registry not maintained (stale component data)
• User explicitly specifies which agents to use
• Prototyping or proof-of-concept (use simple hardcoded lists)

Alternative approaches:

• Hardcoded lists: Define subagents directly in orchestrator.md
• Manual selection: User specifies agents via CLI or config
• Simple routing: Use basic keyword matching without full taxonomy
• External routing: Use LLM to select agents dynamically (no local registry)

Anti-Patterns (Avoid)

Anti-Pattern	Problem	Solution
Hardcoding agent lists in orchestrators	Only 6% of resources used (7 of 118 agents)	Use dynamic capability router to discover all agents
Empty capability tags in registry	Agents not discoverable by capability	Populate all agents with relevant capability keywords
Vague capability names	Low precision matching	Use specific, granular capabilities (e.g., "react_development" not "frontend")
No intent detection	Miss context clues in request	Detect intent from verbs (implement, analyze, test, etc.)
Equal weighting for all capabilities	Misrepresents importance	Weight required capabilities higher (70%) than optional (30%)
Ignoring constraints	Select incompatible agents	Apply technology, quality, and tier constraints
No specialization preference	Over-general agents selected	Prefer expert agents (1-2 capabilities) over generalists
Static execution plan	Inefficient for complex tasks	Choose plan based on complexity (sequential, parallel, phased)
Missing rationale	No explanation for routing decision	Generate rationale with matched capabilities and scores
Stale capability registry	Routing based on outdated data	Regenerate registry when agents/skills change

Principles

This skill embodies:

• #1 Discovery Over Hardcoding - Capability-based routing discovers all 194 resources dynamically
• #2 Evidence-Based Selection - Scoring algorithm selects agents based on objective capability match
• #5 Eliminate Ambiguity - Clear intent detection and domain classification remove guesswork
• #6 Clear, Understandable, Explainable - Rationale explains why each agent selected
• #7 Optimize for Context - Execution plan adapts to task complexity
• #8 No Assumptions - Verify agent capabilities via registry; don't assume based on name
• #9 Maximize Resource Utilization - 100% of agents discoverable (vs 6% with hardcoded lists)
• #10 Automation First - Registry generation and routing fully automated
• #11 Adaptability - Routing logic adapts to new agents/skills automatically

Full Standard: CODITECT-STANDARD-AUTOMATION.md

---