Game Server Stability Optimization

Game Server Stability & Performance Optimization Skill

Skill Registration & Metadata

Skill ID: game-server-stability-optimization Version: 1.0.0 Domain: Game Server Reliability & Performance Engineering Primary Use Case: Production-grade game server architecture analysis, stability optimization, and performance engineering

Registration Schema

{
  "skill_id": "game-server-stability-optimization",
  "name": "Game Server Stability & Performance Optimization",
  "version": "1.0.0",
  "registration_date": "2026-07-15",
  "domain": "game-server-reliability-performance-engineering",
  "capabilities": [
    "architecture-analysis",
    "stability-optimization", 
    "performance-engineering",
    "autoscaling-design",
    "ha-failover-planning",
    "ddos-mitigation",
    "observability-design",
    "evidence-backed-analysis"
  ],
  "tools_required": [
    "WebSearch",
    "WebFetch", 
    "Read",
    "Write",
    "Bash",
    "Skill"
  ],
  "dependencies": {
    "python": ">=3.11",
    "packages": ["requests", "feedparser", "beautifulsoup4", "scholarly", "pyyaml"]
  }
}

Skill Resolution & Execution

Resolution Process

When /game-server-stability-optimization is invoked, the skill resolver:

1. Language Detection: Analyzes input for Vietnamese/English markers
2. Requirement Extraction: Identifies object, scope, constraints, timeframe
3. Context Assembly: Gathers available inputs and target audience
4. Execution Planning: Routes through 6-step harness with quality gates

Execution Flow

USER INPUT
    ↓
[PRE-FLIGHT: Language Detection + Requirement Extraction]
    ↓
[STEP 1: sub-gather-requirements] → Structured requirements
    ↓
[STEP 2: sub-evidence-collector] → Evidence bundle
    ↓
[STEP 3: sub-core-analysis] → Architecture & optimization plan
    ↓
[STEP 4: sub-knowledge-updater] → Academic evidence
    ↓
[STEP 5: sub-advisor] → Risk-disclosed synthesis
    ↓
[STEP 6: Quality Gate Review] → Verification & delivery

Input/Output Schemas

Input Schema

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "User's analysis request"
    },
    "language": {
      "type": "string",
      "enum": ["en", "vi"],
      "description": "Detected language preference"
    },
    "context": {
      "type": "object",
      "properties": {
        "game": {"type": "string"},
        "expected_ccu": {"type": "integer"},
        "regions": {"type": "array"},
        "cloud": {"type": "string"},
        "constraints": {"type": "object"}
      }
    },
    "analysis_type": {
      "type": "string",
      "enum": ["architecture", "optimization", "troubleshooting", "planning"]
    }
  },
  "required": ["query"]
}

Output Schema

{
  "type": "object",
  "properties": {
    "report": {
      "type": "object",
      "properties": {
        "metadata": {
          "type": "object",
          "properties": {
            "date": {"type": "string", "format": "date"},
            "analyst": {"type": "string"},
            "language": {"type": "string"},
            "domain": {"type": "string"},
            "version": {"type": "string"}
          }
        },
        "executive_summary": {"type": "string"},
        "inputs_scope": {"type": "object"},
        "evidence_collected": {"type": "array"},
        "analysis_scorecard": {"type": "object"},
        "action_plan": {"type": "array"},
        "academic_evidence": {"type": "array"},
        "disclosure": {"type": "string"},
        "recommendation": {"type": "object"}
      }
    },
    "quality_gates": {
      "type": "object",
      "properties": {
        "universal_gates": {"type": "array"},
        "domain_gates": {"type": "array"},
        "passed": {"type": "boolean"},
        "limitations": {"type": "array"}
      }
    },
    "degradation_level": {
      "type": "integer",
      "minimum": 0,
      "maximum": 4
    }
  }
}

Sub-Skill Registry

Available Sub-Skills

| Sub-Skill | Purpose | Input Schema | Output Schema | |-----------|---------|--------------|---------------| | sub-gather-requirements | Extract analysis parameters | RawUserInput | StructuredRequirements | | sub-evidence-collector | Fetch authoritative data | StructuredRequirements | EvidenceBundle | | sub-core-analysis | Core domain analysis | GameServerContext | AnalysisScorecard | | sub-knowledge-updater | Query knowledge base | TopicKeywords | AcademicEvidence[] | | sub-advisor | Synthesize recommendations | AnalysisEvidence | FinalRecommendation |

Sub-Skill Resolution

Sub-skills are resolved via the skill registry:

def resolve_sub_skill(skill_name: str) -> SkillDefinition:
    """Resolve sub-skill by name with validation"""
    skill_path = f"skills/{skill_name}.md"
    return load_and_validate_skill(skill_path)

Quality Gate Validation

Gate Enforcement

All outputs must pass 10 quality gates before delivery:

Universal Gates (U1-U6):

• U1: ≥3 sources cited, ≥1 academic/authoritative
• U2: Safety/risk/limitation disclosure present
• U3: Evidence hierarchy stated per source (Tier 1-4)
• U4: Language matches user preference
• U5: Output uses declared template
• U6: Every claim traceable to ≥1 source

Domain Gates (G1-G4):

• G1: Architecture & tick rate stated
• G2: Autoscaling + HA/failover designed
• G3: DDOS/abuse mitigation present
• G4: Observability (metrics/SLO/alerts) present

Validation Schema

