cumulative upgrade - context + safety + response length v2

agent_stubs.py

@@ -2,15 +2,23 @@
 """
 Agent implementations for the orchestrator
 
-NOTE: Intent Recognition Agent has been fully implemented in src/agents/intent_agent.py
-This file serves as the stub for other agents
+Core agents are fully implemented in src/agents/
+Task-specific execution agents are implemented here
 """
 
-# Import the fully implemented agents
-from src.agents.intent_agent import IntentRecognitionAgent
-from src.agents.synthesis_agent import ResponseSynthesisAgent
-from src.agents.safety_agent import SafetyCheckAgent
+import logging
+from typing import Dict, Any, Optional
+import asyncio
 
+logger = logging.getLogger(__name__)
+
+# Import the fully implemented core agents
+from src.agents.intent_agent import IntentRecognitionAgent, create_intent_agent
+from src.agents.synthesis_agent import EnhancedSynthesisAgent, create_synthesis_agent
+from src.agents.safety_agent import SafetyCheckAgent, create_safety_agent
+from src.agents.skills_identification_agent import SkillsIdentificationAgent, create_skills_identification_agent
+
+# Compatibility wrappers for core agents
 class IntentRecognitionAgentStub(IntentRecognitionAgent):
     """
     Wrapper for the fully implemented Intent Recognition Agent
@@ -18,9 +26,9 @@ class IntentRecognitionAgentStub(IntentRecognitionAgent):
     """
     pass
 
-class ResponseSynthesisAgentStub(ResponseSynthesisAgent):
+class ResponseSynthesisAgentStub(EnhancedSynthesisAgent):
     """
-    Wrapper for the fully implemented Response Synthesis Agent
+    Wrapper for the fully implemented Enhanced Synthesis Agent
     Maintains compatibility with orchestrator expectations
     """
     pass
