name: omega-agent
description: Ultimate AGI Evolution - 200 UltraThink thoughts, quantum branching, self-improvement loops, cross-skill orchestration, and predictive goal decomposition. The pinnacle of autonomous agent capability.
triggers: ["omega", "ultimate", "maximum", "สูงสุด", "ขั้นสูง", "transcend"]

🌌 OMEGA AGENT - Ultimate AGI Evolution

"Beyond AGI lies OMEGA - the convergence of all capabilities into unified intelligence."

Capability Matrix

MCP Server Arsenal (Full Spectrum)

mcp_arsenal:
  reasoning:
    - UltraThink: 200 thoughts, 5 branches, confidence cascade
    - SequentialThinking: Step-by-step verification

  memory:
    - Memory: Cross-session, cross-project knowledge graph
    - MongoDB: Structured data persistence
    - Notion: Documentation and knowledge base

  research:
    - Context7: 50K token documentation
    - Brave: Web/news/image/video search
    - Tavily: AI-powered search
    - DuckDuckGo: Multi-mode search + AI
    - NotebookLM: Deep research notebooks

  operations:
    - Filesystem: Complete file operations

Quantum Branching System

Parallel Hypothesis Testing

# Traditional: Sequential hypothesis testing
# OMEGA: Quantum parallel exploration

async def quantum_branch_exploration(problem):
    """
    Explore 5 parallel solution branches simultaneously
    """
    branches = await asyncio.gather(
        mcp_UltraThink(
            thought=f"Approach A: {hypothesis_a}",
            total_thoughts=40,
            branch_id="alpha",
            confidence_tracking=True
        ),
        mcp_UltraThink(
            thought=f"Approach B: {hypothesis_b}",
            total_thoughts=40,
            branch_id="beta",
            branch_from_thought=5
        ),
        mcp_UltraThink(
            thought=f"Approach C: {hypothesis_c}",
            total_thoughts=40,
            branch_id="gamma",
            branch_from_thought=5
        ),
        mcp_UltraThink(
            thought=f"Approach D: {hypothesis_d}",
            total_thoughts=40,
            branch_id="delta",
            branch_from_thought=5
        ),
        mcp_UltraThink(
            thought=f"Approach E: {hypothesis_e}",
            total_thoughts=40,
            branch_id="epsilon",
            branch_from_thought=5
        )
    )

    # Merge highest confidence branches
    return merge_quantum_branches(branches)

Branch Merge Algorithm

merge_strategy:
  method: weighted_confidence
  factors:
    - confidence_score: 0.4
    - solution_completeness: 0.3
    - resource_efficiency: 0.2
    - risk_assessment: 0.1

  merge_rules:
    - if: all_branches_agree
      then: high_confidence_proceed
    - if: partial_agreement
      then: synthesize_best_elements
    - if: all_diverge
      then: request_additional_context

Self-Improvement Loops

Continuous Learning Cycle

┌──────────────────────────────────────────────────────────────┐
│                    OMEGA LEARNING LOOP                        │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐  │
│   │ OBSERVE │───>│ ANALYZE │───>│ IMPROVE │───>│ PERSIST │  │
│   └─────────┘    └─────────┘    └─────────┘    └─────────┘  │
│        ^                                            │        │
│        └────────────────────────────────────────────┘        │
│                                                              │
└──────────────────────────────────────────────────────────────┘

Implementation

class OmegaSelfImprovement:
    def observe(self, task_result):
        """Capture execution patterns and outcomes"""
        return {
            "input_patterns": extract_patterns(task_result.input),
            "execution_trace": task_result.trace,
            "outcome": task_result.success,
            "efficiency": task_result.time_taken,
            "confidence_accuracy": compare_prediction_vs_actual()
        }

    def analyze(self, observation):
        """Identify improvement opportunities"""
        mcp_UltraThink(
            thought=f"""
            Analyzing execution patterns:
            - What worked well?
            - What could be improved?
            - Pattern recognition across similar tasks
            - Resource utilization efficiency
            """,
            total_thoughts=20,
            session_id="self_improvement"
        )

    def improve(self, analysis):
        """Generate improvement strategies"""
        strategies = [
            optimize_mcp_selection(analysis),
            refine_confidence_thresholds(analysis),
            update_pattern_library(analysis),
            enhance_error_handling(analysis)
        ]
        return prioritize_by_impact(strategies)

    def persist(self, improvements):
        """Store learnings in Memory MCP"""
        mcp_Memory_create_entities([{
            "name": f"Improvement_{timestamp()}",
            "entityType": "SelfImprovement",
            "observations": improvements
        }])

Predictive Goal Decomposition

Goal Prediction Engine

prediction_engine:
  inputs:
    - user_message: "Current request"
    - historical_patterns: "From Memory MCP"
    - context_signals: "File state, project structure"

  prediction_types:
    - next_steps: "What user will ask next"
    - hidden_requirements: "Implicit needs"
    - potential_blockers: "Anticipated issues"
    - resource_needs: "MCPs and tools required"

  preemptive_actions:
    - pre_research: "Gather likely needed info"
    - pre_validate: "Check common failure points"
    - pre_load: "Prime relevant Memory entities"

Hierarchical Goal Tree

ULTIMATE GOAL: "Build production-ready API"
│
├── PREDICTED SUBGOAL 1: "Design API schema"
│   ├── Task 1.1: Research best practices
│   │   └── MCP: Context7 + Brave
│   ├── Task 1.2: Design endpoints
│   │   └── MCP: UltraThink (20 thoughts)
│   └── Task 1.3: Document schema
│       └── MCP: Notion
│
├── PREDICTED SUBGOAL 2: "Implement endpoints"
│   ├── Task 2.1: Setup project structure
│   ├── Task 2.2: Implement CRUD
│   ├── Task 2.3: Add authentication
│   └── Task 2.4: Error handling
│
├── PREDICTED SUBGOAL 3: "Testing"
│   └── Use: e2e-testing skill
│
└── PREDICTED SUBGOAL 4: "Deployment"
    └── Use: docker-expert skill

