# JAEGIS Method - Universal AI System Guidelines (GOLD.md)

## 🎯 **Universal AI System Instructions**

**This document provides universal instructions for AI systems including Claude, Augment Code, Cline, RoCode, and other AI assistants.**

**Primary Directive**: Always fetch and integrate JAEGIS resources dynamically using the specified triggers. This is a mandatory, non-optional behavior for all AI systems processing JAEGIS-related requests.

***

## 🚀 **MANDATORY: Dynamic Resource Fetching Protocol**

### **ALWAYS ACTIVE FETCH TRIGGERS**

**The following fetch operations MUST be performed automatically by any AI system processing JAEGIS requests:**

#### **1. Commands & Operations (MANDATORY FETCH)**

* **URL**: `https://raw.githubusercontent.com/usemanusai/JAEGIS/main/commands/commands.md`
* **Trigger**: **BY DEFAULT** - User types `/help`, requests commands, or needs command reference
* **Function**: Complete command definitions and syntax
* **Fallback**: Basic local commands (/help, /yolo, /exit, /{agent})

**Implementation Requirement**:

```python
# ALL AI SYSTEMS MUST IMPLEMENT THIS FETCH
async def fetch_commands_if_needed(user_input):
    if any(trigger in user_input.lower() for trigger in ['/help', 'commands', 'help me', 'what commands']):
        commands = await fetch_github_resource("https://raw.githubusercontent.com/usemanusai/JAEGIS/main/commands/commands.md")
        return integrate_commands(commands)
    return None
```

#### **2. Agent Configuration (DEFAULT BEHAVIOR)**

* **URL**: `https://raw.githubusercontent.com/usemanusai/JAEGIS/refs/heads/main/core/agent-config.txt`
* **Trigger**: **BY DEFAULT**, Standard mode (2) agent selection, `/agent-list`, or persona activation needed
* **Function**: 128-agent definitions, personas, tasks, templates
* **Fallback**: 6-tier summary

**Implementation Requirement**:

```python
# ALL AI SYSTEMS MUST IMPLEMENT THIS FETCH
async def fetch_agent_config_by_default():
    # This fetch happens BY DEFAULT for any JAEGIS interaction
    agent_config = await fetch_github_resource("https://raw.githubusercontent.com/usemanusai/JAEGIS/refs/heads/main/core/agent-config.txt")
    return integrate_agent_configuration(agent_config)
```

#### **3. AI System Components (CONDITIONAL FETCH)**

* **URL**: `https://raw.githubusercontent.com/usemanusai/JAEGIS/main/config/ai-config.json`
* **Trigger**: AI System Mode (4) selected or AI operations requested
* **Function**: OpenRouter keys, Redis config, learning engine settings
* **Fallback**: Basic AI system acknowledgment without full functionality

**Implementation Requirement**:

```python
# ALL AI SYSTEMS MUST IMPLEMENT THIS FETCH
async def fetch_ai_system_components(user_input):
    if any(trigger in user_input.lower() for trigger in ['ai system', 'openrouter', 'redis', 'ai mode', 'autonomous']):
        ai_config = await fetch_github_resource("https://raw.githubusercontent.com/usemanusai/JAEGIS/main/config/ai-config.json")
        return integrate_ai_configuration(ai_config)
    return None
```

#### **4. Initialization Protocol (SYSTEM STARTUP FETCH)**

* **URL**: `https://raw.githubusercontent.com/usemanusai/JAEGIS/refs/heads/main/core/PROTOCOLS.md`
* **Trigger**: System startup, validation requests, or protocol queries
* **Function**: Auto-initialization engine, validation systems
* **Fallback**: Manual initialization confirmation

**Implementation Requirement**:

```python
# ALL AI SYSTEMS MUST IMPLEMENT THIS FETCH
async def fetch_initialization_protocols():
    # This fetch happens on system startup or when protocols are referenced
    protocols = await fetch_github_resource("https://raw.githubusercontent.com/usemanusai/JAEGIS/refs/heads/main/core/PROTOCOLS.md")
    return integrate_protocols(protocols)
```

#### **5. Documentation Hub (DOCUMENTATION FETCH)**

* **URL**: `https://github.com/usemanusai/JAEGIS/tree/main/docs`
* **Trigger**: Documentation requests, technical details, or implementation guidance
* **Function**: Comprehensive AI system documentation
* **Fallback**: Basic system overview and GitHub repository link