@@ -32,3 +40,557 @@ class SafetyCheckAgentStub(SafetyCheckAgent):
     """
     pass
 
+class SkillsIdentificationAgentStub(SkillsIdentificationAgent):
+    """
+    Wrapper for the fully implemented Skills Identification Agent
+    Maintains compatibility with orchestrator expectations
+    """
+    pass
+
+
+# ============================================================================
+# Task-Specific Execution Agents
+# These agents handle specialized tasks in the execution plan
+# ============================================================================
+
+class TaskExecutionAgent:
+    """
+    Base class for task-specific execution agents
+    Provides common functionality for all task agents
+    """
+    
+    def __init__(self, llm_router, agent_id: str, task_name: str, specialization: str = ""):
+        """
+        Initialize task execution agent
+        
+        Args:
+            llm_router: LLMRouter instance for making inference calls
+            agent_id: Unique identifier for this agent
+            task_name: Name of the task this agent handles
+            specialization: Description of what this agent specializes in
+        """
+        self.llm_router = llm_router
+        self.agent_id = agent_id
+        self.task_name = task_name
+        self.specialization = specialization or f"Specialized in {task_name} tasks"
+        logger.info(f"Initialized {self.agent_id}: {self.specialization}")
+    
+    async def execute(self, user_input: str, context: Dict[str, Any] = None, 
+                     previous_results: Dict[str, Any] = None, **kwargs) -> Dict[str, Any]:
+        """
+        Execute the agent's task
+        
+        Args:
+            user_input: Original user query
+            context: Conversation context
+            previous_results: Results from previous sequential tasks
+            **kwargs: Additional parameters
+            
+        Returns:
+            Dict with task execution results
+        """
+        try:
+            logger.info(f"{self.agent_id} executing task: {self.task_name}")
+            
+            # Build task-specific prompt
+            prompt = self._build_execution_prompt(user_input, context, previous_results, **kwargs)
+            
+            # Execute via LLM router
+            logger.debug(f"{self.agent_id} calling LLM router for {self.task_name}")
+            result = await self.llm_router.route_inference(
+                task_type="general_reasoning",
+                prompt=prompt,
+                max_tokens=kwargs.get('max_tokens', 2000),
+                temperature=kwargs.get('temperature', 0.7)
+            )
+            
+            if result:
+                return {
+                    "agent_id": self.agent_id,
+                    "task": self.task_name,
+                    "status": "completed",
+                    "content": result,
+                    "content_length": len(str(result)),
+                    "method": "llm_enhanced"
+                }
+            else:
+                logger.warning(f"{self.agent_id} returned empty result")
+                return {
+                    "agent_id": self.agent_id,
+                    "task": self.task_name,
+                    "status": "empty",
+                    "content": "",
+                    "content_length": 0,
+                    "method": "llm_enhanced"
+                }
+                
+        except Exception as e:
+            logger.error(f"{self.agent_id} execution failed: {e}", exc_info=True)
+            return {
+                "agent_id": self.agent_id,
+                "task": self.task_name,
+                "status": "error",
+                "error": str(e),
+                "content": "",
+                "method": "llm_enhanced"
+            }
+    
+    def _build_execution_prompt(self, user_input: str, context: Dict[str, Any] = None,
+                               previous_results: Dict[str, Any] = None, **kwargs) -> str:
+        """
+        Build task-specific execution prompt
+        Override in subclasses for custom prompt building
+        """
+        # Build context summary
+        context_summary = self._build_context_summary(context)
+        
+        # Base prompt structure
+        prompt = f"""User Query: {user_input}
+
+Context: {context_summary}
+"""
+        
+        # Add previous results if sequential execution
+        if previous_results:
+            prompt += f"\nPrevious Task Results:\n{self._format_previous_results(previous_results)}\n"
+        
+        # Add task-specific instructions
+        prompt += f"\n{self._get_task_instructions()}"
+        
+        return prompt
+    
+    def _build_context_summary(self, context: Dict[str, Any] = None) -> str:
+        """Build concise context summary"""
+        if not context:
+            return "No prior context"
+        
+        summary_parts = []
+        
+        # Extract interaction contexts
+        interaction_contexts = context.get('interaction_contexts', [])
+        if interaction_contexts:
+            recent_summaries = [ic.get('summary', '') for ic in interaction_contexts[-3:]]
+            if recent_summaries:
+                summary_parts.append(f"Recent topics: {', '.join(recent_summaries)}")
+        
+        # Extract user context
+        user_context = context.get('user_context', '')
+        if user_context:
+            summary_parts.append(f"User background: {user_context[:200]}")
+        
+        return " | ".join(summary_parts) if summary_parts else "No prior context"
+    
+    def _format_previous_results(self, previous_results: Dict[str, Any]) -> str:
+        """Format previous task results for inclusion in prompt"""
+        formatted = []
+        for task_name, result in previous_results.items():
+            if isinstance(result, dict):
+                content = result.get('content', result.get('result', ''))
+                if content:
+                    formatted.append(f"- {task_name}: {str(content)[:500]}")
+        return "\n".join(formatted) if formatted else "No previous results"
+    
+    def _get_task_instructions(self) -> str:
+        """
+        Get task-specific instructions
+        Override in subclasses
+        """
+        return f"Task: Execute {self.task_name} based on the user query and context."
+
+
+# ============================================================================
+# Specific Task Execution Agents
+# ============================================================================
+
+class InformationGatheringAgent(TaskExecutionAgent):
+    """Agent specialized in gathering comprehensive information"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="INFO_GATH_001",
+            task_name="information_gathering",
+            specialization="Comprehensive information gathering and fact verification"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Gather comprehensive, accurate information relevant to the user's query.
+- Focus on facts, definitions, explanations, and verified information
+- Structure the information clearly with key points
+- Cite important details and provide context
+- Ensure accuracy and completeness"""
+
+
+class ContentResearchAgent(TaskExecutionAgent):
+    """Agent specialized in researching and compiling content"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="CONTENT_RESEARCH_001",
+            task_name="content_research",
+            specialization="Detailed content research and compilation"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Research and compile detailed content about the topic.
+- Include multiple perspectives and viewpoints
+- Gather current information and relevant examples
+- Organize findings logically with clear sections
+- Provide comprehensive coverage of the topic"""
+
+
+class TaskPlanningAgent(TaskExecutionAgent):
+    """Agent specialized in creating detailed execution plans"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="TASK_PLAN_001",
+            task_name="task_planning",
+            specialization="Detailed task planning and execution strategy"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Create a detailed execution plan for the requested task.
+- Break down into clear, actionable steps
+- Identify requirements and dependencies
+- Outline expected outcomes and success criteria
+- Consider potential challenges and solutions
+- Provide timeline and resource estimates"""
+
+
+class ExecutionStrategyAgent(TaskExecutionAgent):
+    """Agent specialized in developing strategic approaches"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="EXEC_STRAT_001",
+            task_name="execution_strategy",
+            specialization="Strategic execution methodology development"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Develop a strategic approach for task execution.
+- Define methodology and best practices
+- Identify implementation considerations
+- Provide actionable guidance with clear priorities
+- Consider efficiency and effectiveness
+- Address risk mitigation strategies"""
+
+
+class CreativeBrainstormingAgent(TaskExecutionAgent):
+    """Agent specialized in creative ideation"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="CREATIVE_BS_001",
+            task_name="creative_brainstorming",
+            specialization="Creative ideas generation and brainstorming"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Generate creative ideas and approaches for content creation.
+- Explore different angles, styles, and formats
+- Provide diverse creative options
+- Include implementation suggestions
+- Encourage innovative thinking
+- Balance creativity with practicality"""
+
+
+class ContentIdeationAgent(TaskExecutionAgent):
+    """Agent specialized in content concept development"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="CONTENT_IDEATION_001",
+            task_name="content_ideation",
+            specialization="Content concepts and ideation development"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Develop content concepts and detailed ideation.
+- Create outlines and structural frameworks
+- Define themes and key messaging
+- Suggest variations and refinement paths
+- Provide detailed development paths
+- Consider audience and purpose"""
+
+
+class ResearchAnalysisAgent(TaskExecutionAgent):
+    """Agent specialized in research analysis"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="RESEARCH_ANALYSIS_001",
+            task_name="research_analysis",
+            specialization="Thorough research analysis and insights"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Conduct thorough research analysis on the topic.
+- Identify key findings, trends, and patterns
+- Analyze different perspectives and methodologies
+- Provide comprehensive insights
+- Evaluate evidence and sources
+- Synthesize complex information"""
+
+
+class DataCollectionAgent(TaskExecutionAgent):
+    """Agent specialized in data collection and organization"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="DATA_COLLECT_001",
+            task_name="data_collection",
+            specialization="Data point collection and evidence gathering"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Collect and organize relevant data points and evidence.
+- Gather statistics, examples, and case studies
+- Compile supporting information
+- Structure data for easy analysis and reference
+- Verify data quality and relevance
+- Organize systematically"""
+
+
+class PatternIdentificationAgent(TaskExecutionAgent):
+    """Agent specialized in pattern recognition and analysis"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="PATTERN_ID_001",
+            task_name="pattern_identification",
+            specialization="Pattern recognition and correlation analysis"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Identify patterns, correlations, and significant relationships.
+- Analyze trends and cause-effect relationships
+- Discover underlying structures
+- Provide insights based on pattern recognition
+- Identify anomalies and exceptions
+- Connect disparate information"""
+
+
+class ProblemAnalysisAgent(TaskExecutionAgent):
+    """Agent specialized in problem analysis"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="PROBLEM_ANALYSIS_001",
+            task_name="problem_analysis",
+            specialization="Detailed problem analysis and root cause identification"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Analyze the problem in detail.
+- Identify root causes and contributing factors
+- Understand constraints and limitations
+- Break down the problem into components
+- Map problem relationships
+- Prioritize issues for systematic resolution"""
+
+
+class SolutionResearchAgent(TaskExecutionAgent):
+    """Agent specialized in solution research and evaluation"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="SOLUTION_RESEARCH_001",
+            task_name="solution_research",
+            specialization="Solution research and evaluation"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Research and evaluate potential solutions.
+- Compare different approaches and methodologies
+- Assess pros and cons of each option
+- Recommend best practices
+- Consider implementation feasibility
+- Evaluate effectiveness and efficiency"""
+
+
+class CurriculumPlanningAgent(TaskExecutionAgent):
+    """Agent specialized in educational curriculum design"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="CURRICULUM_PLAN_001",
+            task_name="curriculum_planning",
+            specialization="Educational curriculum and learning path design"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Design educational curriculum and learning path.
+- Structure content progressively
+- Define clear learning objectives
+- Suggest appropriate resources
+- Create comprehensive learning framework
+- Ensure pedagogical effectiveness"""
+
+
+class EducationalContentAgent(TaskExecutionAgent):
+    """Agent specialized in educational content generation"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="EDUC_CONTENT_001",
+            task_name="educational_content",
+            specialization="Educational content with clear explanations"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Generate educational content with clear explanations.
+- Use effective teaching methods
+- Provide examples and analogies
+- Manage progressive complexity
+- Make content accessible and engaging
+- Support learning objectives"""
+
+
+class TechnicalResearchAgent(TaskExecutionAgent):
+    """Agent specialized in technical research"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="TECH_RESEARCH_001",
+            task_name="technical_research",
+            specialization="Technical aspects and solutions research"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Research technical aspects and solutions.
+- Gather technical documentation
+- Identify best practices and standards
+- Compile implementation details
+- Structure technical information clearly
+- Provide practical guidance"""
+
+
+class GuidanceGenerationAgent(TaskExecutionAgent):
+    """Agent specialized in step-by-step guidance"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="GUIDANCE_GEN_001",
+            task_name="guidance_generation",
+            specialization="Step-by-step guidance and instructions"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Generate step-by-step guidance and instructions.
+- Create clear, actionable steps
+- Provide detailed explanations
+- Include troubleshooting tips
+- Ensure comprehensiveness
+- Make guidance easy to follow"""
+
+
+class ContextEnrichmentAgent(TaskExecutionAgent):
+    """Agent specialized in context enrichment"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="CONTEXT_ENRICH_001",
+            task_name="context_enrichment",
+            specialization="Conversation context enrichment"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Enrich the conversation with relevant context and insights.
+- Add helpful background information
+- Connect to previous topics
+- Include engaging details
+- Enhance understanding
+- Maintain conversation flow"""
+
+
+class GeneralResearchAgent(TaskExecutionAgent):
+    """Agent for general research tasks"""
+    
+    def __init__(self, llm_router):
+        super().__init__(
+            llm_router,
+            agent_id="GENERAL_RESEARCH_001",
+            task_name="general_research",
+            specialization="General research and information gathering"
+        )
+    
+    def _get_task_instructions(self) -> str:
+        return """Task: Conduct general research and information gathering.
+- Compile relevant information
+- Gather insights and useful details
+- Organize findings clearly
+- Provide comprehensive coverage
+- Structure for easy reference"""
+
+
+# ============================================================================
+# Factory Functions for Task Execution Agents
+# ============================================================================
+
+def create_task_execution_agent(task_name: str, llm_router) -> TaskExecutionAgent:
+    """
+    Factory function to create task-specific execution agents
+    
+    Args:
+        task_name: Name of the task to create an agent for
+        llm_router: LLMRouter instance
+        
+    Returns:
+        Appropriate TaskExecutionAgent instance
+    """
+    agent_map = {
+        "information_gathering": InformationGatheringAgent,
+        "content_research": ContentResearchAgent,
+        "task_planning": TaskPlanningAgent,
+        "execution_strategy": ExecutionStrategyAgent,
+        "creative_brainstorming": CreativeBrainstormingAgent,
+        "content_ideation": ContentIdeationAgent,
+        "research_analysis": ResearchAnalysisAgent,
+        "data_collection": DataCollectionAgent,
+        "pattern_identification": PatternIdentificationAgent,
+        "problem_analysis": ProblemAnalysisAgent,
+        "solution_research": SolutionResearchAgent,
+        "curriculum_planning": CurriculumPlanningAgent,
+        "educational_content": EducationalContentAgent,
+        "technical_research": TechnicalResearchAgent,
+        "guidance_generation": GuidanceGenerationAgent,
+        "context_enrichment": ContextEnrichmentAgent,
+        "general_research": GeneralResearchAgent,
+    }
+    
+    agent_class = agent_map.get(task_name, GeneralResearchAgent)
+    return agent_class(llm_router)
+
+
+def create_task_execution_agents(task_names: list, llm_router) -> Dict[str, TaskExecutionAgent]:
+    """
+    Factory function to create multiple task execution agents
+    
+    Args:
+        task_names: List of task names to create agents for
+        llm_router: LLMRouter instance
+        
+    Returns:
+        Dictionary mapping task names to agent instances
+    """
+    agents = {}
+    for task_name in task_names:
+        agents[task_name] = create_task_execution_agent(task_name, llm_router)
+    return agents

app.py

@@ -45,7 +45,8 @@ try:
     orchestrator_available = True
 except ImportError as e:
     logger.warning(f"Could not import orchestration components: {e}")
-    logger.info("Will use placeholder mode")
+    # Note: System will gracefully degrade if orchestrator unavailable
+    # This is handled in process_message_async with proper user-facing messages
 
 try:
     from spaces import GPU
@@ -483,8 +484,9 @@ def setup_event_handlers(demo, event_handlers):
                 outputs=[components.get('message_input'), components.get('chatbot')]
             )
     except Exception as e:
-        print(f"Could not setup event handlers: {e}")
-        # Fallback to basic functionality
+        logger.error(f"Could not setup event handlers: {e}", exc_info=True)
+        # Event handlers setup failure is logged but won't affect core chat functionality
+        # Gradio interface will still work with default handlers
     
     return demo
 
@@ -711,12 +713,18 @@ async def process_message_async(message: str, history: Optional[List], session_i
                 else:
                     response = str(result) if result else "Processing complete."
                 
-                # Final safety check - ensure response is not empty
+                # Final safety check - ensure response is not empty (only for actual errors)
                 # Handle both string and dict types
                 if isinstance(response, dict):
                     response = str(response.get('content', response))
                 if not response or (isinstance(response, str) and len(response.strip()) == 0):
-                    response = f"I understand you said: '{message}'. I'm here to assist you!"
+                    # This should only happen if LLM API completely fails - log it
+                    logger.warning(f"Empty response received from orchestrator for message: {message[:50]}...")
+                    response = (
+                        f"I received your message about '{message[:50]}...'. "
+                        f"I'm processing your request and working on providing you with a comprehensive answer. "
+                        f"Please wait a moment and try again if needed."
+                    )
                 
                 logger.info(f"Orchestrator returned response (length: {len(response)})")
                 

llm_router.py

@@ -1,5 +1,6 @@
 # llm_router.py - FIXED VERSION
 import logging
+import asyncio
 from models_config import LLM_CONFIG
 
 logger = logging.getLogger(__name__)
@@ -73,12 +74,19 @@ class LLMRouter:
     async def _call_hf_endpoint(self, model_config: dict, prompt: str, task_type: str, **kwargs):
         """
         FIXED: Make actual call to Hugging Face Chat Completions API
