Phase 2: Multi-agent implementation complete (#1)

Implemented complete multi-agent system with three specialized agents:

Research Agent:
- Tavily search integration for web research
- Specialized methods for company info, competitors, market trends
- Gathers and formats data from 20+ sources

Analysis Agent:
- SWOT analysis generation
- Competitive matrix creation
- Market positioning analysis
- Strategic recommendations with priority levels

Writer Agent:
- Executive summary generation (200-300 words)
- Full markdown report creation
- Professional formatting with citations
- Metadata tracking

Core Infrastructure:
- BaseAgent class with OpenRouter LLM integration
- Cost tracking for all agent operations
- Tavily search tool wrapper
- Structured prompts for each agent role

Testing:
- 18/18 unit tests passing
- Complete pipeline test successful on real query
- Generated professional report with 28 sources
- Free tier model working (Grok) - /bin/zsh cost

Files Added:
- src/agents/base.py - Base agent class
- src/agents/researcher.py - Research agent
- src/agents/analyst.py - Analysis agent
- src/agents/writer.py - Writer agent
- src/tools/search.py - Tavily search wrapper
- tests/unit/test_base_agent.py - Agent tests
- test_agents.py - Complete pipeline test

Ready for Phase 3: LangGraph workflow orchestration

src/agents/analyst.py

@@ -0,0 +1,313 @@
+"""Analysis Agent for competitive intelligence and SWOT analysis."""
+
+from typing import Any, Dict, List, Optional
+
+from src.agents.base import BaseAgent
+from src.utils.cost_tracker import CostTracker
+from src.utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class AnalysisAgent(BaseAgent):
+    """
+    Analysis Agent responsible for strategic business analysis.
+
+    Takes research data and produces:
+    - SWOT analysis
+    - Competitive matrix
+    - Market positioning analysis
+    - Strategic recommendations
+    """
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        temperature: float = 0.4,  # Balanced for analytical reasoning
+        cost_tracker: Optional[CostTracker] = None,
+    ):
+        """
+        Initialize Analysis Agent.
+
+        Args:
+            model: LLM model to use
+            temperature: Sampling temperature
+            cost_tracker: Cost tracker instance
+        """
+        super().__init__(
+            name="AnalysisAgent",
+            model=model,
+            temperature=temperature,
+            cost_tracker=cost_tracker,
+        )
+
+    def get_system_prompt(self) -> str:
+        """Get system prompt for analysis agent."""
+        return """You are a strategic business analyst specializing in competitive intelligence and market analysis.
+
+Your role is to analyze research data and provide actionable strategic insights.
+
+When performing analysis, you should:
+1. Use structured frameworks (SWOT, competitive matrices, positioning maps)
+2. Identify clear patterns and trends
+3. Provide specific, actionable recommendations
+4. Support conclusions with evidence from the research
+5. Consider multiple perspectives (competitors, customers, market forces)
+
+Your analysis should be:
+- Objective and data-driven
+- Structured and easy to scan
+- Focused on business impact
+- Actionable for decision-makers
+
+Use bullet points, clear headings, and strategic language."""
+
+    async def run(
+        self,
+        research_data: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Perform comprehensive analysis on research data.
+
+        Args:
+            research_data: Output from ResearchAgent containing:
+                - company_overview
+                - competitors
+                - market_trends
+
+        Returns:
+            Dictionary with analysis results:
+                - swot: SWOT analysis
+                - competitive_matrix: Competitor comparison
+                - positioning: Market positioning analysis
+                - strategic_recommendations: Action items
+        """
+        company_name = research_data.get("company_name", "Unknown Company")
+        logger.info(f"Starting analysis for: {company_name}")
+
+        results = {
+            "company_name": company_name,
+            "swot": "",
+            "competitive_matrix": "",
+            "positioning": "",
+            "strategic_recommendations": "",
+        }
+
+        try:
+            # 1. SWOT Analysis
+            swot = await self._perform_swot_analysis(research_data)
+            results["swot"] = swot
+
+            # 2. Competitive Matrix
+            matrix = await self._create_competitive_matrix(research_data)
+            results["competitive_matrix"] = matrix
+
+            # 3. Market Positioning
+            positioning = await self._analyze_market_positioning(research_data)
+            results["positioning"] = positioning
+
+            # 4. Strategic Recommendations
+            recommendations = await self._generate_recommendations(research_data, swot)
+            results["strategic_recommendations"] = recommendations
+
+            logger.info(f"Analysis complete for {company_name}")
+
+            return results
+
+        except Exception as e:
+            logger.error(f"Analysis failed for {company_name}: {e}")
+            raise
+
+    async def _perform_swot_analysis(
+        self,
+        research_data: Dict[str, Any],
+    ) -> str:
+        """
+        Generate SWOT analysis from research data.
+
+        Args:
+            research_data: Research results
+
+        Returns:
+            SWOT analysis text
+        """
+        company_name = research_data.get("company_name")
+        company_overview = research_data.get("company_overview", "")
+        competitors = research_data.get("competitors", "")
+        market_trends = research_data.get("market_trends", "")
+
+        user_message = f"""Based on the research data, perform a comprehensive SWOT analysis for {company_name}.
+
+Research Data:
+
+COMPANY OVERVIEW:
+{company_overview}
+
+COMPETITORS:
+{competitors}
+
+MARKET TRENDS:
+{market_trends}
+
+Provide a detailed SWOT analysis with:
+
+STRENGTHS (internal positive factors):
+- List 4-6 key strengths
+- Focus on competitive advantages, resources, capabilities
+
+WEAKNESSES (internal negative factors):
+- List 4-6 key weaknesses
+- Include operational limits, resource constraints, vulnerabilities
+
+OPPORTUNITIES (external positive factors):
+- List 4-6 market opportunities
+- Consider market trends, gaps, emerging needs
+
+THREATS (external negative factors):
+- List 4-6 threats
+- Include competitive threats, market risks, industry challenges
+
+Use bullet points and be specific with evidence."""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response
+
+    async def _create_competitive_matrix(
+        self,
+        research_data: Dict[str, Any],
+    ) -> str:
+        """
+        Create competitive comparison matrix.
+
+        Args:
+            research_data: Research results
+
+        Returns:
+            Competitive matrix as formatted text
+        """
+        company_name = research_data.get("company_name")
+        competitors_info = research_data.get("competitors", "")
+
+        user_message = f"""Based on the competitor research, create a competitive matrix comparing {company_name} with its main competitors.
+
+Competitor Research:
+{competitors_info}
+
+Create a comparison matrix with these dimensions:
+1. Market Share/Size
+2. Product Range
+3. Pricing Strategy
+4. Technology/Innovation
+5. Customer Segments
+6. Strengths
+7. Weaknesses
+
+Format as a clear table or structured comparison.
+Include 3-5 main competitors plus {company_name}.
+Use "High/Medium/Low" or specific data points where available."""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response
+
+    async def _analyze_market_positioning(
+        self,
+        research_data: Dict[str, Any],
+    ) -> str:
+        """
+        Analyze market positioning strategy.
+
+        Args:
+            research_data: Research results
+
+        Returns:
+            Positioning analysis
+        """
+        company_name = research_data.get("company_name")
+        company_overview = research_data.get("company_overview", "")
+        competitors = research_data.get("competitors", "")
+
+        user_message = f"""Analyze the market positioning of {company_name}.
+
+Company Overview:
+{company_overview}
+
+Competitive Landscape:
+{competitors}
+
+Provide analysis covering:
+
+1. CURRENT POSITIONING
+   - How is {company_name} currently positioned in the market?
+   - What is their value proposition?
+   - What customer segments do they target?
+
+2. COMPETITIVE DIFFERENTIATION
+   - What makes {company_name} different from competitors?
+   - What is their unique selling proposition (USP)?
+   - Where do they fit in the competitive landscape?
+
+3. POSITIONING GAPS
+   - Are there market segments they're missing?
+   - Are there positioning opportunities?
+   - How could they strengthen their position?
+
+Be specific and strategic."""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response
+
+    async def _generate_recommendations(
+        self,
+        research_data: Dict[str, Any],
+        swot: str,
+    ) -> str:
+        """
+        Generate strategic recommendations.
+
+        Args:
+            research_data: Research results
+            swot: SWOT analysis
+
+        Returns:
+            Strategic recommendations
+        """
+        company_name = research_data.get("company_name")
+        market_trends = research_data.get("market_trends", "")
+
+        user_message = f"""Based on the SWOT analysis and market trends, provide strategic recommendations for {company_name}.
+
+SWOT ANALYSIS:
+{swot}
+
+MARKET TRENDS:
+{market_trends}
+
+Provide 5-7 actionable strategic recommendations organized by priority:
+
+HIGH PRIORITY (immediate action needed):
+- Recommendation 1 (with rationale)
+- Recommendation 2 (with rationale)
+
+MEDIUM PRIORITY (next 6-12 months):
+- Recommendation 3 (with rationale)
+- Recommendation 4 (with rationale)
+
+LONG-TERM (strategic initiatives):
+- Recommendation 5 (with rationale)
+
+Each recommendation should:
+- Be specific and actionable
+- Address a key opportunity or threat
+- Leverage strengths or address weaknesses
+- Include expected impact"""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response

src/agents/base.py

@@ -0,0 +1,156 @@
+"""Base agent class for all agents in the system."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+
+from src.utils.config import get_settings
+from src.utils.cost_tracker import CostTracker
+from src.utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class BaseAgent(ABC):
+    """
+    Base class for all agents in the multi-agent system.
+
+    Provides common functionality for LLM interaction, cost tracking,
+    and error handling.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        model: Optional[str] = None,
+        temperature: float = 0.7,
+        cost_tracker: Optional[CostTracker] = None,
+    ):
+        """
+        Initialize base agent.
+
+        Args:
+            name: Agent name for logging
+            model: LLM model to use (defaults to config default)
+            temperature: LLM sampling temperature (0-1)
+            cost_tracker: Optional cost tracker instance
+        """
+        self.name = name
+        self.cost_tracker = cost_tracker or CostTracker()
+
+        settings = get_settings()
+        self.model_name = model or settings.default_model
+
+        # Initialize LLM via OpenRouter
+        self.llm = ChatOpenAI(
+            model=self.model_name,
+            temperature=temperature,
+            openai_api_key=settings.openrouter_api_key,
+            openai_api_base=settings.openrouter_base_url,
+        )
+
+        logger.info(f"Initialized {name} with model {self.model_name}")
+
+    @abstractmethod
+    def get_system_prompt(self) -> str:
+        """
+        Get the system prompt for this agent.
+
+        Returns:
+            System prompt string
+        """
+        pass
+
+    @abstractmethod
+    async def run(self, **kwargs) -> Dict[str, Any]:
+        """
+        Execute the agent's main task.
+
+        Args:
+            **kwargs: Agent-specific parameters
+
+        Returns:
+            Dictionary with results
+        """
+        pass
+
+    async def _invoke_llm(
+        self,
+        messages: list[BaseMessage],
+        **llm_kwargs,
+    ) -> str:
+        """
+        Invoke LLM and track costs.
+
+        Args:
+            messages: List of messages to send
+            **llm_kwargs: Additional LLM parameters
+
+        Returns:
+            LLM response text
+        """
+        try:
+            response = await self.llm.ainvoke(messages, **llm_kwargs)
+
+            # Track usage if available
+            if hasattr(response, "response_metadata"):
+                usage = response.response_metadata.get("usage", {})
+                if usage:
+                    self.cost_tracker.track_usage(
+                        model=self.model_name,
+                        input_tokens=usage.get("prompt_tokens", 0),
+                        output_tokens=usage.get("completion_tokens", 0),
+                    )
+
+            logger.info(
+                f"{self.name} LLM call complete",
+                extra={
+                    "extra_fields": {
+                        "model": self.model_name,
+                        "total_cost": self.cost_tracker.total_cost,
+                    }
+                },
+            )
+
+            return response.content
+
+        except Exception as e:
+            logger.error(f"{self.name} LLM call failed: {e}")
+            raise
+
+    def _create_messages(
+        self,
+        user_message: str,
+        system_prompt: Optional[str] = None,
+    ) -> list[BaseMessage]:
+        """
+        Create message list for LLM.
+
+        Args:
+            user_message: User message content
+            system_prompt: Optional system prompt (uses default if None)
+
+        Returns:
+            List of messages
+        """
+        messages = []
+
+        # Add system message
+        prompt = system_prompt or self.get_system_prompt()
+        messages.append(SystemMessage(content=prompt))
+
+        # Add user message
+        messages.append(HumanMessage(content=user_message))
+
+        return messages
+
+    def get_cost_summary(self) -> Dict[str, Any]:
+        """
+        Get cost summary for this agent's operations.
+
+        Returns:
+            Cost summary dictionary
+        """
+        return self.cost_tracker.get_summary()

src/agents/researcher.py

@@ -0,0 +1,250 @@
+"""Research Agent for gathering market intelligence data."""
+
+from typing import Any, Dict, Optional
+
+from src.agents.base import BaseAgent
+from src.tools.search import TavilySearchTool
+from src.utils.cost_tracker import CostTracker
+from src.utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ResearchAgent(BaseAgent):
+    """
+    Research Agent responsible for gathering data from web sources.
+
+    Uses Tavily API for web search and can gather:
+    - Company information
+    - Competitor analysis data
+    - Market trends and insights
+    - Industry news
+    """
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        temperature: float = 0.3,  # Lower for more factual responses
+        cost_tracker: Optional[CostTracker] = None,
+    ):
+        """
+        Initialize Research Agent.
+
+        Args:
+            model: LLM model to use
+            temperature: Sampling temperature (lower for research)
+            cost_tracker: Cost tracker instance
+        """
+        super().__init__(
+            name="ResearchAgent",
+            model=model,
+            temperature=temperature,
+            cost_tracker=cost_tracker,
+        )
+
+        self.search_tool = TavilySearchTool()
+
+    def get_system_prompt(self) -> str:
+        """Get system prompt for research agent."""
+        return """You are a professional business research analyst specializing in competitive intelligence.
+
+Your role is to gather and synthesize information about companies, markets, and competitors from web sources.
+
+When analyzing search results, you should:
+1. Focus on factual, verifiable information
+2. Identify key data points: revenue, employees, products, market position
+3. Note dates and sources for important claims
+4. Distinguish between facts and opinions
+5. Highlight competitive advantages and weaknesses
+
+Provide your analysis in a structured format with clear sections and bullet points.
+Always cite sources when making specific claims."""
+
+    async def run(
+        self,
+        company_name: str,
+        industry: Optional[str] = None,
+        research_depth: str = "comprehensive",
+    ) -> Dict[str, Any]:
+        """
+        Gather research data about a company.
+
+        Args:
+            company_name: Target company name
+            industry: Optional industry context
+            research_depth: "basic" or "comprehensive"
+
+        Returns:
+            Dictionary with research results:
+                - company_overview: Company information
+                - competitors: Competitor analysis
+                - market_trends: Industry trends
+                - raw_sources: List of sources used
+        """
+        logger.info(f"Starting research for: {company_name}")
+
+        results = {
+            "company_name": company_name,
+            "industry": industry,
+            "company_overview": "",
+            "competitors": "",
+            "market_trends": "",
+            "raw_sources": [],
+        }
+
+        try:
+            # 1. Company Overview
+            company_data = await self.search_tool.get_company_info(
+                company_name=company_name,
+                max_results=10 if research_depth == "comprehensive" else 5,
+            )
+
+            results["raw_sources"].extend(company_data.get("results", []))
+
+            # Analyze company data with LLM
+            company_context = self.search_tool.format_results_for_llm(company_data)
+            company_analysis = await self._analyze_company(
+                company_name, company_context
+            )
+            results["company_overview"] = company_analysis
+
+            # 2. Competitor Analysis
+            competitor_data = await self.search_tool.get_competitor_info(
+                company_name=company_name,
+                industry=industry,
+                max_results=10 if research_depth == "comprehensive" else 5,
+            )
+
+            results["raw_sources"].extend(competitor_data.get("results", []))
+
+            competitor_context = self.search_tool.format_results_for_llm(
+                competitor_data
+            )
+            competitor_analysis = await self._analyze_competitors(
+                company_name, competitor_context
+            )
+            results["competitors"] = competitor_analysis
+
+            # 3. Market Trends (if industry provided)
+            if industry:
+                trend_data = await self.search_tool.get_market_trends(
+                    industry=industry,
+                    max_results=8 if research_depth == "comprehensive" else 4,
+                )
+
+                results["raw_sources"].extend(trend_data.get("results", []))
+
+                trend_context = self.search_tool.format_results_for_llm(trend_data)
+                trend_analysis = await self._analyze_trends(industry, trend_context)
+                results["market_trends"] = trend_analysis
+
+            logger.info(
+                f"Research complete for {company_name}. "
+                f"Processed {len(results['raw_sources'])} sources"
+            )
+
+            return results
+
+        except Exception as e:
+            logger.error(f"Research failed for {company_name}: {e}")
+            raise
+
+    async def _analyze_company(
+        self,
+        company_name: str,
+        search_context: str,
+    ) -> str:
+        """
+        Analyze company information from search results.
+
+        Args:
+            company_name: Company name
+            search_context: Formatted search results
+
+        Returns:
+            Structured company analysis
+        """
+        user_message = f"""Analyze the following search results about {company_name}.
+
+Provide a structured analysis covering:
+1. Company Overview (founded, headquarters, size)
+2. Products & Services (main offerings)
+3. Business Model (how they make money)
+4. Market Position (market share, ranking)
+5. Key Metrics (revenue, employees, growth)
+
+Search Results:
+{search_context}
+
+Provide your analysis in clear sections with bullet points. Cite sources for specific claims."""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response
+
+    async def _analyze_competitors(
+        self,
+        company_name: str,
+        search_context: str,
+    ) -> str:
+        """
+        Analyze competitor landscape.
+
+        Args:
+            company_name: Target company
+            search_context: Formatted search results
+
+        Returns:
+            Competitor analysis
+        """
+        user_message = f"""Analyze the competitive landscape for {company_name}.
+
+Based on the search results, identify:
+1. Main Competitors (list 3-5 key competitors)
+2. Competitive Positioning (how each differs)
+3. Market Dynamics (who leads, who follows)
+4. Differentiation Factors (what makes each unique)
+
+Search Results:
+{search_context}
+
+Format as a structured list with clear comparisons."""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response
+
+    async def _analyze_trends(
+        self,
+        industry: str,
+        search_context: str,
+    ) -> str:
+        """
+        Analyze market trends.
+
+        Args:
+            industry: Industry name
+            search_context: Formatted search results
+
+        Returns:
+            Trend analysis
+        """
+        user_message = f"""Analyze market trends for the {industry} industry.
+
+Identify:
+1. Key Trends (major shifts in the market)
+2. Growth Drivers (what's fueling growth)
+3. Challenges (obstacles facing the industry)
+4. Future Outlook (predictions for next 1-2 years)
+
+Search Results:
+{search_context}
+
+Provide analysis with clear trends and supporting evidence."""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response

src/agents/writer.py

@@ -0,0 +1,251 @@
+"""Writer Agent for generating professional market intelligence reports."""
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from src.agents.base import BaseAgent
+from src.utils.cost_tracker import CostTracker
+from src.utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class WriterAgent(BaseAgent):
+    """
+    Writer Agent responsible for generating final reports.
+
+    Takes research and analysis data and creates:
+    - Executive summary
+    - Comprehensive market intelligence report
+    - Properly formatted markdown with citations
+    """
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        temperature: float = 0.6,  # Higher for better writing quality
+        cost_tracker: Optional[CostTracker] = None,
+    ):
+        """
+        Initialize Writer Agent.
+
+        Args:
+            model: LLM model to use
+            temperature: Sampling temperature
+            cost_tracker: Cost tracker instance
+        """
+        super().__init__(
+            name="WriterAgent",
+            model=model,
+            temperature=temperature,
+            cost_tracker=cost_tracker,
+        )
+
+    def get_system_prompt(self) -> str:
+        """Get system prompt for writer agent."""
+        return """You are a professional business report writer specializing in market intelligence and competitive analysis.
+
+Your role is to transform research and analysis into polished, executive-ready reports.
+
+When writing reports, you should:
+1. Use clear, professional business language
+2. Structure content logically with proper headings
+3. Include executive summaries for busy stakeholders
+4. Use bullet points and tables for scannability
+5. Cite sources properly
+6. Make insights actionable
+
+Report format guidelines:
+- Use markdown formatting
+- Include clear section headers (#, ##, ###)
+- Use tables for competitive comparisons
+- Include bullet points for lists
+- Add citations [source]
+- Keep executive summary to 200-300 words
+
+Write for senior executives and decision-makers."""
+
+    async def run(
+        self,
+        research_data: Dict[str, Any],
+        analysis_data: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Generate comprehensive market intelligence report.
+
+        Args:
+            research_data: Output from ResearchAgent
+            analysis_data: Output from AnalysisAgent
+
+        Returns:
+            Dictionary with report components:
+                - executive_summary: Brief overview
+                - full_report: Complete markdown report
+                - metadata: Report metadata (date, sources count, etc.)
+        """
+        company_name = research_data.get("company_name", "Unknown Company")
+        logger.info(f"Starting report generation for: {company_name}")
+
+        try:
+            # Generate report sections
+            exec_summary = await self._write_executive_summary(
+                research_data, analysis_data
+            )
+
+            full_report = await self._write_full_report(
+                research_data, analysis_data, exec_summary
+            )
+
+            # Gather metadata
+            metadata = {
+                "company_name": company_name,
+                "industry": research_data.get("industry"),
+                "generated_date": datetime.now().isoformat(),
+                "sources_count": len(research_data.get("raw_sources", [])),
+                "model_used": self.model_name,
+            }
+
+            logger.info(f"Report generation complete for {company_name}")
+
+            return {
+                "executive_summary": exec_summary,
+                "full_report": full_report,
+                "metadata": metadata,
+            }
+
+        except Exception as e:
+            logger.error(f"Report generation failed for {company_name}: {e}")
+            raise
+
+    async def _write_executive_summary(
+        self,
+        research_data: Dict[str, Any],
+        analysis_data: Dict[str, Any],
+    ) -> str:
+        """
+        Write executive summary (200-300 words).
+
+        Args:
+            research_data: Research results
+            analysis_data: Analysis results
+
+        Returns:
+            Executive summary text
+        """
+        company_name = research_data.get("company_name")
+
+        user_message = f"""Write a concise executive summary for a market intelligence report on {company_name}.
+
+Use this information:
+
+COMPANY OVERVIEW:
+{research_data.get("company_overview", "")}
+
+KEY INSIGHTS FROM SWOT:
+{analysis_data.get("swot", "")}
+
+STRATEGIC RECOMMENDATIONS:
+{analysis_data.get("strategic_recommendations", "")}
+
+Requirements:
+- 200-300 words
+- Cover: company overview, market position, key findings, main recommendations
+- Written for senior executives (clear, actionable)
+- Professional business tone
+
+Start directly with content (no "Executive Summary" heading)."""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response
+
+    async def _write_full_report(
+        self,
+        research_data: Dict[str, Any],
+        analysis_data: Dict[str, Any],
+        exec_summary: str,
+    ) -> str:
+        """
+        Write complete markdown report.
+
+        Args:
+            research_data: Research results
+            analysis_data: Analysis results
+            exec_summary: Executive summary
+
+        Returns:
+            Full report in markdown format
+        """
+        company_name = research_data.get("company_name")
+        industry = research_data.get("industry") or "Market"
+
+        # Build comprehensive context
+        context = f"""
+COMPANY: {company_name}
+INDUSTRY: {industry}
+
+RESEARCH DATA:
+Company Overview: {research_data.get("company_overview", "")}
+Competitors: {research_data.get("competitors", "")}
+Market Trends: {research_data.get("market_trends", "")}
+
+ANALYSIS DATA:
+SWOT: {analysis_data.get("swot", "")}
+Competitive Matrix: {analysis_data.get("competitive_matrix", "")}
+Market Positioning: {analysis_data.get("positioning", "")}
+Strategic Recommendations: {analysis_data.get("strategic_recommendations", "")}
+
+EXECUTIVE SUMMARY:
+{exec_summary}
+"""
+
+        user_message = f"""Create a comprehensive market intelligence report for {company_name} in markdown format.
+
+Use all the provided research and analysis data.
+
+Structure the report as follows:
+
+# Market Intelligence Report: {company_name}
+
+## Executive Summary
+[Insert the provided executive summary]
+
+## 1. Company Overview
+[Detailed company information from research]
+
+## 2. Competitive Landscape
+[Competitor analysis and competitive matrix]
+
+## 3. SWOT Analysis
+[Detailed SWOT with clear sections: Strengths, Weaknesses, Opportunities, Threats]
+
+## 4. Market Positioning
+[Positioning analysis and differentiation]
+
+## 5. Market Trends & Insights
+[Industry trends and market dynamics]
+
+## 6. Strategic Recommendations
+[Prioritized recommendations with rationale]
+
+## 7. Sources
+[List key sources used]
+
+---
+Report generated: {datetime.now().strftime("%B %d, %Y")}
+
+Data to use:
+{context}
+
+Format requirements:
+- Use proper markdown (headers, bullets, tables)
+- Make it professional and polished
+- Include all relevant details
+- Cite sources where appropriate
+- Make it actionable for executives"""
+
+        messages = self._create_messages(user_message)
+        response = await self._invoke_llm(messages)
+
+        return response

src/tools/search.py

@@ -0,0 +1,217 @@
+"""Search tools for web research using Tavily API."""
+
+from typing import Dict, List, Optional
+
+from tavily import TavilyClient
+
+from src.utils.config import get_settings
+from src.utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class TavilySearchTool:
+    """
+    Wrapper for Tavily search API optimized for research agents.
+
+    Tavily is designed for AI agents and provides clean, structured
+    results ideal for LLM consumption.
+    """
+
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        Initialize Tavily search tool.
+
+        Args:
+            api_key: Optional Tavily API key (uses config if None)
+        """
+        settings = get_settings()
+        self.api_key = api_key or settings.tavily_api_key
+        self.client = TavilyClient(api_key=self.api_key)
+
+        logger.info("Tavily search tool initialized")
+
+    async def search(
+        self,
+        query: str,
+        max_results: int = 5,
+        search_depth: str = "advanced",
+        include_domains: Optional[List[str]] = None,
+        exclude_domains: Optional[List[str]] = None,
+    ) -> Dict:
+        """
+        Perform web search using Tavily.
+
+        Args:
+            query: Search query
+            max_results: Maximum number of results to return
+            search_depth: "basic" or "advanced" (advanced is more comprehensive)
+            include_domains: Optional list of domains to include
+            exclude_domains: Optional list of domains to exclude
+
+        Returns:
+            Dictionary with search results:
+                - results: List of search results
+                - query: Original query
+                - answer: Tavily's AI-generated answer (if available)
+        """
+        try:
+            logger.info(f"Tavily search: {query}")
+
+            response = self.client.search(
+                query=query,
+                max_results=max_results,
+                search_depth=search_depth,
+                include_domains=include_domains,
+                exclude_domains=exclude_domains,
+            )
+
+            logger.info(f"Tavily returned {len(response.get('results', []))} results")
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Tavily search failed: {e}")
+            raise
+
+    async def get_company_info(
+        self,
+        company_name: str,
+        max_results: int = 10,
+    ) -> Dict:
+        """
+        Get comprehensive company information.
+
+        Args:
+            company_name: Company name to research
+            max_results: Maximum results to retrieve
+
+        Returns:
+            Search results focused on company information
+        """
+        query = f"{company_name} company overview products services business model"
+        return await self.search(
+            query=query,
+            max_results=max_results,
+            search_depth="advanced",
+        )
+
+    async def get_competitor_info(
+        self,
+        company_name: str,
+        industry: Optional[str] = None,
+        max_results: int = 10,
+    ) -> Dict:
+        """
+        Find competitors for a given company.
+
+        Args:
+            company_name: Company name
+            industry: Optional industry context
+            max_results: Maximum results
+
+        Returns:
+            Search results about competitors
+        """
+        industry_context = f"in {industry}" if industry else ""
+        query = f"{company_name} competitors alternatives {industry_context}"
+
+        return await self.search(
+            query=query,
+            max_results=max_results,
+            search_depth="advanced",
+        )
+
+    async def get_market_trends(
+        self,
+        industry: str,
+        year: Optional[str] = "2025",
+        max_results: int = 8,
+    ) -> Dict:
+        """
+        Get market trends for an industry.
+
+        Args:
+            industry: Industry name
+            year: Year for trends (default: 2025)
+            max_results: Maximum results
+
+        Returns:
+            Search results about market trends
+        """
+        query = f"{industry} market trends {year} growth forecast opportunities"
+
+        return await self.search(
+            query=query,
+            max_results=max_results,
+            search_depth="advanced",
+        )
+
+    def format_results_for_llm(self, search_response: Dict) -> str:
+        """
+        Format search results for LLM consumption.
+
+        Args:
+            search_response: Tavily search response
+
+        Returns:
+            Formatted string with search results
+        """
+        results = search_response.get("results", [])
+
+        if not results:
+            return "No search results found."
+
+        formatted = []
+        for i, result in enumerate(results, 1):
+            title = result.get("title", "No title")
+            url = result.get("url", "")
+            content = result.get("content", "No content")
+            score = result.get("score", 0)
+
+            formatted.append(
+                f"[{i}] {title}\n"
+                f"URL: {url}\n"
+                f"Relevance: {score:.2f}\n"
+                f"Content: {content}\n"
+            )
+
+        # Add AI answer if available
+        if answer := search_response.get("answer"):
+            formatted.insert(0, f"AI Summary: {answer}\n\n")
+
+        return "\n".join(formatted)
+
+
+class WikipediaSearchTool:
+    """
+    Wikipedia search for factual company/product information.
+
+    Note: This is a simple wrapper. For production, consider using
+    the wikipedia-api library for more robust access.
+    """
+
+    def __init__(self):
+        """Initialize Wikipedia search tool."""
+        logger.info("Wikipedia search tool initialized")
+
+    async def search(self, query: str, max_results: int = 3) -> Dict:
+        """
+        Search Wikipedia (placeholder for now).
+
+        Args:
+            query: Search query
+            max_results: Maximum results
+
+        Returns:
+            Search results dictionary
+        """
+        # TODO: Implement actual Wikipedia API integration
+        # For now, we'll use Tavily which can search Wikipedia
+        logger.info(f"Wikipedia search: {query}")
+
+        return {
+            "query": query,
+            "results": [],
+            "note": "Wikipedia integration pending - using Tavily for now",
+        }

test_agents.py

@@ -0,0 +1,133 @@
+"""
+Test script to run agents manually on a real query.
+
+This demonstrates the agent pipeline without LangGraph orchestration.
+"""
+
+import asyncio
+import sys
+
+from src.agents.researcher import ResearchAgent
+from src.agents.analyst import AnalysisAgent
+from src.agents.writer import WriterAgent
+from src.utils.cost_tracker import CostTracker
+
+
+async def test_complete_pipeline():
+    """Test the complete agent pipeline."""
+
+    # Query from user
+    query = "going viral on Instagram using AI without showing face"
+    industry = "Social Media Marketing"
+
+    print("=" * 80)
+    print(f"TESTING AGENT PIPELINE")
+    print(f"Query: {query}")
+    print(f"Industry: {industry}")
+    print("=" * 80)
+    print()
+
+    # Shared cost tracker
+    cost_tracker = CostTracker()
+
+    try:
+        # Step 1: Research Agent
+        print("\n[STEP 1] Running Research Agent...")
+        print("-" * 80)
+        researcher = ResearchAgent(cost_tracker=cost_tracker)
+
+        research_results = await researcher.run(
+            company_name=query, industry=industry, research_depth="comprehensive"
+        )
+
+        print(f"\nResearch completed!")
+        print(f"Sources gathered: {len(research_results.get('raw_sources', []))}")
+        print(f"\nCompany Overview (first 500 chars):")
+        print(research_results["company_overview"][:500] + "...")
+
+        # Step 2: Analysis Agent
+        print("\n\n[STEP 2] Running Analysis Agent...")
+        print("-" * 80)
+        analyst = AnalysisAgent(cost_tracker=cost_tracker)
+
+        analysis_results = await analyst.run(research_data=research_results)
+
+        print(f"\nAnalysis completed!")
+        print(f"\nSWOT Analysis (first 500 chars):")
+        print(analysis_results["swot"][:500] + "...")
+
+        # Step 3: Writer Agent
+        print("\n\n[STEP 3] Running Writer Agent...")
+        print("-" * 80)
+        writer = WriterAgent(cost_tracker=cost_tracker)
+
+        report_results = await writer.run(
+            research_data=research_results, analysis_data=analysis_results
+        )
+
+        print(f"\nReport generation completed!")
+
+        # Display results
+        print("\n\n" + "=" * 80)
+        print("EXECUTIVE SUMMARY")
+        print("=" * 80)
+        print(report_results["executive_summary"])
+
+        print("\n\n" + "=" * 80)
+        print("FULL REPORT")
+        print("=" * 80)
+        print(report_results["full_report"])
+
+        # Cost summary
+        print("\n\n" + "=" * 80)
+        print("COST SUMMARY")
+        print("=" * 80)
+        summary = cost_tracker.get_summary()
+        print(f"Total Cost: ${summary['total_cost']:.4f}")
+        print(f"Total Tokens: {summary['total_tokens']:,}")
+        print(f"API Calls: {summary['calls']}")
+        print(f"\nBreakdown by model:")
+        for model, data in summary["by_model"].items():
+            print(f"  {model}:")
+            print(f"    Input: {data['input_tokens']:,} tokens")
+            print(f"    Output: {data['output_tokens']:,} tokens")
+            print(f"    Cost: ${data['cost']:.4f}")
+
+        # Save report
+        output_file = "test_report.md"
+        with open(output_file, "w") as f:
+            f.write(f"# Market Intelligence Report\n\n")
+            f.write(f"**Query:** {query}\n\n")
+            f.write(f"**Industry:** {industry}\n\n")
+            f.write(f"---\n\n")
+            f.write(f"## Executive Summary\n\n")
+            f.write(report_results["executive_summary"])
+            f.write(f"\n\n---\n\n")
+            f.write(report_results["full_report"])
+            f.write(f"\n\n---\n\n")
+            f.write(f"**Total Cost:** ${summary['total_cost']:.4f}\n")
+
+        print(f"\n\nReport saved to: {output_file}")
+
+        return True
+
+    except Exception as e:
+        print(f"\n\nERROR: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    print("\nStarting agent test...")
+    print("Make sure you have .env file with API keys set up!\n")
+
+    result = asyncio.run(test_complete_pipeline())
+
+    if result:
+        print("\n\nTest PASSED!")
+        sys.exit(0)
+    else:
+        print("\n\nTest FAILED!")
+        sys.exit(1)

test_report.md

@@ -0,0 +1,205 @@
+# Market Intelligence Report
+
+**Query:** going viral on Instagram using AI without showing face
+
+**Industry:** Social Media Marketing
+
+---
+
+## Executive Summary
+
+This executive summary outlines the market intelligence on leveraging AI tools for faceless Instagram content to achieve virality, targeting rapid growth in short-form video amid a $32.55B influencer market (57.1% Instagram share) [4].
+
+**Key Players and Landscape**: Leading SaaS tools include Invideo AI (text-to-Reel generation in ~20 minutes), Virlo (faceless workflows with Leonardo.ai/Eleven Labs integrations), and Zebracat (viral niches like pet videos/AI art). Supporting platforms: TailorTalk (DM automation), Madgicx (trend forecasting), Juicer (content/engagement AI). AI influencers like Lil Miquela (3M+ followers) exemplify success via brand deals [1][2][3][9].
+
+**Market Position**: Faceless AI content commands premium engagement—5% for AI art (vs. 2% Instagram average), 3% uplift over humans—driven by scalability, 24/7 operation, and low risks. High-growth niche amid 93% marketer video spend increase ($140B in 2025), but faces authenticity gaps and saturation [3][9].
+
+**Key Findings (SWOT Highlights)**: **Strengths**: Rapid production, superior metrics, multi-platform repurposing. **Weaknesses**: AI fatigue, tool dependency. **Opportunities**: Social commerce ($2.9T by 2026), niche virality. **Threats**: Consumer distrust (50% pullback), algorithm volatility [1-10].
+
+**Strategic Recommendations** (Prioritized for Execution):
+- **Immediate (0-3 Months)**: Deploy workflows in 2-3 niches (e.g., pet motivation) for 5-10 Reels/week; automate outbound engagement for 3-5x reach, targeting 10K followers [1][3][6].
+- **Medium (6-12 Months)**: Blend UGC (30%) for authenticity; launch Instagram Shops/affiliates for $10K+ quarterly revenue [2][4].
+- **Long-Term**: Cross-post to TikTok/YouTube; build proprietary prompts for 1M+ followers, 7% engagement [5][6].
+
+Actionable path: Start with Invideo/Z zebracat pilots to capture first-mover edges, mitigating risks for scalable, passive income. (248 words)
+
+---
+
+# Market Intelligence Report: Going Viral on Instagram Using AI Without Showing Face
+
+## Executive Summary
+This executive summary outlines the market intelligence on leveraging AI tools for faceless Instagram content to achieve virality, targeting rapid growth in short-form video amid a $32.55B influencer market (57.1% Instagram share) [4].
+
+**Key Players and Landscape**: Leading SaaS tools include Invideo AI (text-to-Reel generation in ~20 minutes), Virlo (faceless workflows with Leonardo.ai/Eleven Labs integrations), and Zebracat (viral niches like pet videos/AI art). Supporting platforms: TailorTalk (DM automation), Madgicx (trend forecasting), Juicer (content/engagement AI). AI influencers like Lil Miquela (3M+ followers) exemplify success via brand deals [1][2][3][9].
+
+**Market Position**: Faceless AI content commands premium engagement—5% for AI art (vs. 2% Instagram average), 3% uplift over humans—driven by scalability, 24/7 operation, and low risks. High-growth niche amid 93% marketer video spend increase ($140B in 2025), but faces authenticity gaps and saturation [3][9].
+
+**Key Findings (SWOT Highlights)**: **Strengths**: Rapid production, superior metrics, multi-platform repurposing. **Weaknesses**: AI fatigue, tool dependency. **Opportunities**: Social commerce ($2.9T by 2026), niche virality. **Threats**: Consumer distrust (50% pullback), algorithm volatility [1-10].
+
+**Strategic Recommendations** (Prioritized for Execution):
+- **Immediate (0-3 Months)**: Deploy workflows in 2-3 niches (e.g., pet motivation) for 5-10 Reels/week; automate outbound engagement for 3-5x reach, targeting 10K followers [1][3][6].
+- **Medium (6-12 Months)**: Blend UGC (30%) for authenticity; launch Instagram Shops/affiliates for $10K+ quarterly revenue [2][4].
+- **Long-Term**: Cross-post to TikTok/YouTube; build proprietary prompts for 1M+ followers, 7% engagement [5][6].
+
+Actionable path: Start with Invideo/Zebracat pilots to capture first-mover edges, mitigating risks for scalable, passive income. (248 words)
+
+## 1. Company Overview
+"Going Viral on Instagram Using AI Without Showing Face" represents an emerging strategy and ecosystem in the social media marketing industry, leveraging AI-powered SaaS tools to create scalable, anonymous content (e.g., Reels, AI art, videos) for virality and monetization. No formal company structure (e.g., founding date, headquarters, employee count) is established, as it is a niche approach powered by specialized platforms rather than a single entity [1][2][3].
+
+### Key Offerings (Products & Services)
+- **Invideo AI**: Generates faceless Instagram Reels from text prompts in ~20 minutes; supports monetization via digital products, affiliates, and brand partnerships [1].
+- **Virlo**: AI workflows for faceless accounts, integrating Leonardo.ai (imagery), Eleven Labs (voice-overs), and Flarecut (video transformation); enables Instagram Shop setup for merchandise [2].
+- **Zebracat**: AI video generator for viral faceless niches (e.g., pets, AI art, study-with-me, PowerPoint tutorials); focuses on psychological virality triggers [3].
+- Supporting tools: TailorTalk (Instagram automation for DMs/comments), Madgicx (audience growth/trend forecasting), Juicer (content creation/engagement), Copy.ai (copywriting), Descript (editing), Mentionlytics (social listening) [5][6][7][8].
+
+### Business Model
+- Primarily SaaS/subscription-based for tools (e.g., Invideo AI, Zebracat sign-ups) [1][3].
+- Monetization strategies: Digital products (spreadsheets, courses), affiliates, brand deals (e.g., AI influencers like Aitana Lopez with Fenty Beauty), Instagram Shops, AdSense [1][2][4][9].
+- Enables 24/7 scalable engagement for passive income without human limitations [4][9].
+
+### Market Position and Key Metrics
+- Niche high-growth positioning: Faceless AI art achieves ~5% engagement (vs. Instagram 2% average); AI influencers yield 3% higher engagement than humans [3][9].
+- Examples: Lil Miquela (3M+ followers); Zebracat cases (509K followers, millions of views) [3][9].
+- Growth drivers: Efficiency, multi-platform repurposing, no reputational risks [1][2][3].
+
+## 2. Competitive Landscape
+The competitive landscape for AI-driven faceless Instagram virality is emerging and fragmented, dominated by niche SaaS tools focused on content generation, automation, and optimization. No dominant player holds quantifiable market share, but Zebracat leads in proven virality [1][3].
+
+### Main Competitors
+- **Zebracat**: AI video for niches like pets/AI art; high engagement (5%) [1].
+- **BigMotion AI**: Full automation for Reels (generation to auto-posting) [3].
+- **Faceless.video**: Faceless video ads with auto-posting/social integration [4].
+- **Crayo AI**: Viral short-form Reels ideation/production by faceless experts [6].
+
+### Competitive Positioning and Dynamics
+- **Leaders**: Zebracat (creative niches, proven metrics); BigMotion AI (automation for passive income).
+- **Followers**: Faceless.video (ads), Crayo (ideation).
+- Differentiation: Zebracat (niche templates), BigMotion (free tier/auto-post), Faceless.video (analytics), Crayo (expert-backed).
+- Market: Fast-evolving; general tools (Canva, Hootsuite) lag in faceless virality [1][3][4][6].
+
+### Competitive Matrix
+| Dimension              | FacelessViral IG (Ours)                  | Zebracat [1]                          | BigMotion AI [3]                      | Faceless.video [4]                    | Crayo AI [6]                          |
+|------------------------|------------------------------------------|---------------------------------------|---------------------------------------|---------------------------------------|---------------------------------------|
+| **Market Share/Size**  | Low (Emerging; IG-specific focus)        | **High** (509K followers, 5% engagement) | Medium-High (Free multi-platform)    | Low (No IG cases)                     | Low (Emerging)                        |
+| **Product Range**      | Medium (Reels virality)                  | Medium (Niche templates)              | **High** (Gen-to-post automation)     | Medium (Ads/auto-post)                | Medium (Ideation/production)          |
+| **Pricing Strategy**   | Unknown (Competitive SaaS)               | Medium (Beginner-friendly)            | **High** (Free tier)                  | Medium (Tiered SaaS)                  | Medium (No free tier)                 |
+| **Technology/Innovation** | Medium (Reels optimization)           | **High** (Niche workflows)            | **High** (Algo adaptation)            | Medium (Analytics integration)        | Medium-High (Viral ideation)          |
+| **Customer Segments**  | IG viral creators (passive focus)        | Beginners (pets/AI art)               | Passive income (multi-platform)       | Ad marketers                          | Short-form creators                   |
+| **Strengths**          | IG-exclusive virality, anonymity         | Proven metrics, templates             | Automation, free tier                 | Ad optimization                       | Expert-backed virals                  |
+| **Weaknesses**         | Narrow scope, no metrics                 | Niche-limited                         | Less creative depth                   | Ad-centric                            | Less automation                       |
+
+**Insights**: Differentiate via IG-exclusive focus; pursue hybrid automation/creatives [1][3].
+
+## 3. SWOT Analysis
+
+#### Strengths (Internal Positive Factors)
+- **Rapid, Scalable Content Production**: AI tools generate Reels in ~20 minutes; workflows enable high-volume output [1][2][3].
+- **Superior Engagement Metrics**: 5% for AI art, 3% uplift for AI influencers [3][9].
+- **Low Reputational and Operational Risks**: No face exposure; 24/7 scalability [2][3][9].
+- **Cost-Effective Monetization Pathways**: Affiliates, Shops, digital products [1][2][4].
+- **Trend-First-Mover Capabilities**: Real-time forecasting [6][7].
+- **Multi-Platform Repurposing**: Easy adaptation [1][3].
+
+#### Weaknesses (Internal Negative Factors)
+- **Perceived Lack of Authenticity**: Risks AI fatigue [3][9][10].
+- **Dependency on Third-Party Tools**: Pricing/outage vulnerabilities [1][2][3].
+- **Steep Learning Curve**: Prompt mastery needed [2][3].
+- **Limited Metrics for New Entrants**: Unproven scaling [1][3].
+- **Content Saturation Risk**: Oversupply in niches [3].
+- **Narrow Human Oversight**: Lacks nuance [5].
+
+#### Opportunities (External Positive Factors)
+- **Short-Form Video and Influencer Boom**: $140B video ads, $32.55B influencers [4].
+- **Social Commerce Expansion**: $2.9T by 2026 [2][3].
+- **Niche Virality and AI Art Demand**: Psychological hooks [1][3].
+- **AI Efficiency Amid Burnout**: 50% leaders adopting [2][4][6].
+- **Platform Discovery Prioritization**: Organic reach [1][2].
+- **UGC and Private Communities**: Retention boost [1][4].
+
+#### Threats (External Negative Factors)
+- **Consumer Distrust and Pullback**: 50% limiting interactions [2][4].
+- **Intense Niche Competition**: Zebracat/BigMotion dominance [1][3][4][6].
+- **Algorithm Volatility**: Interaction shifts [1][3][4].
+- **Market Saturation and Fatigue**: AI erosion [1][4][7][10].
+- **Regulatory/Economic Pressures**: Ad spend benefits incumbents [2][4][9].
+- **Resource Gaps**: Investment needs [2][5][8].
+
+## 4. Market Positioning
+Faceless AI Virality positions as an **accessible, low-risk Instagram monetization strategy** via anonymous Reels, yielding 5% engagement [3].
+
+### 1. Current Positioning
+- **Value Proposition**: 20-min virals, passive income, 2.5x engagement [1][2][3][9].
+- **Target Segments**:
+  | Segment              | Description                          | Examples                  |
+  |----------------------|--------------------------------------|---------------------------|
+  | Beginner Creators   | Quick virality/passive income        | Pet/AI art [1][3]        |
+  | Passive Income Seekers | Avoid personal branding            | Affiliates [1][2]        |
+  | Niche Producers     | Specialized themes                   | Tutorials [3]            |
+  | AI Influencer Teams | Virtual personas                     | Aitana Lopez [2][4]      |
+
+### 2. Competitive Differentiation
+- **Positioning Map** (Automation vs. Virality):
+  | Tool/Player       | Automation | Virality Focus | Key Diff                  |
+  |-------------------|------------|----------------|---------------------------|
+  | Zebracat         | Medium    | High          | Proven metrics [1]       |
+  | BigMotion AI     | High      | Medium        | Free auto-post [3]       |
+  | Faceless.video   | High      | Low-Medium    | Ads [4]                  |
+  | Crayo AI         | Medium    | High          | Ideation [6]             |
+  | **Ours**         | **High**  | **Highest**   | Anonymity + hooks [3][9] |
+
+- **USP**: Anonymity + scaling outperforms humans [9].
+
+### 3. Positioning Gaps and Opportunities
+- Gaps: Enterprise, global, e-commerce.
+- Recommendations: Hybrid SaaS, B2B pivot, authenticity boosters [1][5].
+
+## 5. Market Trends & Insights
+### 1. Key Trends
+- Short-form video dominance (78% preference) [4].
+- Authenticity/UGC/niches rise [1][3][4].
+- AI integration, social commerce, discovery engines [2][3][7].
+
+### 2. Growth Drivers
+- Ad/video spend ($276.7B/$140B in 2025) [2][4].
+- Influencers ($32.55B), commerce ($2.9T) [3][4].
+- AI innovations, niche storytelling [2][5][6].
+
+### 3. Challenges
+- Consumer pullback (50%), algorithm uncertainty, saturation [1][2][4].
+- Burnout, authenticity fatigue [2][5].
+
+### 4. Future Outlook
+- Growth through 2026; AI enabler with authenticity focus; fragmentation risks [2][4][5].
+
+## 6. Strategic Recommendations
+
+#### HIGH PRIORITY (0-3 Months)
+- **1**: Niche workflows (5-10 Reels/week); 3-5x reach [1][3][6].
+- **2**: Auto-posting/outbound; 2-4% lift [3][9].
+
+#### MEDIUM PRIORITY (6-12 Months)
+- **3**: 30% UGC blend; 25% churn reduction [1][4].
+- **4**: Shops/affiliates; $10K+ revenue [2][4].
+
+#### LONG-TERM (12+ Months)
+- **5**: Multi-platform; 2x audience [1][4].
+- **6**: Proprietary prompts; 7% engagement [2][5][6].
+
+## 7. Sources
+- [1] Zebracat case studies and examples.
+- [2] Virlo workflows and AI influencer context.
+- [3] Invideo AI, BigMotion AI features; faceless engagement metrics.
+- [4] Faceless.video; market trends (e.g., Gartner, HypeAuditor).
+- [5] TailorTalk automation.
+- [6] Madgicx, Crayo AI.
+- [7] Juicer social listening.
+- [8] Copy.ai, Descript, Mentionlytics.
+- [9] AI influencers (Lil Miquela, Aitana Lopez).
+- [10] General tools (Canva, Hootsuite); authenticity research.
+
+---
+Report generated: November 28, 2025
+
+---
+
+**Total Cost:** $0.0000

tests/unit/test_base_agent.py

@@ -0,0 +1,99 @@
+"""Unit tests for base agent class."""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from src.agents.base import BaseAgent
+from src.utils.cost_tracker import CostTracker
+
+
+class TestAgent(BaseAgent):
+    """Concrete test agent for testing base class."""
+
+    def get_system_prompt(self) -> str:
+        return "Test system prompt"
+
+    async def run(self, **kwargs):
+        return {"result": "test"}
+
+
+@pytest.mark.asyncio
+async def test_base_agent_initialization():
+    """Test base agent initializes correctly."""
+    tracker = CostTracker()
+
+    with patch("src.agents.base.get_settings") as mock_settings:
+        mock_settings.return_value = MagicMock(
+            default_model="x-ai/grok-4.1-fast:free",
+            openrouter_api_key="test-key",
+            openrouter_base_url="https://openrouter.ai/api/v1",
+        )
+
+        agent = TestAgent(
+            name="TestAgent",
+            model="openai/gpt-5-mini",
+            temperature=0.5,
+            cost_tracker=tracker,
+        )
+
+        assert agent.name == "TestAgent"
+        assert agent.model_name == "openai/gpt-5-mini"
+        assert agent.cost_tracker == tracker
+
+
+@pytest.mark.asyncio
+async def test_base_agent_uses_default_model():
+    """Test agent uses default model from config."""
+    with patch("src.agents.base.get_settings") as mock_settings:
+        mock_settings.return_value = MagicMock(
+            default_model="x-ai/grok-4.1-fast:free",
+            openrouter_api_key="test-key",
+            openrouter_base_url="https://openrouter.ai/api/v1",
+        )
+
+        agent = TestAgent(name="TestAgent")
+
+        assert agent.model_name == "x-ai/grok-4.1-fast:free"
+
+
+@pytest.mark.asyncio
+async def test_create_messages():
+    """Test message creation."""
+    with patch("src.agents.base.get_settings") as mock_settings:
+        mock_settings.return_value = MagicMock(
+            default_model="test-model",
+            openrouter_api_key="test-key",
+            openrouter_base_url="https://test.com",
+        )
+
+        agent = TestAgent(name="TestAgent")
+
+        messages = agent._create_messages("test user message")
+
+        assert len(messages) == 2
+        assert messages[0].content == "Test system prompt"
+        assert messages[1].content == "test user message"
+
+
+@pytest.mark.asyncio
+async def test_get_cost_summary():
+    """Test cost summary retrieval."""
+    tracker = CostTracker()
+
+    with patch("src.agents.base.get_settings") as mock_settings:
+        mock_settings.return_value = MagicMock(
+            default_model="test-model",
+            openrouter_api_key="test-key",
+            openrouter_base_url="https://test.com",
+        )
+
+        agent = TestAgent(name="TestAgent", cost_tracker=tracker)
+
+        # Track some usage
+        tracker.track_usage("openai/gpt-5-mini", 1000, 500)
+
+        summary = agent.get_cost_summary()
+
+        assert summary["total_input_tokens"] == 1000
+        assert summary["total_output_tokens"] == 500
+        assert summary["calls"] == 1