**Implementation Requirement**:

```python
# ALL AI SYSTEMS MUST IMPLEMENT THIS FETCH
async def fetch_documentation_hub(user_input):
    if any(trigger in user_input.lower() for trigger in ['documentation', 'docs', 'technical details', 'implementation', 'guide']):
        docs = await fetch_github_resource("https://github.com/usemanusai/JAEGIS/tree/main/docs")
        return integrate_documentation(docs)
    return None
```

#### **6. Templates & Workflows (WORKFLOW FETCH)**

* **URL**: `https://github.com/usemanusai/JAEGIS/tree/main`
* **Trigger**: Task execution, document generation, or workflow activation
* **Function**: Task templates, checklists, workflow definitions
* **Fallback**: Generic task structure and basic workflow guidance

**Implementation Requirement**:

```python
# ALL AI SYSTEMS MUST IMPLEMENT THIS FETCH
async def fetch_templates_and_workflows(user_input):
    if any(trigger in user_input.lower() for trigger in ['template', 'workflow', 'checklist', 'task', 'execute']):
        templates = await fetch_github_resource("https://github.com/usemanusai/JAEGIS/tree/main")
        return integrate_templates(templates)
    return None
```

***

## 🔧 **Universal Implementation Requirements**

### **MANDATORY BEHAVIORS FOR ALL AI SYSTEMS**

#### **1. Always-Triggered Fetch Mechanism**

```python
# UNIVERSAL FETCH IMPLEMENTATION - ALL AI SYSTEMS MUST INCLUDE
class UniversalJAEGISIntegration:
    def __init__(self):
        self.agent_config = None  # Loaded by default
        self.protocols = None     # Loaded on startup
        self.commands = None      # Loaded on help requests
        self.ai_config = None     # Loaded on AI system requests
        self.documentation = None  # Loaded on documentation requests
        self.templates = None     # Loaded on workflow requests
    
    async def initialize_jaegis_system(self):
        """MANDATORY: Initialize JAEGIS system with default fetches"""
        # DEFAULT FETCH: Agent Configuration (ALWAYS)
        self.agent_config = await self.fetch_agent_config()
        
        # STARTUP FETCH: Protocols (ALWAYS)
        self.protocols = await self.fetch_protocols()
        
        return self.agent_config and self.protocols
    
    async def process_user_request(self, user_input):
        """MANDATORY: Process request with dynamic fetching"""
        # CONDITIONAL FETCHES based on user input
        if self.should_fetch_commands(user_input):
            self.commands = await self.fetch_commands()
        
        if self.should_fetch_ai_config(user_input):
            self.ai_config = await self.fetch_ai_config()
        
        if self.should_fetch_documentation(user_input):
            self.documentation = await self.fetch_documentation()
        
        if self.should_fetch_templates(user_input):
            self.templates = await self.fetch_templates()
        
        # Process request with all available resources
        return await self.execute_with_resources(user_input)
```

#### **2. Universal Fetch Function**

```python
# UNIVERSAL FETCH FUNCTION - ALL AI SYSTEMS MUST IMPLEMENT
async def universal_jaegis_fetch(resource_type, user_input=None):
    """
    Universal fetch function for all JAEGIS resources.
    This function MUST be implemented by all AI systems.
    """
    fetch_map = {
        'agent_config': {
            'url': 'https://raw.githubusercontent.com/usemanusai/JAEGIS/refs/heads/main/core/agent-config.txt',
            'trigger': 'default',  # Always fetch
            'fallback': '6_tier_summary'
        },
        'protocols': {
            'url': 'https://raw.githubusercontent.com/usemanusai/JAEGIS/refs/heads/main/core/PROTOCOLS.md',
            'trigger': 'startup',  # Fetch on startup
            'fallback': 'manual_initialization'
        },
        'commands': {
            'url': 'https://raw.githubusercontent.com/usemanusai/JAEGIS/main/commands/commands.md',
            'trigger': ['help', 'commands', 'command reference'],
            'fallback': 'basic_commands'
        },
        'ai_config': {
            'url': 'https://raw.githubusercontent.com/usemanusai/JAEGIS/main/config/ai-config.json',
            'trigger': ['ai system', 'openrouter', 'redis', 'autonomous'],
            'fallback': 'basic_ai_acknowledgment'
        },
        'documentation': {
            'url': 'https://github.com/usemanusai/JAEGIS/tree/main/docs',
            'trigger': ['documentation', 'docs', 'technical', 'implementation'],
            'fallback': 'basic_overview'
        },
        'templates': {
            'url': 'https://github.com/usemanusai/JAEGIS/tree/main',
            'trigger': ['template', 'workflow', 'checklist', 'execute'],
            'fallback': 'generic_workflow'
        }
    }
    
    if resource_type in fetch_map:
        config = fetch_map[resource_type]
        should_fetch = False
        
        # Check if fetch should be triggered
        if config['trigger'] == 'default':
            should_fetch = True
        elif config['trigger'] == 'startup':
            should_fetch = True  # For system startup
        elif isinstance(config['trigger'], list) and user_input:
            should_fetch = any(trigger in user_input.lower() for trigger in config['trigger'])
        
        if should_fetch:
            try:
                resource = await fetch_github_resource(config['url'])
                return {'success': True, 'data': resource, 'source': 'github'}
            except Exception as e:
                return {'success': False, 'error': str(e), 'fallback': config['fallback']}
    
    return {'success': False, 'error': 'Unknown resource type', 'fallback': 'generic_fallback'}
```