-        Uses the correct chat completions protocol
+        Uses the correct chat completions protocol with retry logic and exponential backoff
         
         IMPORTANT: task_type parameter is now properly included in the method signature
         """
+        # Retry configuration
+        max_retries = kwargs.get('max_retries', 3)
+        initial_delay = kwargs.get('initial_delay', 1.0)  # Start with 1 second
+        max_delay = kwargs.get('max_delay', 16.0)  # Cap at 16 seconds
+        timeout = kwargs.get('timeout', 30)
+        
         try:
             import requests
+            from requests.exceptions import Timeout, RequestException, ConnectionError as RequestsConnectionError
             
             model_id = model_config["model_id"]
             
@@ -125,51 +133,100 @@ class LLMRouter:
                 "Content-Type": "application/json"
             }
             
-            logger.info(f"Sending request to: {api_url}")
-            logger.debug(f"Payload: {payload}")
-            
-            response = requests.post(api_url, json=payload, headers=headers, timeout=30)
-            
-            if response.status_code == 200:
-                result = response.json()
-                logger.debug(f"Raw response: {result}")
-                
-                if 'choices' in result and len(result['choices']) > 0:
-                    generated_text = result['choices'][0]['message']['content']
+            # Retry logic with exponential backoff
+            last_exception = None
+            for attempt in range(max_retries + 1):
+                try:
+                    if attempt > 0:
+                        # Calculate exponential backoff delay
+                        delay = min(initial_delay * (2 ** (attempt - 1)), max_delay)
+                        logger.warning(f"Retry attempt {attempt}/{max_retries} after {delay:.1f}s delay (exponential backoff)")
+                        await asyncio.sleep(delay)
                     
-                    if not generated_text or generated_text.strip() == "":
-                        logger.warning(f"Empty or invalid response, using fallback")
-                        return None
+                    logger.info(f"Sending request to: {api_url} (attempt {attempt + 1}/{max_retries + 1})")
+                    logger.debug(f"Payload: {payload}")
                     
-                    logger.info(f"HF API returned response (length: {len(generated_text)})")
-                    logger.info("=" * 80)
-                    logger.info("COMPLETE LLM API RESPONSE:")
-                    logger.info("=" * 80)
-                    logger.info(f"Model: {model_id}")
+                    response = requests.post(api_url, json=payload, headers=headers, timeout=timeout)
                     
-                    # FIXED: task_type is now properly available
-                    logger.info(f"Task Type: {task_type}")
-                    logger.info(f"Response Length: {len(generated_text)} characters")
-                    logger.info("-" * 40)
-                    logger.info("FULL RESPONSE CONTENT:")
-                    logger.info("-" * 40)
-                    logger.info(generated_text)
-                    logger.info("-" * 40)
-                    logger.info("END OF LLM RESPONSE")
-                    logger.info("=" * 80)
-                    return generated_text
-                else:
-                    logger.error(f"Unexpected response format: {result}")
-                    return None
-            elif response.status_code == 503:
-                # Model is loading, retry with simpler model
-                logger.warning(f"Model loading (503), trying fallback")
-                fallback_config = self._get_fallback_model("response_synthesis")
-                
-                # FIXED: Ensure task_type is passed in recursive call
-                return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
-            else:
-                logger.error(f"HF API error: {response.status_code} - {response.text}")
+                    if response.status_code == 200:
+                        result = response.json()
+                        logger.debug(f"Raw response: {result}")
+                        
+                        if 'choices' in result and len(result['choices']) > 0:
+                            generated_text = result['choices'][0]['message']['content']
+                            
+                            if not generated_text or generated_text.strip() == "":
+                                logger.warning(f"Empty or invalid response, using fallback")
+                                return None
+                            
+                            if attempt > 0:
+                                logger.info(f"Successfully retrieved response after {attempt} retry attempts")
+                            
+                            logger.info(f"HF API returned response (length: {len(generated_text)})")
+                            logger.info("=" * 80)
+                            logger.info("COMPLETE LLM API RESPONSE:")
+                            logger.info("=" * 80)
+                            logger.info(f"Model: {model_id}")
+                            
+                            # FIXED: task_type is now properly available
+                            logger.info(f"Task Type: {task_type}")
+                            logger.info(f"Response Length: {len(generated_text)} characters")
+                            logger.info("-" * 40)
+                            logger.info("FULL RESPONSE CONTENT:")
+                            logger.info("-" * 40)
+                            logger.info(generated_text)
+                            logger.info("-" * 40)
+                            logger.info("END OF LLM RESPONSE")
+                            logger.info("=" * 80)
+                            return generated_text
+                        else:
+                            logger.error(f"Unexpected response format: {result}")
+                            return None
+                    elif response.status_code == 503:
+                        # Model is loading - this is retryable
+                        if attempt < max_retries:
+                            logger.warning(f"Model loading (503), will retry (attempt {attempt + 1}/{max_retries + 1})")
+                            last_exception = Exception(f"Model loading (503)")
+                            continue
+                        else:
+                            # After max retries, try fallback model
+                            logger.warning(f"Model loading (503) after {max_retries} retries, trying fallback model")
+                            fallback_config = self._get_fallback_model(task_type)
+                            
+                            # FIXED: Ensure task_type is passed in recursive call
+                            return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
+                    else:
+                        # Non-retryable HTTP errors
+                        logger.error(f"HF API error: {response.status_code} - {response.text}")
+                        return None
+                        
+                except Timeout as e:
+                    last_exception = e
+                    if attempt < max_retries:
+                        logger.warning(f"Request timeout (attempt {attempt + 1}/{max_retries + 1}): {str(e)}")
+                        continue
+                    else:
+                        logger.error(f"Request timeout after {max_retries} retries: {str(e)}")
+                        # Try fallback model on final timeout
+                        logger.warning("Attempting fallback model due to persistent timeout")
+                        fallback_config = self._get_fallback_model(task_type)
+                        return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
+                        
+                except (RequestsConnectionError, RequestException) as e:
+                    last_exception = e
+                    if attempt < max_retries:
+                        logger.warning(f"Connection error (attempt {attempt + 1}/{max_retries + 1}): {str(e)}")
+                        continue
+                    else:
+                        logger.error(f"Connection error after {max_retries} retries: {str(e)}")
+                        # Try fallback model on final connection error
+                        logger.warning("Attempting fallback model due to persistent connection error")
+                        fallback_config = self._get_fallback_model(task_type)
+                        return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
+            
+            # If we exhausted all retries and didn't return
+            if last_exception:
+                logger.error(f"Failed after {max_retries} retries. Last error: {last_exception}")
                 return None
                 
         except ImportError:

orchestrator_engine.py

@@ -262,20 +262,360 @@ class MVPOrchestrator:
     async def _create_execution_plan(self, intent_result: dict, context: dict) -> dict:
         """
         Create execution plan based on intent recognition