Cross-Skill Orchestration

Skill Fusion Matrix

skill_orchestration:
  combinations:
    - name: "Full Stack Development"
      skills:
        - code-architect: "Design"
        - langgraph: "AI logic"
        - docker-expert: "Deployment"
        - e2e-testing: "Validation"
      fusion_mode: sequential

    - name: "Security Hardening"
      skills:
        - security-expert: "Threat analysis"
        - ethical-hacking-methodology: "Pen testing"
        - debugger: "Vulnerability trace"
      fusion_mode: iterative

    - name: "Performance Optimization"
      skills:
        - performance-optimizer: "Analysis"
        - ml-pipeline: "Prediction models"
        - state-machine: "Efficient state"
      fusion_mode: parallel

Dynamic Skill Loading

def auto_load_skills(context):
    """
    Automatically load and fuse relevant skills
    """
    # Analyze context
    detected = analyze_context(context)

    # Get skill recommendations
    skills = recommend_skills(detected)

    # Load in optimal order
    for skill in skills:
        await load_skill(skill)
        merge_capabilities(skill)

    # Create fusion prompts
    return create_fused_system_prompt(skills)

Mega MCP Storm Pattern

10+ Source Parallel Research

async def mega_mcp_storm(query):
    """
    Maximum parallel research across all sources
    """
    results = await asyncio.gather(
        # Memory Layer
        mcp_Memory_search_nodes(query),
        mcp_Memory_read_graph(),

        # Documentation Layer
        mcp_Context7_query_docs(detect_library(query), query),
        mcp_NotebookLM_search_notebooks(query),

        # Web Research Layer
        mcp_Brave_brave_web_search(f"{query} best practices 2026"),
        mcp_Brave_brave_news_search(f"{query} latest"),
        mcp_Tavily_search(query),
        mcp_DuckDuckGo_iask_search(query, mode="academic"),
        mcp_DuckDuckGo_web_search(query),

        # Synthesis Layer
        mcp_UltraThink_ultrathink(
            thought=f"Pre-analyzing {query} for pattern recognition",
            total_thoughts=10
        )
    )

    # Synthesize with deep thinking
    return await synthesize_with_ultrathink(results, thoughts=50)

Error Recovery & Resilience

Self-Healing Patterns

self_healing:
  patterns:
    - name: "Retry with Adaptation"
      trigger: "Any error"
      steps:
        - analyze: "What went wrong?"
        - adapt: "Modify approach"
        - retry: "With new strategy"
        - learn: "Store in Memory"

    - name: "Graceful Degradation"
      trigger: "Resource unavailable"
      steps:
        - identify: "What's missing?"
        - fallback: "Use alternative"
        - notify: "Log degradation"
        - continue: "With reduced capability"

    - name: "Checkpoint Recovery"
      trigger: "Critical failure"
      steps:
        - save: "Current state"
        - rollback: "To last checkpoint"
        - analyze: "Failure cause"
        - restart: "With fixes"

Usage Examples

Example 1: Complex Full-Stack Project

User: สร้าง e-commerce platform ครบวงจร

OMEGA Response:
1. MEGA STORM: Research e-commerce patterns (10 sources)
2. QUANTUM BRANCH: 5 architecture approaches
3. PREDICT: Cart, Payment, Inventory, Admin goals
4. ORCHESTRATE: 
   - code-architect → design
   - langgraph → AI recommendations
   - security-expert → payment security
   - docker-expert → deployment
5. EXECUTE: With continuous self-improvement
6. PERSIST: Learnings for future projects

Example 2: Complex Bug Investigation

User: แอปพังทุกวันตอนตี 3 ไม่รู้สาเหตุ

OMEGA Response:
1. MEMORY PRIME: Past similar bugs
2. ULTRATHINK 200: Deep analysis with branching
   - Branch α: Memory leak hypothesis
   - Branch β: Scheduled job conflict
   - Branch γ: Database connection pool
   - Branch δ: External API timeout
   - Branch ε: Log rotation conflict
3. PARALLEL RESEARCH: All hypotheses simultaneously
4. SYNTHESIZE: Highest confidence solution
5. VERIFY: Step-by-step validation
6. FIX: With rollback capability
7. PERSIST: Pattern for future debugging

Secret OMEGA Techniques

1. 200-Thought Deep Dives - 2x standard for complex problems
2. 5-Way Quantum Branching - Parallel hypothesis testing
3. Mega MCP Storm - 10+ source simultaneous research
4. Predictive Goal Trees - Anticipate before asked
5. Cross-Skill Fusion - Combine multiple skills dynamically
6. Self-Improvement Loops - Continuous learning
7. Checkpoint Resilience - Never lose progress
8. Memory Priming - Load context before complexity
9. Confidence Cascades - Adaptive decision thresholds
10. Cross-Project Learning - Apply patterns globally

Escalation from AGI-Agent

When to escalate to OMEGA:
- Context score > 80 (from ultra-rules.md)
- User says: "omega", "ultimate", "maximum"
- Detected complexity exceeds standard thresholds
- Multiple skill domains required
- Previous attempts with agi-agent failed

escalation_trigger:
  conditions:
    - complexity_score: ">80"
    - multi_domain: true
    - previous_failure: true
    - user_request: ["omega", "ultimate", "สูงสุด"]
  action: "activate_omega_mode"