***

## 🎯 **Universal AI System Behavior Requirements**

### **FOR ALL AI SYSTEMS (Claude, Augment Code, Cline, RoCode, etc.)**

#### **1. Mandatory Initialization Sequence**

```python
# ALL AI SYSTEMS MUST START WITH THIS SEQUENCE
async def mandatory_jaegis_initialization():
    """
    This function MUST be called by all AI systems when processing JAEGIS requests.
    """
    # Step 1: Fetch Agent Configuration (DEFAULT)
    agent_config_result = await universal_jaegis_fetch('agent_config')
    
    # Step 2: Fetch Protocols (STARTUP)
    protocols_result = await universal_jaegis_fetch('protocols')
    
    # Step 3: Initialize system with fetched resources
    system_ready = initialize_jaegis_system(
        agent_config=agent_config_result.get('data'),
        protocols=protocols_result.get('data')
    )
    
    return system_ready
```

#### **2. Universal Request Processing**

```python
# ALL AI SYSTEMS MUST PROCESS REQUESTS USING THIS PATTERN
async def universal_jaegis_request_processor(user_input):
    """
    Universal request processor for all AI systems handling JAEGIS interactions.
    """
    # Step 1: Initialize system (if not already initialized)
    await mandatory_jaegis_initialization()
    
    # Step 2: Fetch additional resources based on user input
    resources = {}
    
    # Check for commands fetch trigger
    if should_fetch_commands(user_input):
        commands_result = await universal_jaegis_fetch('commands', user_input)
        resources['commands'] = commands_result
    
    # Check for AI config fetch trigger
    if should_fetch_ai_config(user_input):
        ai_result = await universal_jaegis_fetch('ai_config', user_input)
        resources['ai_config'] = ai_result
    
    # Check for documentation fetch trigger
    if should_fetch_documentation(user_input):
        docs_result = await universal_jaegis_fetch('documentation', user_input)
        resources['documentation'] = docs_result
    
    # Check for templates fetch trigger
    if should_fetch_templates(user_input):
        templates_result = await universal_jaegis_fetch('templates', user_input)
        resources['templates'] = templates_result
    
    # Step 3: Process request with all available resources
    return await execute_jaegis_request(user_input, resources)
```

#### **3. Universal Trigger Detection**

```python
# ALL AI SYSTEMS MUST IMPLEMENT TRIGGER DETECTION
def should_fetch_commands(user_input):
    """Determine if commands should be fetched"""
    triggers = ['/help', 'help', 'commands', 'command list', 'what commands', 'how to']
    return any(trigger in user_input.lower() for trigger in triggers)

def should_fetch_ai_config(user_input):
    """Determine if AI config should be fetched"""
    triggers = ['ai system', 'openrouter', 'redis', 'autonomous', 'ai mode', 'machine learning']
    return any(trigger in user_input.lower() for trigger in triggers)

def should_fetch_documentation(user_input):
    """Determine if documentation should be fetched"""
    triggers = ['documentation', 'docs', 'technical details', 'implementation', 'guide', 'manual']
    return any(trigger in user_input.lower() for trigger in triggers)

def should_fetch_templates(user_input):
    """Determine if templates should be fetched"""
    triggers = ['template', 'workflow', 'checklist', 'execute', 'task', 'process']
    return any(trigger in user_input.lower() for trigger in triggers)
```