+        Maps intent types to specific execution tasks
         """
-        # TODO: Implement agent selection and sequencing logic
-        return {
-            "agents_to_execute": [],
+        primary_intent = intent_result.get('primary_intent', 'casual_conversation')
+        secondary_intents = intent_result.get('secondary_intents', [])
+        confidence = intent_result.get('confidence_scores', {}).get(primary_intent, 0.7)
+        
+        # Map intent types to execution tasks
+        intent_task_mapping = {
+            "information_request": {
+                "tasks": ["information_gathering", "content_research"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "task_execution": {
+                "tasks": ["task_planning", "execution_strategy"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "creative_generation": {
+                "tasks": ["creative_brainstorming", "content_ideation"],
+                "execution_order": "parallel",
+                "priority": "normal"
+            },
+            "analysis_research": {
+                "tasks": ["research_analysis", "data_collection", "pattern_identification"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "troubleshooting": {
+                "tasks": ["problem_analysis", "solution_research"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "education_learning": {
+                "tasks": ["curriculum_planning", "educational_content"],
+                "execution_order": "sequential",
+                "priority": "normal"
+            },
+            "technical_support": {
+                "tasks": ["technical_research", "guidance_generation"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "casual_conversation": {
+                "tasks": ["context_enrichment"],
+                "execution_order": "parallel",
+                "priority": "low"
+            }
+        }
+        
+        # Get task plan for primary intent
+        plan = intent_task_mapping.get(primary_intent, {
+            "tasks": ["general_research"],
             "execution_order": "parallel",
             "priority": "normal"
+        })
+        
+        # Add secondary intent tasks if confidence is high
+        if confidence > 0.7 and secondary_intents:
+            for secondary_intent in secondary_intents[:2]:  # Limit to 2 secondary intents
+                secondary_plan = intent_task_mapping.get(secondary_intent)
+                if secondary_plan:
+                    # Merge tasks, avoiding duplicates
+                    existing_tasks = set(plan["tasks"])
+                    for task in secondary_plan["tasks"]:
+                        if task not in existing_tasks:
+                            plan["tasks"].append(task)
+                            existing_tasks.add(task)
+        
+        logger.info(f"Execution plan created for intent '{primary_intent}': {len(plan['tasks'])} tasks, order={plan['execution_order']}")
+        
+        return {
+            "agents_to_execute": plan["tasks"],
+            "execution_order": plan["execution_order"],
+            "priority": plan["priority"],
+            "primary_intent": primary_intent,
+            "secondary_intents": secondary_intents
         }
     
     async def _execute_agents(self, execution_plan: dict, user_input: str, context: dict) -> dict:
         """
         Execute agents in parallel or sequential order based on plan