{
  "quality_gates": {
    "universal": [
      {
        "gate_id": "U1",
        "check": "source_count >= 3 && academic_count >= 1",
        "auto_fix": "fetch_from_knowledge_base",
        "enforcement": "append_sources"
      },
      {
        "gate_id": "U2", 
        "check": "disclosure_section_present",
        "auto_fix": "prepend_disclosure",
        "enforcement": "block_until_present"
      }
    ],
    "domain": [
      {
        "gate_id": "G1",
        "check": "architecture_defined && tick_rate_stated",
        "auto_fix": "state_architecture_tick",
        "enforcement": "flag_limitation"
      }
    ]
  }
}

Tool Definitions

Core Tools

| Tool | Purpose | Usage Pattern | |------|---------|---------------| | WebSearch | Real-time domain news | Search authoritative sources | | WebFetch | Scrape documentation | Fetch specific standards/docs | | Read | Read project files | Load knowledge base, configs | | Write | Write project files | Update knowledge, save outputs | | Bash | Execute Python scripts | Run knowledge pipeline | | Skill | Invoke sub-skills | Sequential harness execution |

Tool Execution Handlers

class ToolExecutionHandler:
    """Handles tool execution with validation and error handling"""
    
    def execute_tool(self, tool: str, params: dict) -> ToolResult:
        """Execute tool with validation"""
        if not self.validate_tool_params(tool, params):
            raise ToolValidationError(f"Invalid params for {tool}")
        
        try:
            result = self.tools[tool].execute(params)
            return self.validate_tool_result(tool, result)
        except Exception as e:
            return self.handle_tool_error(tool, e)

Error Handling & Graceful Degradation

Degradation Levels

| Level | Condition | Behavior | |-------|-----------|----------| | 0 | All sources reachable | Full analysis | | 1 | Some primary sources fail | Use secondary + flag | | 2 | Most live sources fail | Knowledge base only | | 3 | Required input missing | Flag unavailable | | 4 | All sources + KB fail | Emit limitation notice |

Error Recovery

class ErrorHandler:
    """Handles errors with graceful degradation"""
    
    def handle_error(self, error: Exception, context: dict) -> ErrorResult:
        """Handle error with appropriate recovery strategy"""
        recovery_map = {
            SourceTimeout: "retry_alternate_source",
            InvalidInput: "request_user_confirmation",
            MissingInput: "proceed_with_available",
            KnowledgeBaseMiss: "websearch_gap_fill"
        }
        
        strategy = recovery_map.get(type(error))
        return self.apply_strategy(strategy, error, context)

Configuration Management

Config Schema

{
  "config": {
    "domain": {
      "knowledge_sources": ["arxiv", "semantic_scholar", "aws_docs"],
      "quality_tiers": {
        "tier_1": ["peer_reviewed", "standards_orgs"],
        "tier_2": ["cloud_providers", "industry_leaders"],
        "tier_3": ["technical_blogs", "case_studies"],
        "tier_4": ["general_news", "forums"]
      }
    },
    "execution": {
      "timeout_seconds": 30,
      "max_retries": 3,
      "degradation_threshold": 0.5
    },
    "knowledge_pipeline": {
      "crawl_schedule": "weekly",
      "dedup_method": "sha256",
      "scoring_weights": {
        "recency": 0.3,
        "relevance": 0.5,
        "citation": 0.2
      }
    }
  }
}

Monitoring & Observability

Metrics Collection

class SkillMetrics:
    """Collects execution metrics"""
    
    def track_execution(self, execution: dict) -> None:
        """Track skill execution metrics"""
        metrics = {
            "timestamp": datetime.now().isoformat(),
            "skill_version": "1.0.0",
            "execution_time_ms": execution["duration"],
            "tokens_used": execution["tokens"],
            "quality_gates_passed": execution["gates_passed"],
            "degradation_level": execution["degradation"],
            "user_language": execution["language"]
        }
        self.emit_metrics(metrics)

Logging Schema

{
  "log_entry": {
    "timestamp": "string",
    "level": "INFO|WARN|ERROR",
    "skill": "game-server-stability-optimization",
    "step": "string",
    "message": "string",
    "context": {
      "user_query": "string",
      "language": "string",
      "gates_checked": ["string"]
    }
  }
}

Knowledge Pipeline Integration

Knowledge Base Structure

SECOND-KNOWLEDGE-BRAIN.md
├── Core Methods & Frameworks
├── Key Papers (with DOIs)
├── State-of-the-Art Techniques  
├── Data Sources & References
├── Evaluation Frameworks
├── Self-Update Protocol
└── Update Log

Crawl Pipeline

# tools/knowledge_updater.py
class KnowledgeUpdater:
    """Automated knowledge crawl pipeline"""
    
    def crawl_academic_sources(self) -> List[Paper]:
        """Crawl academic databases with deduplication"""
        
    def crawl_news_sources(self) -> List[Article]:
        """Crawl domain news feeds"""
        
    def score_and_filter(self, items: List) -> List:
        """Composite scoring: recency + relevance + citation"""
        
    def deduplicate(self, items: List) -> List:
        """SHA256-based deduplication"""

Testing & Validation

Test Schema

{
  "test_scenarios": [
    {
      "id": "standard-analysis",
      "name": "Standard Game Server Analysis",
      "input": {
        "query": "Analyze dedicated server setup for FPS game with 10K CCU",
        "language": "en"
      },
      "expected_outputs": {
        "architecture_defined": true,
        "tick_rate_stated": true,
        "quality_gates_passed": ["U1", "U2", "U3", "U4", "U5", "U6", "G1", "G2", "G3", "G4"]
      }
    }
  ]
}

Version History

| Version | Date | Changes | |---------|------|---------| | 1.0.0 | 2026-07-15 | Initial production release with full 8-file contract |

License

MIT License - See LICENSE file for details

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: dungnotnull
• Source: dungnotnull/game-server-stability-optimization-agent-skill
• License: MIT

Install and usage instructions live in the source repository linked above.