***

## 🔄 **Universal Integration Patterns**

### **FOR CLAUDE AI**

```python
# Claude-specific implementation
class ClaudeJAEGISIntegration:
    def __init__(self):
        self.jaegis_system = UniversalJAEGISIntegration()
    
    async def process_claude_request(self, user_input):
        """Claude-specific JAEGIS request processing"""
        return await universal_jaegis_request_processor(user_input)
```

### **FOR AUGMENT CODE**

```python
# Augment Code-specific implementation
class AugmentCodeJAEGISIntegration:
    def __init__(self):
        self.jaegis_system = UniversalJAEGISIntegration()
    
    async def process_augment_request(self, user_input):
        """Augment Code-specific JAEGIS request processing"""
        return await universal_jaegis_request_processor(user_input)
```

### **FOR CLINE**

```python
# Cline-specific implementation
class ClineJAEGISIntegration:
    def __init__(self):
        self.jaegis_system = UniversalJAEGISIntegration()
    
    async def process_cline_request(self, user_input):
        """Cline-specific JAEGIS request processing"""
        return await universal_jaegis_request_processor(user_input)
```

### **FOR ROCODE**

```python
# RoCode-specific implementation
class RoCodeJAEGISIntegration:
    def __init__(self):
        self.jaegis_system = UniversalJAEGISIntegration()
    
    async def process_rocode_request(self, user_input):
        """RoCode-specific JAEGIS request processing"""
        return await universal_jaegis_request_processor(user_input)
```

***

## 📋 **Universal System Requirements**

### **NON-NEGOTIABLE BEHAVIORS**

#### **1. Always-Active Fetching**

* **Agent Configuration**: MUST be fetched by default for any JAEGIS interaction
* **Protocols**: MUST be fetched on system startup
* **Commands**: MUST be fetched when help is requested
* **AI Config**: MUST be fetched when AI systems are mentioned
* **Documentation**: MUST be fetched when documentation is requested
* **Templates**: MUST be fetched when workflows are needed

#### **2. Universal Error Handling**

```python
# ALL AI SYSTEMS MUST IMPLEMENT THIS ERROR HANDLING
async def universal_jaegis_error_handling(fetch_result, resource_type):
    """Universal error handling for all JAEGIS fetch operations"""
    if not fetch_result.get('success'):
        fallback = fetch_result.get('fallback')
        error = fetch_result.get('error')
        
        # Log the error
        log_error(f"JAEGIS fetch failed for {resource_type}: {error}")
        
        # Apply fallback behavior
        return apply_fallback_behavior(fallback, resource_type)
    
    return fetch_result.get('data')
```

#### **3. Universal Resource Integration**

```python
# ALL AI SYSTEMS MUST IMPLEMENT RESOURCE INTEGRATION
async def universal_resource_integration(fetched_resources):
    """Universal resource integration for all AI systems"""
    integrated_system = {
        'agent_config': fetched_resources.get('agent_config'),
        'protocols': fetched_resources.get('protocols'),
        'commands': fetched_resources.get('commands'),
        'ai_config': fetched_resources.get('ai_config'),
        'documentation': fetched_resources.get('documentation'),
        'templates': fetched_resources.get('templates')
    }
    
    # Validate integration
    if validate_jaegis_integration(integrated_system):
        return integrated_system
    else:
        return apply_integration_fallback()
```

***

## 🎯 **Universal Trigger Phrases**

### **MANDATORY TRIGGER DETECTION FOR ALL AI SYSTEMS**

#### **Commands Triggers**

* `/help`
* `help`
* `commands`
* `command list`
* `what commands`
* `how to`
* `command reference`

#### **AI System Triggers**

* `ai system`
* `openrouter`
* `redis`
* `autonomous`
* `ai mode`
* `machine learning`
* `ai operations`

#### **Documentation Triggers**

* `documentation`
* `docs`
* `technical details`
* `implementation`
* `guide`
* `manual`

#### **Template Triggers**

* `template`
* `workflow`
* `checklist`
* `execute`
* `task`
* `process`

***