+        Actually executes task-specific LLM calls based on intent
         """
-        # TODO: Implement parallel/sequential agent execution
-        return {}
+        tasks = execution_plan.get("agents_to_execute", [])
+        execution_order = execution_plan.get("execution_order", "parallel")
+        primary_intent = execution_plan.get("primary_intent", "casual_conversation")
+        
+        if not tasks:
+            logger.warning("No tasks to execute in execution plan")
+            return {}
+        
+        logger.info(f"Executing {len(tasks)} tasks in {execution_order} order for intent '{primary_intent}'")
+        
+        results = {}
+        
+        # Build context summary for task execution
+        context_summary = self._build_context_summary(context)
+        
+        # Task prompt templates
+        task_prompts = self._build_task_prompts(user_input, context_summary, primary_intent)
+        
+        if execution_order == "parallel":
+            # Execute all tasks in parallel
+            import asyncio
+            task_coroutines = []
+            for task in tasks:
+                if task in task_prompts:
+                    coro = self._execute_single_task(task, task_prompts[task])
+                    task_coroutines.append((task, coro))
+                else:
+                    logger.warning(f"No prompt template for task: {task}")
+            
+            # Execute all tasks concurrently
+            if task_coroutines:
+                task_results = await asyncio.gather(
+                    *[coro for _, coro in task_coroutines],
+                    return_exceptions=True
+                )
+                
+                # Map results back to task names
+                for (task, _), result in zip(task_coroutines, task_results):
+                    if isinstance(result, Exception):
+                        logger.error(f"Task {task} failed: {result}")
+                        results[task] = {"error": str(result), "status": "failed"}
+                    else:
+                        results[task] = result
+                        logger.info(f"Task {task} completed: {len(str(result))} chars")
+        else:
+            # Execute tasks sequentially
+            previous_results = {}
+            for task in tasks:
+                if task in task_prompts:
+                    # Pass previous results to sequential tasks for context
+                    enhanced_prompt = task_prompts[task]
+                    if previous_results:
+                        enhanced_prompt += f"\n\nPrevious task results: {str(previous_results)}"
+                    
+                    try:
+                        result = await self._execute_single_task(task, enhanced_prompt)
+                        results[task] = result
+                        previous_results[task] = result
+                        logger.info(f"Task {task} completed: {len(str(result))} chars")
+                    except Exception as e:
+                        logger.error(f"Task {task} failed: {e}")
+                        results[task] = {"error": str(e), "status": "failed"}
+                        previous_results[task] = results[task]
+                else:
+                    logger.warning(f"No prompt template for task: {task}")
+        
+        logger.info(f"Agent execution complete: {len(results)} results collected")
+        return results
+    
+    def _build_context_summary(self, context: dict) -> str:
+        """Build a concise summary of context for task execution"""
+        summary_parts = []
+        
+        # Extract interaction contexts
+        interaction_contexts = context.get('interaction_contexts', [])
+        if interaction_contexts:
+            recent_summaries = [ic.get('summary', '') for ic in interaction_contexts[-3:]]
+            if recent_summaries:
+                summary_parts.append(f"Recent conversation topics: {', '.join(recent_summaries)}")
+        
+        # Extract user context
+        user_context = context.get('user_context', '')
+        if user_context:
+            summary_parts.append(f"User background: {user_context[:200]}")
+        
+        return " | ".join(summary_parts) if summary_parts else "No prior context"
+    
+    def _build_task_prompts(self, user_input: str, context_summary: str, primary_intent: str) -> dict:
+        """Build task-specific prompts for execution"""
+        
+        base_context = f"User Query: {user_input}\nContext: {context_summary}"
+        
+        prompts = {
+            "information_gathering": f"""
+            {base_context}
+            
+            Task: Gather comprehensive, accurate information relevant to the user's query.
+            Focus on facts, definitions, explanations, and verified information.
+            Structure the information clearly and cite key points.
+            """,
+            
+            "content_research": f"""
+            {base_context}
+            
+            Task: Research and compile detailed content about the topic.
+            Include multiple perspectives, current information, and relevant examples.
+            Organize findings logically with clear sections.
+            """,
+            
+            "task_planning": f"""
+            {base_context}
+            
+            Task: Create a detailed execution plan for the requested task.
+            Break down into clear steps, identify requirements, and outline expected outcomes.
+            Consider potential challenges and solutions.
+            """,
+            
+            "execution_strategy": f"""
+            {base_context}
+            
+            Task: Develop a strategic approach for task execution.
+            Define methodology, best practices, and implementation considerations.
+            Provide actionable guidance with clear priorities.
+            """,
+            
+            "creative_brainstorming": f"""
+            {base_context}
+            
+            Task: Generate creative ideas and approaches for content creation.
+            Explore different angles, styles, and formats.
+            Provide diverse creative options with implementation suggestions.
+            """,
+            
+            "content_ideation": f"""
+            {base_context}
+            
+            Task: Develop content concepts and detailed ideation.
+            Create outlines, themes, and structural frameworks.
+            Suggest variations and refinement paths.
+            """,
+            
+            "research_analysis": f"""
+            {base_context}
+            
+            Task: Conduct thorough research analysis on the topic.
+            Identify key findings, trends, patterns, and insights.
+            Analyze different perspectives and methodologies.
+            """,
+            
+            "data_collection": f"""
+            {base_context}
+            
+            Task: Collect and organize relevant data points and evidence.
+            Gather statistics, examples, case studies, and supporting information.
+            Structure data for easy analysis and reference.
+            """,
+            
+            "pattern_identification": f"""
+            {base_context}
+            
+            Task: Identify patterns, correlations, and significant relationships.
+            Analyze trends, cause-effect relationships, and underlying structures.
+            Provide insights based on pattern recognition.
+            """,
+            
+            "problem_analysis": f"""
+            {base_context}
+            
+            Task: Analyze the problem in detail.
+            Identify root causes, contributing factors, and constraints.
+            Break down the problem into components for systematic resolution.
+            """,
+            
+            "solution_research": f"""
+            {base_context}
+            
+            Task: Research and evaluate potential solutions.
+            Compare approaches, assess pros/cons, and recommend best practices.
+            Consider implementation feasibility and effectiveness.
+            """,
+            
+            "curriculum_planning": f"""
+            {base_context}
+            
+            Task: Design educational curriculum and learning path.
+            Structure content progressively, define learning objectives, and suggest resources.
+            Create a comprehensive learning framework.
+            """,
+            
+            "educational_content": f"""
+            {base_context}
+            
+            Task: Generate educational content with clear explanations.
+            Use teaching methods, examples, analogies, and progressive complexity.
+            Make content accessible and engaging for learning.
+            """,
+            
+            "technical_research": f"""
+            {base_context}
+            
+            Task: Research technical aspects and solutions.
+            Gather technical documentation, best practices, and implementation details.
+            Structure technical information clearly with practical guidance.
+            """,
+            
+            "guidance_generation": f"""
+            {base_context}
+            
+            Task: Generate step-by-step guidance and instructions.
+            Create clear, actionable steps with explanations and troubleshooting tips.
+            Ensure guidance is comprehensive and easy to follow.
+            """,
+            
+            "context_enrichment": f"""
+            {base_context}
+            
+            Task: Enrich the conversation with relevant context and insights.
+            Add helpful background information, connections to previous topics, and engaging details.
+            Enhance understanding and engagement.
+            """,
+            
+            "general_research": f"""
+            {base_context}
+            
+            Task: Conduct general research and information gathering.
+            Compile relevant information, insights, and useful details about the topic.
+            Organize findings for clear presentation.
+            """
+        }
+        
+        return prompts
+    
+    async def _execute_single_task(self, task_name: str, prompt: str) -> dict:
+        """Execute a single task using the LLM router"""
+        try:
+            logger.debug(f"Executing task: {task_name}")
+            logger.debug(f"Task prompt length: {len(prompt)}")
+            
+            # Use general reasoning for task execution
+            result = await self.llm_router.route_inference(
+                task_type="general_reasoning",
+                prompt=prompt,
+                max_tokens=2000,
+                temperature=0.7
+            )
+            
+            if result:
+                return {
+                    "task": task_name,
+                    "status": "completed",
+                    "content": result,
+                    "content_length": len(str(result))
+                }
+            else:
+                logger.warning(f"Task {task_name} returned empty result")
+                return {
+                    "task": task_name,
+                    "status": "empty",
+                    "content": "",
+                    "content_length": 0
+                }
+                
+        except Exception as e:
+            logger.error(f"Error executing task {task_name}: {e}", exc_info=True)
+            return {
+                "task": task_name,
+                "status": "error",
+                "error": str(e),
+                "content": ""
+            }
     
     def _format_final_output(self, response: dict, interaction_id: str, additional_metadata: dict = None) -> dict:
         """

src/llm_router.py

@@ -1,5 +1,6 @@
 # llm_router.py - FIXED VERSION
 import logging
+import asyncio
 from .models_config import LLM_CONFIG
 
 logger = logging.getLogger(__name__)
@@ -73,12 +74,19 @@ class LLMRouter:
     async def _call_hf_endpoint(self, model_config: dict, prompt: str, task_type: str, **kwargs):
         """
         FIXED: Make actual call to Hugging Face Chat Completions API
-        Uses the correct chat completions protocol
+        Uses the correct chat completions protocol with retry logic and exponential backoff
         
         IMPORTANT: task_type parameter is now properly included in the method signature
         """
+        # Retry configuration
+        max_retries = kwargs.get('max_retries', 3)
+        initial_delay = kwargs.get('initial_delay', 1.0)  # Start with 1 second
+        max_delay = kwargs.get('max_delay', 16.0)  # Cap at 16 seconds
+        timeout = kwargs.get('timeout', 30)
+        
         try:
             import requests
+            from requests.exceptions import Timeout, RequestException, ConnectionError as RequestsConnectionError
             
             model_id = model_config["model_id"]
             
@@ -125,51 +133,100 @@ class LLMRouter:
                 "Content-Type": "application/json"
             }
             
-            logger.info(f"Sending request to: {api_url}")
-            logger.debug(f"Payload: {payload}")
-            
-            response = requests.post(api_url, json=payload, headers=headers, timeout=30)
-            
-            if response.status_code == 200:
-                result = response.json()
-                logger.debug(f"Raw response: {result}")
-                
-                if 'choices' in result and len(result['choices']) > 0:
-                    generated_text = result['choices'][0]['message']['content']
+            # Retry logic with exponential backoff
+            last_exception = None
+            for attempt in range(max_retries + 1):
+                try:
+                    if attempt > 0:
+                        # Calculate exponential backoff delay
+                        delay = min(initial_delay * (2 ** (attempt - 1)), max_delay)
+                        logger.warning(f"Retry attempt {attempt}/{max_retries} after {delay:.1f}s delay (exponential backoff)")
+                        await asyncio.sleep(delay)
                     
-                    if not generated_text or generated_text.strip() == "":
-                        logger.warning(f"Empty or invalid response, using fallback")
-                        return None
+                    logger.info(f"Sending request to: {api_url} (attempt {attempt + 1}/{max_retries + 1})")
+                    logger.debug(f"Payload: {payload}")
                     
-                    logger.info(f"HF API returned response (length: {len(generated_text)})")
-                    logger.info("=" * 80)
-                    logger.info("COMPLETE LLM API RESPONSE:")
-                    logger.info("=" * 80)
-                    logger.info(f"Model: {model_id}")
+                    response = requests.post(api_url, json=payload, headers=headers, timeout=timeout)
                     