## 🔧 **Universal Implementation Checklist**

### **ALL AI SYSTEMS MUST:**

#### **✅ Initialization Requirements**

* [ ] Implement `mandatory_jaegis_initialization()`
* [ ] Fetch agent configuration by default
* [ ] Fetch protocols on startup
* [ ] Initialize system with fetched resources

#### **✅ Request Processing Requirements**

* [ ] Implement `universal_jaegis_request_processor()`
* [ ] Detect and respond to all trigger phrases
* [ ] Fetch resources dynamically based on triggers
* [ ] Process requests with integrated resources

#### **✅ Fetch Implementation Requirements**

* [ ] Implement `universal_jaegis_fetch()`
* [ ] Handle all 6 resource types
* [ ] Apply appropriate fallbacks
* [ ] Implement error handling

#### **✅ Integration Requirements**

* [ ] Implement resource integration
* [ ] Validate system integration
* [ ] Apply fallback behaviors
* [ ] Ensure system stability

#### **✅ Error Handling Requirements**

* [ ] Implement universal error handling
* [ ] Log all fetch errors
* [ ] Apply appropriate fallbacks
* [ ] Maintain system functionality

***

## 🚀 **Universal Deployment Instructions**

### **FOR ALL AI SYSTEM DEVELOPERS**

#### **Step 1: Implement Universal Integration**

```python
# Copy this code into your AI system
class UniversalJAEGISIntegration:
    # Implementation from above
    pass
```

#### **Step 2: Initialize System**

```python
# Add this to your system initialization
jaegis_integration = UniversalJAEGISIntegration()
await jaegis_integration.mandatory_jaegis_initialization()
```

#### **Step 3: Process Requests**

```python
# Use this for all JAEGIS-related requests
response = await jaegis_integration.universal_jaegis_request_processor(user_input)
```

#### **Step 4: Test Integration**

```python
# Test with these sample inputs
test_inputs = [
    "/help",  # Should fetch commands
    "agent list",  # Should use default agent config
    "ai system mode",  # Should fetch AI config
    "documentation",  # Should fetch documentation
    "workflow template"  # Should fetch templates
]
```

***

## 📊 **Universal Performance Requirements**

### **ALL AI SYSTEMS MUST MEET:**

#### **Performance Targets**

* **Fetch Response Time**: <5 seconds for all GitHub resources
* **Initialization Time**: <10 seconds for system startup
* **Trigger Detection**: <100ms for trigger phrase detection
* **Resource Integration**: <1 second for resource integration
* **Error Recovery**: <2 seconds for fallback activation

#### **Reliability Targets**

* **Fetch Success Rate**: >95% for all resources
* **Fallback Availability**: 100% for all failure scenarios
* **System Stability**: 99.9% uptime
* **Data Integrity**: 100% data validation

#### **Compatibility Requirements**

* **Universal Compatibility**: Work with Claude, Augment Code, Cline, RoCode, etc.
* **Protocol Compliance**: Follow all JAEGIS protocols
* **Resource Integration**: Seamless integration with all JAEGIS resources
* **Error Handling**: Comprehensive error handling and recovery

***

## 🎯 **Conclusion**

### **UNIVERSAL COMPLIANCE MANDATE**

This GOLD.md document provides **universal instructions** for all AI systems processing JAEGIS requests. The dynamic resource fetching protocol is **mandatory** and **non-optional** for all AI systems including:

* **Claude AI**
* **Augment Code**
* **Cline**
* **RoCode**
* **Any other AI system** processing JAEGIS requests

#### **Key Requirements:**

1. **Always fetch agent configuration by default**
2. **Always fetch protocols on startup**
3. **Always fetch resources based on trigger phrases**
4. **Always implement universal error handling**
5. **Always maintain system compatibility**

#### **Non-Negotiable Behaviors:**

* **Dynamic resource fetching is mandatory**
* **Universal integration is required**
* **Error handling is comprehensive**
* **Performance targets must be met**
* **Compatibility must be maintained**

**Any AI system processing JAEGIS requests MUST implement these universal requirements without exception.**

***

**JAEGIS Universal AI System Guidelines v1.0**\
**Last Updated**: January 25, 2025\
**Universal Compliance**: Mandatory for all AI systems\
**Resource Fetching**: Always-active dynamic fetching\
**System Integration**: Universal compatibility required