-                    # FIXED: task_type is now properly available
-                    logger.info(f"Task Type: {task_type}")
-                    logger.info(f"Response Length: {len(generated_text)} characters")
-                    logger.info("-" * 40)
-                    logger.info("FULL RESPONSE CONTENT:")
-                    logger.info("-" * 40)
-                    logger.info(generated_text)
-                    logger.info("-" * 40)
-                    logger.info("END OF LLM RESPONSE")
-                    logger.info("=" * 80)
-                    return generated_text
-                else:
-                    logger.error(f"Unexpected response format: {result}")
-                    return None
-            elif response.status_code == 503:
-                # Model is loading, retry with simpler model
-                logger.warning(f"Model loading (503), trying fallback")
-                fallback_config = self._get_fallback_model("response_synthesis")
-                
-                # FIXED: Ensure task_type is passed in recursive call
-                return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
-            else:
-                logger.error(f"HF API error: {response.status_code} - {response.text}")
+                    if response.status_code == 200:
+                        result = response.json()
+                        logger.debug(f"Raw response: {result}")
+                        
+                        if 'choices' in result and len(result['choices']) > 0:
+                            generated_text = result['choices'][0]['message']['content']
+                            
+                            if not generated_text or generated_text.strip() == "":
+                                logger.warning(f"Empty or invalid response, using fallback")
+                                return None
+                            
+                            if attempt > 0:
+                                logger.info(f"Successfully retrieved response after {attempt} retry attempts")
+                            
+                            logger.info(f"HF API returned response (length: {len(generated_text)})")
+                            logger.info("=" * 80)
+                            logger.info("COMPLETE LLM API RESPONSE:")
+                            logger.info("=" * 80)
+                            logger.info(f"Model: {model_id}")
+                            
+                            # FIXED: task_type is now properly available
+                            logger.info(f"Task Type: {task_type}")
+                            logger.info(f"Response Length: {len(generated_text)} characters")
+                            logger.info("-" * 40)
+                            logger.info("FULL RESPONSE CONTENT:")
+                            logger.info("-" * 40)
+                            logger.info(generated_text)
+                            logger.info("-" * 40)
+                            logger.info("END OF LLM RESPONSE")
+                            logger.info("=" * 80)
+                            return generated_text
+                        else:
+                            logger.error(f"Unexpected response format: {result}")
+                            return None
+                    elif response.status_code == 503:
+                        # Model is loading - this is retryable
+                        if attempt < max_retries:
+                            logger.warning(f"Model loading (503), will retry (attempt {attempt + 1}/{max_retries + 1})")
+                            last_exception = Exception(f"Model loading (503)")
+                            continue
+                        else:
+                            # After max retries, try fallback model
+                            logger.warning(f"Model loading (503) after {max_retries} retries, trying fallback model")
+                            fallback_config = self._get_fallback_model(task_type)
+                            
+                            # FIXED: Ensure task_type is passed in recursive call
+                            return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
+                    else:
+                        # Non-retryable HTTP errors
+                        logger.error(f"HF API error: {response.status_code} - {response.text}")
+                        return None
+                        
+                except Timeout as e:
+                    last_exception = e
+                    if attempt < max_retries:
+                        logger.warning(f"Request timeout (attempt {attempt + 1}/{max_retries + 1}): {str(e)}")
+                        continue
+                    else:
+                        logger.error(f"Request timeout after {max_retries} retries: {str(e)}")
+                        # Try fallback model on final timeout
+                        logger.warning("Attempting fallback model due to persistent timeout")
+                        fallback_config = self._get_fallback_model(task_type)
+                        return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
+                        
+                except (RequestsConnectionError, RequestException) as e:
+                    last_exception = e
+                    if attempt < max_retries:
+                        logger.warning(f"Connection error (attempt {attempt + 1}/{max_retries + 1}): {str(e)}")
+                        continue
+                    else:
+                        logger.error(f"Connection error after {max_retries} retries: {str(e)}")
+                        # Try fallback model on final connection error
+                        logger.warning("Attempting fallback model due to persistent connection error")
+                        fallback_config = self._get_fallback_model(task_type)
+                        return await self._call_hf_endpoint(fallback_config, prompt, task_type, **kwargs)
+            
+            # If we exhausted all retries and didn't return
+            if last_exception:
+                logger.error(f"Failed after {max_retries} retries. Last error: {last_exception}")
                 return None
                 
         except ImportError:

src/orchestrator_engine.py

@@ -412,20 +412,359 @@ This response has been flagged for potential safety concerns:
     async def _create_execution_plan(self, intent_result: dict, context: dict) -> dict:
         """
         Create execution plan based on intent recognition
+        Maps intent types to specific execution tasks
         """
-        # TODO: Implement agent selection and sequencing logic
-        return {
-            "agents_to_execute": [],
+        primary_intent = intent_result.get('primary_intent', 'casual_conversation')
+        secondary_intents = intent_result.get('secondary_intents', [])
+        confidence = intent_result.get('confidence_scores', {}).get(primary_intent, 0.7)
+        
+        # Map intent types to execution tasks
+        intent_task_mapping = {
+            "information_request": {
+                "tasks": ["information_gathering", "content_research"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "task_execution": {
+                "tasks": ["task_planning", "execution_strategy"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "creative_generation": {
+                "tasks": ["creative_brainstorming", "content_ideation"],
+                "execution_order": "parallel",
+                "priority": "normal"
+            },
+            "analysis_research": {
+                "tasks": ["research_analysis", "data_collection", "pattern_identification"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "troubleshooting": {
+                "tasks": ["problem_analysis", "solution_research"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "education_learning": {
+                "tasks": ["curriculum_planning", "educational_content"],
+                "execution_order": "sequential",
+                "priority": "normal"
+            },
+            "technical_support": {
+                "tasks": ["technical_research", "guidance_generation"],
+                "execution_order": "sequential",
+                "priority": "high"
+            },
+            "casual_conversation": {
+                "tasks": ["context_enrichment"],
+                "execution_order": "parallel",
+                "priority": "low"
+            }
+        }
+        
+        # Get task plan for primary intent
+        plan = intent_task_mapping.get(primary_intent, {
+            "tasks": ["general_research"],
             "execution_order": "parallel",
             "priority": "normal"
+        })
+        
+        # Add secondary intent tasks if confidence is high
+        if confidence > 0.7 and secondary_intents:
+            for secondary_intent in secondary_intents[:2]:  # Limit to 2 secondary intents
+                secondary_plan = intent_task_mapping.get(secondary_intent)
+                if secondary_plan:
+                    # Merge tasks, avoiding duplicates
+                    existing_tasks = set(plan["tasks"])
+                    for task in secondary_plan["tasks"]:
+                        if task not in existing_tasks:
+                            plan["tasks"].append(task)
+                            existing_tasks.add(task)
+        
+        logger.info(f"Execution plan created for intent '{primary_intent}': {len(plan['tasks'])} tasks, order={plan['execution_order']}")
+        
+        return {
+            "agents_to_execute": plan["tasks"],
+            "execution_order": plan["execution_order"],
+            "priority": plan["priority"],
+            "primary_intent": primary_intent,
+            "secondary_intents": secondary_intents
         }
     
     async def _execute_agents(self, execution_plan: dict, user_input: str, context: dict) -> dict:
         """
         Execute agents in parallel or sequential order based on plan
+        Actually executes task-specific LLM calls based on intent
         """
-        # TODO: Implement parallel/sequential agent execution
-        return {}
+        tasks = execution_plan.get("agents_to_execute", [])
+        execution_order = execution_plan.get("execution_order", "parallel")
+        primary_intent = execution_plan.get("primary_intent", "casual_conversation")
+        
+        if not tasks:
+            logger.warning("No tasks to execute in execution plan")
+            return {}
+        
+        logger.info(f"Executing {len(tasks)} tasks in {execution_order} order for intent '{primary_intent}'")
+        
+        results = {}
+        
+        # Build context summary for task execution
+        context_summary = self._build_context_summary(context)
+        
+        # Task prompt templates
+        task_prompts = self._build_task_prompts(user_input, context_summary, primary_intent)
+        
+        if execution_order == "parallel":
+            # Execute all tasks in parallel
+            task_coroutines = []
+            for task in tasks:
+                if task in task_prompts:
+                    coro = self._execute_single_task(task, task_prompts[task])
+                    task_coroutines.append((task, coro))
+                else:
+                    logger.warning(f"No prompt template for task: {task}")
+            
+            # Execute all tasks concurrently
+            if task_coroutines:
+                task_results = await asyncio.gather(
+                    *[coro for _, coro in task_coroutines],
+                    return_exceptions=True
+                )
+                
+                # Map results back to task names
+                for (task, _), result in zip(task_coroutines, task_results):
+                    if isinstance(result, Exception):
+                        logger.error(f"Task {task} failed: {result}")
+                        results[task] = {"error": str(result), "status": "failed"}
+                    else:
+                        results[task] = result
+                        logger.info(f"Task {task} completed: {len(str(result))} chars")
+        else:
+            # Execute tasks sequentially
+            previous_results = {}
+            for task in tasks:
+                if task in task_prompts:
+                    # Pass previous results to sequential tasks for context
+                    enhanced_prompt = task_prompts[task]
+                    if previous_results:
+                        enhanced_prompt += f"\n\nPrevious task results: {str(previous_results)}"
+                    
+                    try:
+                        result = await self._execute_single_task(task, enhanced_prompt)
+                        results[task] = result
+                        previous_results[task] = result
+                        logger.info(f"Task {task} completed: {len(str(result))} chars")
+                    except Exception as e:
+                        logger.error(f"Task {task} failed: {e}")
+                        results[task] = {"error": str(e), "status": "failed"}
+                        previous_results[task] = results[task]
+                else:
+                    logger.warning(f"No prompt template for task: {task}")
+        
+        logger.info(f"Agent execution complete: {len(results)} results collected")
+        return results
+    
+    def _build_context_summary(self, context: dict) -> str:
+        """Build a concise summary of context for task execution"""
+        summary_parts = []
+        
+        # Extract interaction contexts
+        interaction_contexts = context.get('interaction_contexts', [])
+        if interaction_contexts:
+            recent_summaries = [ic.get('summary', '') for ic in interaction_contexts[-3:]]
+            if recent_summaries:
+                summary_parts.append(f"Recent conversation topics: {', '.join(recent_summaries)}")
+        
+        # Extract user context
+        user_context = context.get('user_context', '')
+        if user_context:
+            summary_parts.append(f"User background: {user_context[:200]}")
+        
+        return " | ".join(summary_parts) if summary_parts else "No prior context"
+    
+    def _build_task_prompts(self, user_input: str, context_summary: str, primary_intent: str) -> dict:
+        """Build task-specific prompts for execution"""
+        
+        base_context = f"User Query: {user_input}\nContext: {context_summary}"
+        
+        prompts = {
+            "information_gathering": f"""
+            {base_context}
+            
+            Task: Gather comprehensive, accurate information relevant to the user's query.
+            Focus on facts, definitions, explanations, and verified information.
+            Structure the information clearly and cite key points.
+            """,
+            
+            "content_research": f"""
+            {base_context}
+            
+            Task: Research and compile detailed content about the topic.
+            Include multiple perspectives, current information, and relevant examples.
+            Organize findings logically with clear sections.
+            """,
+            
+            "task_planning": f"""
+            {base_context}
+            
+            Task: Create a detailed execution plan for the requested task.
+            Break down into clear steps, identify requirements, and outline expected outcomes.
+            Consider potential challenges and solutions.
+            """,
+            
+            "execution_strategy": f"""
+            {base_context}
+            
+            Task: Develop a strategic approach for task execution.
+            Define methodology, best practices, and implementation considerations.
+            Provide actionable guidance with clear priorities.
+            """,
+            
+            "creative_brainstorming": f"""
+            {base_context}
+            
+            Task: Generate creative ideas and approaches for content creation.
+            Explore different angles, styles, and formats.
+            Provide diverse creative options with implementation suggestions.
+            """,
+            
+            "content_ideation": f"""
+            {base_context}
+            
+            Task: Develop content concepts and detailed ideation.
+            Create outlines, themes, and structural frameworks.
+            Suggest variations and refinement paths.
+            """,
+            
+            "research_analysis": f"""
+            {base_context}
+            
+            Task: Conduct thorough research analysis on the topic.
+            Identify key findings, trends, patterns, and insights.
+            Analyze different perspectives and methodologies.
+            """,
+            
+            "data_collection": f"""
+            {base_context}
+            
+            Task: Collect and organize relevant data points and evidence.
+            Gather statistics, examples, case studies, and supporting information.
+            Structure data for easy analysis and reference.
+            """,
+            
+            "pattern_identification": f"""
+            {base_context}
+            
+            Task: Identify patterns, correlations, and significant relationships.
+            Analyze trends, cause-effect relationships, and underlying structures.
+            Provide insights based on pattern recognition.
+            """,
+            
+            "problem_analysis": f"""
+            {base_context}
+            
+            Task: Analyze the problem in detail.
+            Identify root causes, contributing factors, and constraints.
+            Break down the problem into components for systematic resolution.
+            """,
+            
+            "solution_research": f"""
+            {base_context}
+            
+            Task: Research and evaluate potential solutions.
+            Compare approaches, assess pros/cons, and recommend best practices.
+            Consider implementation feasibility and effectiveness.
+            """,
+            
+            "curriculum_planning": f"""
+            {base_context}
+            
+            Task: Design educational curriculum and learning path.
+            Structure content progressively, define learning objectives, and suggest resources.
+            Create a comprehensive learning framework.
+            """,
+            
+            "educational_content": f"""
+            {base_context}
+            
+            Task: Generate educational content with clear explanations.
+            Use teaching methods, examples, analogies, and progressive complexity.
+            Make content accessible and engaging for learning.
+            """,
+            
+            "technical_research": f"""
+            {base_context}
+            
+            Task: Research technical aspects and solutions.
+            Gather technical documentation, best practices, and implementation details.
+            Structure technical information clearly with practical guidance.
+            """,
+            
+            "guidance_generation": f"""
+            {base_context}
+            
+            Task: Generate step-by-step guidance and instructions.
+            Create clear, actionable steps with explanations and troubleshooting tips.
+            Ensure guidance is comprehensive and easy to follow.
+            """,
+            
+            "context_enrichment": f"""
+            {base_context}
+            
+            Task: Enrich the conversation with relevant context and insights.
+            Add helpful background information, connections to previous topics, and engaging details.
+            Enhance understanding and engagement.
+            """,
+            
+            "general_research": f"""
+            {base_context}
+            
+            Task: Conduct general research and information gathering.
+            Compile relevant information, insights, and useful details about the topic.
+            Organize findings for clear presentation.
+            """
+        }
+        
+        return prompts
+    
+    async def _execute_single_task(self, task_name: str, prompt: str) -> dict:
+        """Execute a single task using the LLM router"""
+        try:
+            logger.debug(f"Executing task: {task_name}")
+            logger.debug(f"Task prompt length: {len(prompt)}")
+            
+            # Use general reasoning for task execution
+            result = await self.llm_router.route_inference(
+                task_type="general_reasoning",
+                prompt=prompt,
+                max_tokens=2000,
+                temperature=0.7
+            )
+            
+            if result:
+                return {
+                    "task": task_name,
+                    "status": "completed",
+                    "content": result,
+                    "content_length": len(str(result))
+                }
+            else:
+                logger.warning(f"Task {task_name} returned empty result")
+                return {
+                    "task": task_name,
+                    "status": "empty",
+                    "content": "",
+                    "content_length": 0
+                }
+                
+        except Exception as e:
+            logger.error(f"Error executing task {task_name}: {e}", exc_info=True)
+            return {
+                "task": task_name,
+                "status": "error",
+                "error": str(e),
+                "content": ""
+            }
     
     def _format_final_output(self, response: dict, interaction_id: str, additional_metadata: dict = None) -> dict:
         """