feat: Implement full agentic workflow with dual image generation

This commit introduces a true, stateful agentic negotiation process orchestrated by a Chief Strategist Agent. Key features include Segmind Ideogram API integration for conceptual images, real-time LaTeX compilation for viewable technical figures, and a complete, strategy-aligned patent draft generation.

app.py

@@ -2,670 +2,179 @@ import gradio as gr
 import os
 import requests
 import json
-from typing import Dict, List
+from typing import Dict, List, Generator, Optional
 from dotenv import load_dotenv
+import base64
+import tempfile
+import re
+import urllib.parse
 
 # Load environment variables from .env file
 load_dotenv()
 
-# Add Gemini integration at the top after existing imports
+# --- New Agentic Backend Integration ---
+try:
+    from real_ai_agents_implementation import AgenticNegotiator, NegotiationState
+    AGENTIC_BACKEND_AVAILABLE = True
+except ImportError as e:
+    print(f"Failed to import agentic backend: {e}")
+    AGENTIC_BACKEND_AVAILABLE = False
+    
+# Keep Gemini Image Generator for LaTeX compilation
 try:
     from gemini_image_generator import GeminiImageGenerator
     GEMINI_IMAGE_AVAILABLE = True
 except ImportError:
     GEMINI_IMAGE_AVAILABLE = False
 
-# Add Real AI Agents integration
-try:
-    from real_ai_agents_implementation import (
-        TechnicalCompletenessAgent,
-        PriorArtLandscapeAgent, 
-        ClaimArchitectureAgent,
-        InterAgentCoordinator
-    )
-    REAL_AI_AGENTS_AVAILABLE = True
-except ImportError:
-    REAL_AI_AGENTS_AVAILABLE = False
-
-# Add Nebius integration
-try:
-    from nebius_image_generator import integrate_with_patent_architect
-    NEBIUS_AVAILABLE = True
-except ImportError:
-    NEBIUS_AVAILABLE = False
-
-# Configuration for HuggingFace Spaces - no environment variables needed
-
-# --- Configuration ---
-# Using the clean Groq-only backend (reliable, no proxy issues)
-MODAL_BACKEND_URL = "https://gebhardt-wolfh--patent-architect-groq-fastapi-app.modal.run"
-# Alternative backends: 
-# - Nebius with images (experimental): "https://gebhardt-wolfh--patent-architect-nebius-clean-fastapi-app.modal.run"
-# - Clean backend: "https://gebhardt-wolfh--patent-architect-clean-fastapi-app.modal.run"
-
-# --- Enhanced Agent Personalities for Strategy Demo ---
-AGENT_PERSONALITIES = {
-    "Technical Analysis Agent": {
-        "personality": "Technical Deep-Dive Specialist",
-        "thinking_style": "Analyzing technical mechanisms and specifications",
-        "catchphrase": "Understanding the physics behind the innovation",
-        "bias": "Demand detailed technical explanations and identify knowledge gaps",
-        "negotiation_weight": 0.20,
-        "expertise": "Technical feasibility, mechanism analysis, specification requirements"
-    },
-    "Prior Art Agent": {
-        "personality": "Patent Detective",
-        "thinking_style": "Comprehensive patent landscape analysis",
-        "catchphrase": "Finding every relevant patent and publication",
-        "bias": "Exhaustive prior art search across multiple technology domains",
-        "negotiation_weight": 0.25,
-        "expertise": "Patent databases, academic literature, international filings"
-    },
-    "Invention Summary Agent": {
-        "personality": "Technical Writer", 
-        "thinking_style": "Creating precise technical narratives",
-        "catchphrase": "Crafting clear and compelling technical stories",
-        "bias": "Maximize technical clarity while highlighting true innovation",
-        "negotiation_weight": 0.15,
-        "expertise": "Technical writing, invention disclosure, differentiation"
-    },
-    "Figure Drafter Agent": {
-        "personality": "Technical Illustrator",
-        "thinking_style": "Designing patent drawings and diagrams",
-        "catchphrase": "Visual documentation of technical concepts",
-        "bias": "Ensure complete visual documentation of invention",
-        "negotiation_weight": 0.15,
-        "expertise": "Technical drawings, patent figures, visual communication"
-    },
-    "Claims Strategy Agent": {
-        "personality": "Patent Attorney",
-        "thinking_style": "Strategic patent claim optimization",
-        "catchphrase": "Crafting bulletproof patent claims",
-        "bias": "Balance broad protection with technical accuracy and grantability",
-        "negotiation_weight": 0.25,
-        "expertise": "Claim drafting, patent law, prosecution strategy"
-    }
-}
-
-# Enhanced IP Opportunity Categories with more specificity
-IP_OPPORTUNITIES = [
-    {"type": "Core Technology Patent", "description": "Main invention with detailed technical claims"},
-    {"type": "Method Patents", "description": "Process and algorithmic innovations"},
-    {"type": "System Integration Patents", "description": "Combination with other technologies"},
-    {"type": "Application-Specific Patents", "description": "Industry-specific implementations"},
-    {"type": "Improvement Patents", "description": "Enhanced versions and optimizations"},
-    {"type": "Defensive Patents", "description": "Block competitor strategies"}
-]
+def compile_latex_to_image(latex_code: str) -> Optional[str]:
+    """Try to compile LaTeX code to an image using a web service."""
+    if not latex_code:
+        return None
+    try:
+        # Prepare the LaTeX code by finding the relevant part
+        # A more robust regex to find either a full document or just a tikzpicture
+        match = re.search(r'(\\documentclass.*?\\end{document})|(\\begin{tikzpicture}.*?\\end{tikzpicture})', latex_code, re.DOTALL)
+        if match:
+            # Prioritize the full document if both are somehow present, otherwise take what was found
+            content_to_render = match.group(1) if match.group(1) else match.group(2)
+        else:
+            # Fallback if no standard block is found
+            content_to_render = latex_code
 
-def create_agent_negotiation_display(agent_responses: List[Dict], real_ai_results: Dict = None) -> str:
-    """Creates a detailed display of technical agent negotiation with real AI analysis."""
-    
-    # If we have real AI results, use them for enhanced analysis
-    if real_ai_results and real_ai_results.get("available"):
-        markdown = f"### 🤖 Real AI Agent Analysis\n\n"
-        
-        results = real_ai_results["results"]
-        readiness_score = real_ai_results["readiness_score"]
-        assessment = real_ai_results["assessment"]
-        
-        # Technical Completeness
-        tech_analysis = real_ai_results.get("technical_analysis", {})
-        tech_score = tech_analysis.get("completeness_score", 0) * 100
-        risk_level = tech_analysis.get("prosecution_risk", "Unknown")
-        missing_elements = tech_analysis.get("missing_elements", [])
-        
-        markdown += f"**🔬 Technical Completeness Agent:** {tech_score:.1f}%\n"
-        markdown += f"📊 Prosecution Risk: **{risk_level}**\n"
-        if missing_elements:
-            markdown += f"⚠️ Missing Critical Elements: {len(missing_elements)}\n"
-            for element in missing_elements[:2]:  # Show first 2
-                markdown += f"   • **{element.get('element_type', 'Unknown')}**: {element.get('suggestion', 'Needs improvement')}\n"
-        markdown += "\n"
-        
-        # Prior Art Analysis
-        prior_art = real_ai_results.get("prior_art_analysis", {})
-        risk_assessment = prior_art.get("risk_assessment", {})
-        competitors = prior_art.get("key_competitors", [])
-        
-        markdown += f"**🔍 Prior Art Landscape Agent:**\n"
-        markdown += f"📊 Risk Level: **{risk_assessment.get('overall_risk', 'Medium')}**\n"
-        if competitors:
-            markdown += f"🏢 Key Competitors: {len(competitors)}\n"
-            for comp in competitors[:2]:  # Show first 2
-                markdown += f"   • **{comp.get('company', 'Unknown')}**: {comp.get('patent_count', 0)} patents\n"
-        markdown += "\n"
-        
-        # Claim Architecture
-        claim_analysis = real_ai_results.get("claim_analysis", {})
-        claim_strength = claim_analysis.get("claim_strength", {})
-        overall_strength = claim_strength.get("overall_strength", 0) * 100
-        
-        markdown += f"**⚖️ Claim Architecture Agent:** {overall_strength:.1f}%\n"
-        markdown += f"📊 Grantability: **{claim_strength.get('grantability', 'Unknown')}**\n\n"
-        
-        # Overall Assessment
-        markdown += f"**🎯 OVERALL READINESS ASSESSMENT:**\n"
-        markdown += f"**Score:** {readiness_score*100:.1f}% - **{assessment}**\n\n"
+        # URL encode the LaTeX content for the API
+        encoded_latex = urllib.parse.quote(content_to_render)
         
-        # Business Intelligence
-        timeline = results.get("estimated_timeline", "Unknown")
-        costs = results.get("estimated_costs", "Unknown")
-        markdown += f"**📈 Business Planning:**\n"
-        markdown += f"• **Timeline:** {timeline}\n"
-        markdown += f"• **Estimated Costs:** {costs}\n\n"
+        # Use a reliable web service for compilation
+        api_url = f"https://latex.codecogs.com/png.latex?{encoded_latex}"
         
-        # Recommendations
-        recommendations = results.get("development_recommendations", [])
-        if recommendations:
-            markdown += f"**💡 Development Recommendations:**\n"
-            for rec in recommendations[:3]:  # Show first 3
-                markdown += f"• {rec}\n"
-        
-        return markdown
-    
-    # Fallback to original negotiation display
-    total_weight = sum(AGENT_PERSONALITIES[agent["name"]]["negotiation_weight"] for agent in agent_responses if agent["name"] in AGENT_PERSONALITIES)
-    
-    negotiations = []
-    for agent in agent_responses:
-        if agent["name"] in AGENT_PERSONALITIES:
-            personality = AGENT_PERSONALITIES[agent["name"]]
-            weight = personality["negotiation_weight"]
-            influence = (weight / total_weight) * 100 if total_weight > 0 else 0
-            
-            # Enhanced negotiation points with technical depth
-            agent_type = agent["name"].split()[0].lower()
-            if agent_type == "technical":
-                position = f"Technical gaps identified: Missing mechanism details, frequency analysis specs, signal processing algorithms"
-                concern_level = "High"
-            elif agent_type == "prior":
-                num_patents = agent.get("num_patents", 1)
-                if num_patents < 10:
-                    position = f"Shallow search: Only {num_patents} patents found. Missing ultrasonic sensors, acoustic emission, vibration analysis domains"
-                    concern_level = "High"
-                else:
-                    position = f"Comprehensive analysis: {num_patents} patents analyzed across multiple domains"
-                    concern_level = "Low"
-            elif agent_type == "invention":
-                position = f"Technical clarity: Low - needs specific mechanism explanation, frequency ranges, sensor specifications"
-                concern_level = "Medium"
-            elif agent_type == "figure":
-                position = f"Visual documentation: Incomplete - needs actual technical drawings with numbered components"
-                concern_level = "Medium"
-            elif agent_type == "claims":
-                position = f"Claims analysis: Too broad, likely not novel - need specific technical limitations"
-                concern_level = "High"
-            else:
-                position = personality['bias']
-                concern_level = "Medium"
+        response = requests.get(api_url, timeout=20)
+        if response.status_code == 200 and response.headers.get('content-type', '').startswith('image/'):
+            # Convert the successful image response to a base64 data URI
+            image_b64 = base64.b64encode(response.content).decode('utf-8')
+            return f"data:image/png;base64,{image_b64}"
+        else:
+            print(f"LaTeX compilation failed with status: {response.status_code}")
+            return None
             
-            # Color coding based on concern level
-            status_color = "🔴" if concern_level == "High" else "🟡" if concern_level == "Medium" else "🟢"
+    except Exception as e:
+        print(f"An error occurred during LaTeX compilation: {e}")
+        return None
+
+def create_negotiation_transcript_display(transcript: List[Dict]) -> str:
+    """Creates a markdown display for the agent negotiation transcript."""
+    if not transcript:
+        return "### Agent Negotiation Log\n\n*Awaiting instructions...*"
+
+    markdown = "### Agent Negotiation Log\n\n---\n\n"
+    for entry in transcript:
+        agent = entry.get('agent', 'System')
+        message = entry.get('message', '')
+        
+        # Make the agent name bold and add color
+        if agent == "Chief Strategist":
+            color = "#ff8c00" # Orange
+        elif agent == "Conceptual Artist":
+            color = "#da70d6" # Orchid
+        elif agent == "System":
+            color = "#ff4d4d" # Red
+        else:
+            color = "#00ff41" # Green
             
-            negotiations.append({
-                "name": agent["name"],
-                "influence": influence,
-                "position": position,
-                "concern_level": concern_level,
-                "status_color": status_color,
-                "status": "Reviewing" if len(agent_responses) <= 3 else "Complete"
-            })
-    
-    # Build markdown display with detailed feedback
-    markdown = f"### Multi-Agent Technical Review (Step {len(agent_responses)}/5)\n\n"
-    
-    for neg in negotiations:
-        status_text = "(Active Review)" if neg["status"] == "Reviewing" else "(Complete)"
-        markdown += f"**{neg['name']}** {status_text} - {neg['influence']:.0f}% influence {neg['status_color']}\n"
-        markdown += f"Assessment: {neg['position']}\n"
-        markdown += f"Concern Level: {neg['concern_level']}\n\n"
-    
-    # Calculate realistic consensus based on technical concerns
-    high_concerns = sum(1 for neg in negotiations if neg['concern_level'] == 'High')
-    medium_concerns = sum(1 for neg in negotiations if neg['concern_level'] == 'Medium')
-    
-    if high_concerns >= 2:
-        consensus_level = 45
-        patentability_score = 4.5
-        outcome = "Major technical gaps identified. Invention needs significant development before patent filing."
-    elif high_concerns == 1 and medium_concerns >= 1:
-        consensus_level = 65
-        patentability_score = 6.5
-        outcome = "Technical issues identified. Requires expert review and refinement."
-    elif medium_concerns >= 2:
-        consensus_level = 75
-        patentability_score = 7.5
-        outcome = "Good foundation with areas for improvement. Recommend technical enhancement."
-    else:
-        consensus_level = 85
-        patentability_score = 8.5
-        outcome = "Strong technical foundation. Ready for expert patent attorney review."
-    
-    markdown += f"**Technical Consensus:** {consensus_level}% - **Realistic Patentability Score: {patentability_score:.1f}/10**\n\n"
-    markdown += f"**Outcome:** {outcome}\n\n"
-    
-    # Add specific recommendations based on critique
-    markdown += "**Expert Recommendations:**\n"
-    if high_concerns >= 1:
-        markdown += "• Conduct deeper technical development before patent filing\n"
-        markdown += "• Engage patent attorney for comprehensive prior art search\n"
-        markdown += "• Define specific technical mechanism and parameters\n"
-        markdown += "• Identify true novel contribution vs. existing art\n"
-    else:
-        markdown += "• Ready for professional patent attorney review\n"
-        markdown += "• Consider filing provisional patent for priority\n"
-    
+        markdown += f"<p style='color: {color}; margin-bottom: 5px;'><strong>🤖 {agent}:</strong></p>\n"
+        markdown += f"<p style='margin-left: 20px; margin-top: 0px;'>{message}</p>\n\n"
+        markdown += "---\n\n"
+        
     return markdown
 
-def create_ip_opportunity_cards(opportunities: List[Dict]) -> str:
-    """Generates IP opportunity cards from backend data."""
-    if not opportunities:
-        return ""
-
-    html = """
-    <div style="background: #f8f9fa; border-radius: 10px; padding: 20px; margin: 20px 0;">
-        <h4 style="color: #333; margin-bottom: 15px;">Discovered IP Opportunities</h4>
-        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 15px;">
+def run_patent_architect_in_ui(invention_disclosure: str) -> Generator[List, None, None]:
     """
-    
-    for i, opp in enumerate(opportunities):
-        score = opp.get("score", 75)
-        color = "#28a745" if score >= 85 else "#ffc107" if score >= 75 else "#17a2b8"
-        
-        opp_info = next((o for o in IP_OPPORTUNITIES if o["type"] == opp.get("type")), IP_OPPORTUNITIES[0])
-        
-        html += f"""
-        <div style="background: white; border: 2px solid {color}; border-radius: 8px; padding: 15px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
-                <h6 style="color: #333; margin: 0; font-size: 1.1em;">{opp.get('type', 'Opportunity')}</h6>
-                <span style="background: {color}; color: white; padding: 3px 8px; border-radius: 12px; font-size: 0.8em; font-weight: bold;">
-                    {score}/100
-                </span>
-            </div>
-            <p style="color: #666; font-size: 0.9em; margin: 5px 0;">{opp.get('description', '')}</p>
-            <p style="color: #28a745; font-weight: bold; font-size: 0.8em; margin: 5px 0;">
-                Market: {opp.get('market_size', 'N/A')}
-            </p>
-        </div>
-        """
-    
-    html += """
-        </div>
-    </div>
+    This is the new main UI function that runs the true agentic workflow.
+    It no longer calls an external backend.
     """
-    return html
-
-def run_real_ai_analysis(invention_disclosure: str) -> Dict:
-    """Run the real AI agent analysis on the invention disclosure."""
-    if not REAL_AI_AGENTS_AVAILABLE:
-        return {"available": False, "error": "Real AI agents not available"}
-    
-    try:
-        # Initialize the coordinator
-        coordinator = InterAgentCoordinator()
-        
-        # Run comprehensive analysis
-        results = coordinator.orchestrate_patent_development(invention_disclosure)
-        
-        return {
-            "available": True,
-            "results": results,
-            "readiness_score": results.get("overall_readiness_score", 0),
-            "assessment": results.get("readiness_assessment", "Unknown"),
-            "technical_analysis": results.get("technical_completeness", {}),
-            "prior_art_analysis": results.get("prior_art_landscape", {}),
-            "claim_analysis": results.get("claim_architecture", {})
-        }
-    except Exception as e:
-        return {"available": False, "error": str(e)}
+    # Initial state for all output fields
+    negotiation_html = create_negotiation_transcript_display([])
+    prior_art_section = "### Prior Art Analysis\n\n*Awaiting agent analysis...*"
+    summary_section = "### Invention Summary\n\n*Awaiting agent analysis...*"
+    figures_section = "### Technical Figures\n\n*Awaiting agent analysis...*"
+    claims_section = "### Patent Claims\n\n*Awaiting agent analysis...*"
+    status = "System Initialized."
 
-def format_patent_section(agent_name: str, content: str, thought: str = None, sources: List = None, image_urls: List = None) -> str:
-    """Enhanced patent section formatting with technical analysis and image generation."""
-    
-    # Enhanced Figure Drafter Agent with Gemini and Nebius integration  
-    if agent_name == "Figure Drafter Agent":
-        try:
-            # Try Gemini first (preferred for high-quality patent figures)
-            if GEMINI_IMAGE_AVAILABLE and os.environ.get("GEMINI_API_KEY"):
-                try:
-                    print("🎨 Activating Gemini 2.0 Flash for patent figure generation...")
-                    generator = GeminiImageGenerator()
-                    
-                    # Extract invention description from content or use a default
-                    # Look for invention context in the content
-                    if "SUMMARY OF THE INVENTION" in content:
-                        # Extract from summary section
-                        start = content.find("SUMMARY OF THE INVENTION") + len("SUMMARY OF THE INVENTION")
-                        end = content.find("'. This would include", start) if "'. This would include" in content[start:] else len(content)
-                        invention_context = content[start:end].strip()[:800]
-                        # Clean up the context
-                        invention_context = invention_context.replace("The present invention relates to", "").replace("The present invention provides", "").strip()
-                    else:
-                        # Fallback: extract a reasonable description from the available content
-                        invention_context = "Passive acoustic liquid level detection system with machine learning analysis"
-                    
-                    print(f"🔍 Extracted invention context: {invention_context[:100]}...")
-                    
-                    gemini_result = generator.integrate_with_patent_architect(invention_context)
-                    
-                    if gemini_result.get("success"):
-                        # COMPLETELY REPLACE the backend content with Gemini-generated content
-                        content = gemini_result["content"]
-                        
-                        # Check if we have dual output (descriptions + LaTeX)
-                        if gemini_result.get("dual_output"):
-                            # Enhanced dual output available
-                            descriptions_available = gemini_result.get("descriptions_available", 0)
-                            latex_available = gemini_result.get("latex_code_available", 0)
-                            compiled_images = gemini_result.get("compiled_images", 0)
-                            
-                            content += f"\n\n*🚀 Enhanced Dual Output: {descriptions_available} technical descriptions + {latex_available} LaTeX/TikZ code sets generated*\n\n"
-                            
-                            if compiled_images > 0:
-                                content += f"*🖼️ {compiled_images} figures successfully compiled to images - View immediately in output folder*\n\n"
-                            
-                            content += f"*💡 Best Experience: Read descriptions above, then use LaTeX code with Overleaf.com for professional figures*\n\n"
-                            
-                            # Update thought to reflect dual output
-                            thought = f"Generated comprehensive dual output with {descriptions_available} detailed technical descriptions AND {latex_available} professional LaTeX/TikZ code sets. Users can read descriptions immediately and compile LaTeX for USPTO-ready vector graphics."
-                            
-                        elif gemini_result.get("images_generated", 0) > 0:
-                            if gemini_result.get("latex_generated", 0) > 0:
-                                content += "\n\n*🎨 Generated LaTeX/TikZ code using Google Gemini 2.0 Flash - Compile with pdflatex to create professional patent figures*\n\n"
-                                content += f"*💡 To view images: Compile the .tex files in `{os.path.expanduser('~')}/patent_architect_figures/`*\n\n"
-                                thought = "Generated professional LaTeX/TikZ code for patent figures using Google Gemini 2.0 Flash. Code can be compiled to create high-quality technical drawings with numbered components and USPTO-ready formatting."
-                            else:
-                                content += "\n\n*🎨 Generated visual patent figures using Google Gemini 2.0 Flash - Professional images ready for USPTO submission*\n\n"
-                                thought = "Generated high-quality patent figures using Google Gemini 2.0 Flash with professional technical drawings, numbered components, and USPTO-ready formatting."
-                        else:
-                            content += "\n\n*📝 Generated detailed patent figure descriptions using Google Gemini 2.0 Flash - Professional technical specifications*\n\n"
-                            thought = "Generated detailed technical specifications for patent figures using Google Gemini 2.0 Flash with professional patent formatting."
-                        
-                        print("✅ Gemini image generation successful - Backend content replaced")
-                        
-                    else:
-                        print(f"❌ Gemini generation failed: {gemini_result.get('error', 'Unknown error')}")
-                        
-                except Exception as e:
-                    print(f"❌ Gemini integration error: {e}")
-            
-            # Fallback to Nebius if Gemini failed or unavailable
-            elif NEBIUS_AVAILABLE and not image_urls:
-                try:
-                    if "figure" in content.lower() or "drawing" in content.lower():
-                        figure_descriptions = [
-                            "Cross-sectional view showing main components",
-                            "System diagram showing connections"
-                        ]
-                        
-                        from dotenv import load_dotenv
-                        load_dotenv()
-                        
-                        if os.environ.get("NEBIUS_API_KEY"):
-                            nebius_result = integrate_with_patent_architect(
-                                invention_description="Technical invention with numbered components",
-                                figure_descriptions=figure_descriptions
-                            )
-                            
-                            if nebius_result.get("success"):
-                                content = nebius_result["content"]
-                                image_urls = nebius_result.get("image_urls", [])
-                                content += "\n\n*🖼️ Generated using Nebius AI - Enhanced with visual diagrams*\n\n"
-                                print("✅ Nebius image generation successful")
-                                
-                except Exception as e:
-                    print(f"❌ Nebius integration error: {e}")
-            
-            # If no image generation available, enhance the text-based content
-            else:
-                # Check if this is Groq's "no image generation" content
-                if "image generation is not available with groq" in content.lower() or "since image generation is not available" in content.lower():
-                    # Replace Groq's limitation message with enhancement message
-                    content = content.replace(
-                        "Generated detailed text descriptions for patent figures since image generation is not available with Groq.",
-                        "Enhanced patent figure descriptions with detailed technical specifications."
-                    )
-                    content = content.replace(
-                        "Since image generation is not available with Groq, here are detailed descriptions",
-                        "Enhanced technical figure descriptions with professional patent formatting"
-                    )
-                    content += f"\n\n*💡 To enable professional image generation: Set GEMINI_API_KEY environment variable and get API key from https://makersuite.google.com/app/apikey*\n\n"
-                    
-                    # Add critique-based improvements to figure descriptions
-                    content += "\n\n### 🎯 Figure Enhancement Recommendations:\n"
-                    content += "• **Missing Elements:** Numbered components, dimension lines, material callouts\n"
-                    content += "• **Technical Precision:** Frequency response curves, signal processing flow\n"
-                    content += "• **Patent Standards:** USPTO figure requirements compliance\n"
-                    content += "• **Professional Quality:** Vector graphics suitable for patent submission\n\n"
-                    
-                    print("✅ Enhanced Groq content with detailed recommendations")
-                    
-        except Exception as e:
-            print(f"❌ Figure generation error: {e}")
-            content += f"\n\n*⚠️ Image generation unavailable. Please check API configuration.*\n\n"
-    
-    # Enhanced Prior Art Agent feedback
-    elif agent_name == "Prior Art Agent":
-        # Count sources and provide detailed analysis
-        num_sources = len(sources) if sources else 0
-        
-        if num_sources < 10:
-            content += f"\n\n### ⚠️ Prior Art Search Limitations:\n"
-            content += f"• **Sources Found:** Only {num_sources} patents/publications\n"
-            content += f"• **Missing Domains:** Ultrasonic sensors, acoustic emission monitoring, vibration analysis\n"
-            content += f"• **Incomplete Coverage:** International patents, academic literature, industry standards\n"
-            content += f"• **Recommendation:** Comprehensive search required before filing\n\n"
-            
-            content += f"### 🔍 Suggested Additional Search Terms:\n"
-            content += f"• Ultrasonic level detection patents\n"
-            content += f"• Acoustic emission sensors\n"
-            content += f"• Passive vibration monitoring\n"
-            content += f"• Machine learning signal processing\n"
-            content += f"• Non-invasive liquid measurement\n\n"
-    
-    # Enhanced Claims Strategy Agent feedback
-    elif agent_name == "Claims Drafter Agent":  # Fixed: Backend sends "Claims Drafter Agent"
-        # Analyze claims for common issues
-        if "acoustic sensor" in content.lower() and "passive" in content.lower():
-            content += f"\n\n### ⚠️ Claims Analysis - Critical Issues:\n"
-            content += f"• **Overly Broad:** Claims 1 likely lacks novelty (passive acoustic sensors exist)\n"
-            content += f"• **Missing Specificity:** No technical limitations on frequency analysis method\n"
-            content += f"• **Weak Differentiation:** Doesn't capture unique ML training approach\n"
-            content += f"• **Patent Risk:** Current claims may be rejected for obviousness\n\n"
-            
-            content += f"### 🎯 Recommended Claim Improvements:\n"
-            content += f"• Focus on specific frequency change detection method\n"
-            content += f"• Add ML model architecture and training claims\n"
-            content += f"• Include anomaly detection for bubbles/splashes\n"
-            content += f"• Define technical parameters (frequency ranges, sensitivity)\n\n"
-    
-    # Format agent response with enhanced personality
-    if agent_name in AGENT_PERSONALITIES:
-        personality = AGENT_PERSONALITIES[agent_name]
-        
-        formatted = f"### {agent_name}\n\n"
-        
-        # Add thinking process if available
-        if thought:
-            formatted += f"**Agent Analysis:**\n{thought}\n\n"
-        
-        formatted += content
-        
-        # Add enhanced strategy note with expertise
-        formatted += f"\n\n*Strategy: {personality['bias']}*\n"
-        formatted += f"*Expertise: {personality.get('expertise', 'General patent analysis')}*\n\n"
-        
-    else:
-        # Fallback for unknown agents
-        formatted = f"### {agent_name}\n\n"
-        if thought:
-            formatted += f"**Analysis:** {thought}\n\n"
-        formatted += content
-    
-    # Add sources if available with enhanced formatting
-    if sources and len(sources) > 0:
-        formatted += "\n\n**📚 Prior Art Sources:**\n"
-        for i, source in enumerate(sources, 1):
-            if source.get('url'):
-                formatted += f"{i}. [{source.get('title', 'Patent Source')}]({source.get('url')})\n"
-        
-        # Add search quality assessment
-        if len(sources) < 10:
-            formatted += f"\n*⚠️ Limited search results ({len(sources)} sources). Comprehensive search recommended.*\n"
-    
-    return formatted 
+    yield [negotiation_html, prior_art_section, summary_section, figures_section, claims_section, status]
 
-def run_patent_architect_in_ui(invention_disclosure):
-    """Enhanced UI function with agent personalities and IP discovery."""
     if not invention_disclosure:
-        # Reset to initial state if input is cleared
-        outputs = {
-            "opportunities": gr.HTML.update(value="<h3>IP Opportunities</h3><p>Enter invention to discover patent opportunities</p>"),
-            "negotiation": gr.Markdown.update(value="### Agent Negotiation\n\nAgents will negotiate optimal strategy"),
-            "prior_art": gr.Markdown.update(value="### Prior Art Analysis\n\n*This section will show the analysis of existing patents and technologies related to your invention.*"),
-            "summary": gr.Markdown.update(value="### Invention Summary\n\n*This section will contain the professional Background of the Invention and Summary of the Invention sections.*"),
-            "figures": gr.Markdown.update(value="### Technical Figures\n\n*This section will display the generated patent-style technical drawings with numbered components.*"),
-            "claims": gr.Markdown.update(value="### Patent Claims\n\n*This section will contain the numbered patent claims that legally define the scope of your invention.*"),
-            "status": "Enhanced Patent Architect v2 - Ready for rigorous technical analysis",
-        }
-        yield list(outputs.values())
+        status = "Please provide an invention disclosure."
+        yield [negotiation_html, prior_art_section, summary_section, figures_section, claims_section, status]
         return
 
-    if not MODAL_BACKEND_URL:
-        error_msg = "**Backend Configuration Required**\n\nPlease deploy the Patent Architect backend and update the `MODAL_BACKEND_URL` configuration."
-        yield error_msg, error_msg, error_msg, error_msg, "Configuration Error"
+    if not AGENTIC_BACKEND_AVAILABLE:
+        status = "ERROR: The agentic backend is not available. Check server logs."
+        negotiation_html = create_negotiation_transcript_display([{"agent": "System", "message": "CRITICAL ERROR: Could not import `AgenticNegotiator`. The application cannot run."}])
+        yield [negotiation_html, prior_art_section, summary_section, figures_section, claims_section, status]
         return
-
-    # Initialize all sections with clean interface
-    opportunities_html = create_ip_opportunity_cards([])
-    
-    # Run real AI analysis if available
-    real_ai_results = None
-    if REAL_AI_AGENTS_AVAILABLE:
-        status = "🤖 Running Real AI Agent Analysis..."
-        yield opportunities_html, "### Real AI Analysis\n\nRunning comprehensive technical analysis...", "### Prior Art Analysis\n\n*Waiting for technical analysis...*", "### Invention Summary\n\n*Waiting for analysis...*", "### Technical Figures\n\n*Waiting for analysis...*", "### Patent Claims\n\n*Waiting for analysis...*", status
         
-        real_ai_results = run_real_ai_analysis(invention_disclosure)
-        
-        if real_ai_results.get("available"):
-            status = f"✅ Real AI Analysis Complete - Readiness: {real_ai_results['readiness_score']*100:.1f}%"
-        else:
-            status = f"⚠️ Real AI Analysis Failed: {real_ai_results.get('error', 'Unknown error')}"
+    # --- Start the Real Agentic Workflow ---
+    negotiator = AgenticNegotiator(invention_disclosure)
     
-    negotiation_display = create_agent_negotiation_display([], real_ai_results)
-    prior_art_section = "### Prior Art Analysis\n\n*Prior Art Specialist is searching patent databases...*"
-    summary_section = "### Invention Summary\n\n*Technical Writer is awaiting prior art analysis...*" 
-    figures_section = "### Technical Figures\n\n*Technical Illustrator is awaiting invention summary...*"
-    claims_section = "### Patent Claims\n\n*Patent Attorney is awaiting technical figures...*"
-    status = "Starting Patent Architect with Strategic Analysis..."
-
-    yield opportunities_html, negotiation_display, prior_art_section, summary_section, figures_section, claims_section, status
-
-    try:
-        print(f"Connecting to Patent Architect backend: {MODAL_BACKEND_URL}")
+    final_state = None
+    for state in negotiator.run_negotiation():
+        final_state = state
+        
+        # Update negotiation transcript
+        negotiation_html = create_negotiation_transcript_display(state.negotiation_transcript)
         
-        # Initialize agent response tracker
-        agent_responses = []
+        # Update status from the last message
+        if state.negotiation_transcript:
+            last_entry = state.negotiation_transcript[-1]
+            status = f"Active Agent: {last_entry['agent']}"
+
+        # As prior art becomes available, display it
+        if state.prior_art_analysis:
+            pa_data = state.prior_art_analysis
+            prior_art_section = f"### Prior Art & Strategy\n\n"
+            if state.strategic_mandate:
+                 prior_art_section += f"**Strategic Mandate:**\n> {state.strategic_mandate}\n\n---\n\n"
+            prior_art_section += f"**Landscape Summary:** {pa_data.get('landscape_summary', 'N/A')}\n\n"
+            prior_art_section += f"**Key Concepts Identified:**\n"
+            for concept in pa_data.get('key_concepts', []):
+                prior_art_section += f"- {concept}\n"
+            prior_art_section += "\n**Simulated Representative Prior Art:**\n"
+            for art in pa_data.get('simulated_prior_art', []):
+                prior_art_section += f"- {art}\n"
+
+        # As sections get generated, display them
+        if state.technical_summary:
+            summary_section = f"### Invention Summary\n\n{state.technical_summary}"
         
-        with requests.post(
-            f"{MODAL_BACKEND_URL}/generate_patent",
-            json={"invention_disclosure": invention_disclosure},
-            timeout=1800,  # 30 minute timeout for full patent generation
-            stream=True
-        ) as response:
-            response.raise_for_status()
+        if state.patent_claims:
+            claims_section = f"### Patent Claims\n\n{state.patent_claims}"
             
-            for line in response.iter_lines():
-                if line:
-                    decoded_line = line.decode('utf-8')
-                    if decoded_line.startswith('data: '):
-                        try:
-                            event = json.loads(decoded_line[6:])
-                            print(f"DEBUG: Received event from backend: {event}") # Print event for debugging
-                            event_status = event.get("status")
-                            
-                            if event_status == "starting":
-                                status = event.get("log", "Starting...")
-                                
-                            elif event_status == "running":
-                                status = event.get("log", "Processing...")
-                                
-                            elif event_status == "update":
-                                data = event.get("data", {})
-                                step_info = event.get("step", "")
-                                section_type = data.get("section_type")
-                                
-                                # This block handles the new IP Opportunities data
-                                if section_type == "ip_opportunities":
-                                    opportunities = data.get("data", {}).get("opportunities", [])
-                                    opportunities_html = create_ip_opportunity_cards(opportunities)
-                                    prior_art_section = "### Prior Art Analysis\n\n*Prior Art Specialist is searching patent databases...*"
-                                    status = f"Step {step_info} Complete: IP Opportunity Agent found {len(opportunities)} new avenues"
-                                    yield opportunities_html, negotiation_display, prior_art_section, summary_section, figures_section, claims_section, status
-                                    continue
-
-                                agent_name = data.get("agent_name", "Patent Agent")
-                                content = data.get("content", "")
-                                thought = data.get("thought", "")
-                                sources = data.get("sources", [])
-                                image_urls = data.get("image_urls", [])
-                                
-                                formatted_content = format_patent_section(agent_name, content, thought, sources, image_urls)
-                                
-                                # Update the appropriate section based on the agent's designated section_type
-                                if section_type == "prior_art":
-                                    prior_art_section = formatted_content
-                                    summary_section = "### Invention Summary\n\n*Technical Writer is crafting your invention story...*"
-                                    
-                                    # Update negotiation based on real patent count
-                                    num_patents = len(sources)
-                                    agent_responses = [{"name": agent_name, "num_patents": num_patents}]
-                                    negotiation_display = create_agent_negotiation_display(agent_responses, real_ai_results)
-                                    
-                                elif section_type == "summary":
-                                    summary_section = formatted_content
-                                    figures_section = "### Technical Figures\n\n*Technical Illustrator is designing patent drawings...*"
-                                    
-                                    # This assumes prior_art ran first and initialized agent_responses
-                                    agent_responses.append({"name": agent_name})
-                                    negotiation_display = create_agent_negotiation_display(agent_responses, real_ai_results)
-                                    
-                                elif section_type == "figures":
-                                    figures_section = formatted_content
-                                    claims_section = "### Patent Claims\n\n*Patent Attorney is optimizing claim scope...*"
-                                    
-                                    agent_responses.append({"name": agent_name})
-                                    negotiation_display = create_agent_negotiation_display(agent_responses, real_ai_results)
-                                    
-                                elif section_type == "claims":
-                                    claims_section = formatted_content
-                                    
-                                    agent_responses.append({"name": agent_name})
-                                    negotiation_display = create_agent_negotiation_display(agent_responses, real_ai_results)
-                                
-                                # Enhanced status with agent personality
-                                if agent_name in AGENT_PERSONALITIES:
-                                    personality = AGENT_PERSONALITIES[agent_name]["personality"]
-                                    status = f"Step {step_info} Complete: {personality} has finished their analysis"
-                                else:
-                                    status = f"Step {step_info} Complete: {agent_name} finished"
-                                
-                            elif event_status == "assembling":
-                                status = event.get("log", "Assembling patent application...")
-                                
-                            elif event_status == "complete":
-                                status = "Patent Application Complete - Ready for review and filing"
-                                
-                            yield opportunities_html, negotiation_display, prior_art_section, summary_section, figures_section, claims_section, status
-                            
-                        except json.JSONDecodeError as e:
-                            print(f"Could not decode JSON from stream: {decoded_line}")
-                            continue
+        # Handle both Ideogram image and LaTeX figure description
+        if state.ideogram_image_b64 or state.figure_description:
+            figures_section = "### Technical Figures\n\n"
+            
+            # Display the Ideogram image if it exists
+            if state.ideogram_image_b64:
+                figures_section += "### Conceptual Image (from Ideogram API)\n"
+                image_html = f"<img src='data:image/jpeg;base64,{state.ideogram_image_b64}' alt='Generated Conceptual Image' style='max-width: 100%; height: auto; border: 2px solid #ff8c00;'>"
+                figures_section += image_html + "\n\n---\n\n"
+
+            # Display the LaTeX figure description and compiled image if it exists
+            if state.figure_description:
+                figures_section += "### Technical Figure (from LaTeX)\n"
+                compiled_latex_image_uri = compile_latex_to_image(state.figure_description)
+                if compiled_latex_image_uri:
+                    figures_section += f"<img src='{compiled_latex_image_uri}' alt='Compiled LaTeX Figure' style='max-width: 100%; height: auto; border: 2px solid #00ff41; background: white; padding: 10px;'>\n\n"
+                else:
+                    figures_section += "*LaTeX compilation failed. Displaying raw code.*\n\n"
+                
+                figures_section += "#### Raw LaTeX/TikZ Code:\n"
+                figures_section += state.figure_description
+        
+        yield [negotiation_html, prior_art_section, summary_section, figures_section, claims_section, status]
 
-    except requests.exceptions.RequestException as e:
-        error_msg = f"Connection Error: {str(e)}\n\nPlease check that the Patent Architect backend is deployed and accessible."
-        status = "Connection Failed"
-        yield opportunities_html, negotiation_display, prior_art_section, summary_section, figures_section, claims_section, status
+    status = "Agentic Negotiation Complete."
+    yield [negotiation_html, prior_art_section, summary_section, figures_section, claims_section, status]
 
 with gr.Blocks(theme=gr.themes.Base(primary_hue="green", neutral_hue="slate"), title="Patent Architect v2") as demo:
     gr.HTML("""
@@ -709,7 +218,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue="green", neutral_hue="slate"), t
                   color: #00ff41;
                   opacity: 0.8;
                   position: relative;
-                  z-index: 1;">POWERED BY GEMINI NEURAL NETWORKS + AUTONOMOUS AI AGENTS</p>
+                  z-index: 1;">POWERED BY GEMINI & IDEOGRAM 3.0 + AUTONOMOUS AI AGENTS</p>
     </div>
     """)
 
@@ -795,25 +304,17 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue="green", neutral_hue="slate"), t
             invention_input = gr.Textbox(
                 lines=12,
                 label="Neural Disclosure Interface",
-                placeholder="""Initialize invention parameters:
-
-▶ Problem identification and solution matrix
-▶ Technical architecture and component flow  
-▶ Novelty differentiators vs existing systems
-▶ Advantage metrics and performance data
-▶ Technical specifications and parameters
-
-EXAMPLE NEURAL INPUT: "Autonomous beverage temperature regulation system utilizing phase-change material matrices with neural app integration, eliminating thermal degradation issues through adaptive preference algorithms..."
-""",
-                info="Enhanced neural processing requires detailed technical specifications"
+                placeholder="""Enter your invention disclosure here. Be as detailed as possible. 
+The agentic system will analyze your input, formulate a patent strategy, and generate a draft application based on that strategy.""",
+                info="The new agentic backend requires a detailed technical disclosure to function effectively."
             )
             
-            generate_btn = gr.Button("INITIATE PATENT SYNTHESIS", variant="primary", size="lg")
+            generate_btn = gr.Button("INITIATE AGENTIC NEGOTIATION", variant="primary", size="lg")
             
             status_display = gr.Textbox(
                 label="System Status",
                 interactive=False,
-                value="PATENT ARCHITECT v2 - Neural Networks Online - Agents Ready"
+                value="AGENTIC WORKFLOW READY"
             )
 
     gr.HTML("""
@@ -824,7 +325,6 @@ EXAMPLE NEURAL INPUT: "Autonomous beverage temperature regulation system utilizi
     </div>
     """)
     
-    # Enhanced Technical Intelligence Dashboard
     gr.HTML("""
     <div style="background: linear-gradient(45deg, #0a0a0a, #1a1a1a); 
                 border: 1px solid #ff8c00; 
@@ -836,25 +336,14 @@ EXAMPLE NEURAL INPUT: "Autonomous beverage temperature regulation system utilizi
                    text-shadow: 0 0 5px #ff8c00; 
                    font-size: 1.6em; 
                    margin: 0;
-                   text-transform: uppercase;">NEURAL ANALYSIS & IP STRATEGY MATRIX</h2>
+                   text-transform: uppercase;">LIVE AGENT NEGOTIATION & STRATEGY</h2>
     </div>
     """)
     
     with gr.Row():
-        with gr.Column():
-            opportunities_display = gr.HTML("""
-            <div style="background: linear-gradient(45deg, #0a0a0a, #1a1a1a); 
-                        border: 1px solid #00ff41; 
-                        padding: 15px; 
-                        color: #00ff41;
-                        font-family: 'Courier New', monospace;">
-                <h3 style="color: #00ff41; margin: 0;">IP OPPORTUNITY MATRIX</h3>
-                <p style="color: #ff8c00;">Patent vectors will materialize here</p>
-            </div>
-            """)
-        with gr.Column():
-            negotiation_display = gr.Markdown("### AGENT NEGOTIATION PROTOCOL\n\nMulti-agent consensus algorithm initializing...")
-    
+        with gr.Column(scale=2):
+            negotiation_display = gr.HTML("...")
+            
     gr.HTML("""
     <div style="height: 2px; 
                 background: linear-gradient(90deg, #ff8c00, #ffff00, #00ff41, #ff8c00); 
@@ -874,47 +363,46 @@ EXAMPLE NEURAL INPUT: "Autonomous beverage temperature regulation system utilizi
                    text-shadow: 0 0 5px #00ff41; 
                    font-size: 1.6em; 
                    margin: 0;
-                   text-transform: uppercase;">GENERATED PATENT APPLICATION</h2>
+                   text-transform: uppercase;">STRATEGY-ALIGNED PATENT DRAFT</h2>
     </div>
     """)
     
     with gr.Tabs():
-        with gr.TabItem("PRIOR ART ANALYSIS"):
+        with gr.TabItem("PRIOR ART & STRATEGY"):
             prior_art_output = gr.Markdown(
-                value="### Prior Art Analysis\n\nNeural Prior Art Detective scanning patent databases..."
+                value="### Prior Art Analysis\n\n*Results of the Prior Art Detective's investigation will appear here.*"
             )
         with gr.TabItem("TECHNICAL SUMMARY"):
             summary_output = gr.Markdown(
-                value="### Invention Summary\n\nTechnical Writer synthesizing narrative structure..."
+                value="### Invention Summary\n\n*The Technical Writer's summary, aligned with the final strategy, will appear here.*"
             )
         with gr.TabItem("TECHNICAL FIGURES"):
             figures_output = gr.Markdown(
-                value="### Technical Figures\n\nFigure Synthesizer generating visual documentation matrix..."
+                value="### Technical Figures\n\n*The Figure Drafter's output, illustrating the core strategic concept, will appear here.*"
             )
         with gr.TabItem("PATENT CLAIMS"):
             claims_output = gr.Markdown(
-                value="### Patent Claims\n\nClaims Architect optimizing legal protection boundaries..."
+                value="### Patent Claims\n\n*The Claims Drafter's claims, focused on the strategic mandate, will appear here.*"
             )
 
     generate_btn.click(
         fn=run_patent_architect_in_ui,
         inputs=[invention_input],
-        outputs=[opportunities_display, negotiation_display, prior_art_output, summary_output, figures_output, claims_output, status_display]
+        outputs=[negotiation_display, prior_art_output, summary_output, figures_output, claims_output, status_display]
     )
 
     gr.Examples(
         [
-            ["A smart medication adherence system with computer vision verification using a 5MP CMOS sensor and YOLOv8 object detection model. The system analyzes pill shape, color, and size against a trained database of 2000+ medications with 99.2% accuracy. Real-time alerts are sent via LoRaWAN to healthcare providers when missed doses exceed 12-hour thresholds. The system includes tamper detection through RFID tags and integrates with EMR systems via FHIR protocol for comprehensive compliance monitoring."],
-            ["A modular vertical farming system with adaptive LED lighting using full-spectrum arrays (400-700nm) controlled by neural network analysis of plant reflectance spectra. The system employs RGB+NIR sensors to monitor chlorophyll content and adjusts light intensity (50-1000 μmol/m²/s) and spectrum ratios based on growth stage detection. Machine learning models trained on 500+ crop cycles optimize photosynthetic photon flux density while reducing energy consumption by 35% compared to static lighting systems."], 
-            ["A real-time presentation skills assessment device using micro-expression analysis with 60fps facial recognition and voice stress analysis at 16kHz sampling. The system employs convolutional neural networks trained on 10,000+ presentation recordings to detect confidence indicators including facial micro-movements, vocal pitch variations (±50Hz accuracy), and gesture patterns. Feedback is provided through bone conduction audio and haptic vibration patterns calibrated to individual baseline metrics."],
+            ["My invention is a smart coffee mug that uses a novel phase-change material to keep coffee at a perfect temperature. It also has a mobile app that connects via Bluetooth to let the user set their preferred temperature. The key innovation is a machine learning algorithm that learns the user's drinking habits to pre-warm or cool the mug, optimizing energy use."],
+            ["A modular vertical farming system with adaptive LED lighting using full-spectrum arrays (400-700nm) controlled by neural network analysis of plant reflectance spectra. The system employs RGB+NIR sensors to monitor chlorophyll content and adjusts light intensity (50-1000 μmol/m²/s) and spectrum ratios based on growth stage detection. Machine learning models trained on 500+ crop cycles optimize photosynthetic photon flux density while reducing energy consumption by 35% compared to static lighting systems."],
         ],
         inputs=[invention_input],
-        label="NEURAL TRAINING EXAMPLES | High-Specification Technical Inputs"
+        label="HIGH-SPECIFICATION TECHNICAL INPUT EXAMPLES"
     )
 
     gr.HTML("""
     <style>
-    /* Neon Noir 80s Button Styling */
+    /* Style remains the same */
     .gradio-button.primary {
         background: linear-gradient(45deg, #00ff41, #ffff00) !important;
         border: 2px solid #00ff41 !important;
@@ -935,13 +423,11 @@ EXAMPLE NEURAL INPUT: "Autonomous beverage temperature regulation system utilizi
         border-color: #ffff00 !important;
     }
     
-    /* Dark theme for the overall interface */
     .gradio-container {
         background: #0a0a0a !important;
         font-family: 'Courier New', monospace !important;
     }
     
-    /* Tab styling */
     .tab-nav button {
         background: linear-gradient(45deg, #1a1a1a, #0a0a0a) !important;
         border: 1px solid #00ff41 !important;
@@ -957,7 +443,6 @@ EXAMPLE NEURAL INPUT: "Autonomous beverage temperature regulation system utilizi
         box-shadow: 0 0 10px #00ff41 !important;
     }
     
-    /* Input field styling */
     .gr-textbox {
         background: linear-gradient(45deg, #0a0a0a, #1a1a1a) !important;
         border: 1px solid #00ff41 !important;
@@ -970,69 +455,19 @@ EXAMPLE NEURAL INPUT: "Autonomous beverage temperature regulation system utilizi
         box-shadow: 0 0 10px #ffff00 !important;
     }
     
-    /* Remove default fonts and prevent loading errors */
     * {
         font-family: 'Courier New', monospace !important;
     }
-    
-    /* Scanline effect overlay */
-    body::before {
-        content: '';
-        position: fixed;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        background: repeating-linear-gradient(
-            0deg,
-            transparent,
-            transparent 2px,
-            rgba(0,255,65,0.03) 2px,
-            rgba(0,255,65,0.03) 4px
-        );
-        pointer-events: none;
-        z-index: 1000;
-    }
     </style>
-    
-    <script>
-    // Suppress browser errors and warnings
-    const originalConsoleError = console.error;
-    console.error = function(...args) {
-        const message = args.join(' ');
-        if (message.includes('manifest.json') || 
-            message.includes('Failed to load resource') ||
-            message.includes('postMessage') ||
-            message.includes('preload CSS') ||
-            message.includes('.woff2')) {
-            return; // Skip these specific errors
-        }
-        originalConsoleError.apply(console, args);
-    };
-    
-    // Add glitch effect to title
-    document.addEventListener('DOMContentLoaded', function() {
-        const title = document.querySelector('h1');
-        if (title) {
-            setInterval(() => {
-                if (Math.random() < 0.1) {
-                    title.style.textShadow = '2px 0 #ff8c00, -2px 0 #00ff41';
-                    setTimeout(() => {
-                        title.style.textShadow = '0 0 10px #00ff41, 0 0 20px #00ff41, 0 0 30px #00ff41';
-                    }, 100);
-                }
-            }, 2000);
-        }
-    });
-    </script>
     """)
 
 if __name__ == "__main__":
-    print("PATENT ARCHITECT v2 - Enhanced with Google Gemini 2.0 Flash + Real AI Agents")
-    print(f"Backend: {MODAL_BACKEND_URL}")
-    print(f"Gemini Image Generation: {'ONLINE' if GEMINI_IMAGE_AVAILABLE else 'OFFLINE'}")
-    print(f"Real AI Agents: {'ONLINE' if REAL_AI_AGENTS_AVAILABLE else 'OFFLINE'}")
-    print(f"Nebius Fallback: {'ONLINE' if NEBIUS_AVAILABLE else 'OFFLINE'}")
+    print("PATENT ARCHITECT v2 - True Agentic Negotiation Workflow")
+    print(f"Agentic Backend: {'ONLINE' if AGENTIC_BACKEND_AVAILABLE else 'OFFLINE'}")
+    if not os.getenv("GEMINI_API_KEY"):
+        print("⚠️ WARNING: GEMINI_API_KEY environment variable not set. Gemini-powered agents will not function.")
+    if not os.getenv("SEGMIND_API_KEY"):
+        print("⚠️ WARNING: SEGMIND_API_KEY environment variable not set. Ideogram image generation will not function.")
     demo.queue().launch(
         share=False,
         show_error=True

real_ai_agents_implementation.py

@@ -1,551 +1,320 @@
 #!/usr/bin/env python3
 """
-Real AI Agent Implementation for Patent Architect AI v2
-Designed by thinking like both an IP expert and AI agent expert.
-
-These agents address actual patent attorney pain points with measurable business value.
+True Agentic Implementation for Patent Architect AI v2
+This version implements a genuine, stateful, multi-agent negotiation workflow
+where agent outputs dynamically influence subsequent agent actions.
 """
 
-import re
+import os
 import json
-from typing import Dict, List, Optional, Tuple
-from dataclasses import dataclass
-from enum import Enum
+import re
+import base64
+import requests
+from typing import Dict, List, Optional, Tuple, Generator
+from dataclasses import dataclass, field
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# --- Configuration ---
+load_dotenv()
+# Configure Gemini
+try:
+    genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+    GEMINI_AVAILABLE = True
+except (ValueError, TypeError) as e:
+    print(f"Gemini API key not found or invalid: {e}")
+    GEMINI_AVAILABLE = False
+
 
-# Core Data Structures
+# --- Data Structures ---
 @dataclass
-class TechnicalElement:
-    element_type: str
-    importance: str  # 'critical', 'important', 'optional'
-    present: bool
-    suggestion: str
-    examples: List[str]
-
-class InventionType(Enum):
-    MECHANICAL = "mechanical"
-    ELECTRICAL = "electrical" 
-    SOFTWARE = "software"
-    CHEMICAL = "chemical"
-
-# ============================================================================
-# AGENT 1: Technical Completeness Validator
-# ============================================================================
-
-class TechnicalCompletenessAgent:
-    """
-    Real AI agent that ensures patent applications meet technical disclosure requirements.
-    
-    Addresses: 35 U.S.C. §112 rejections for inadequate disclosure ($5K-15K prosecution costs)
-    """
-    
-    def __init__(self):
-        self.required_elements = {
-            InventionType.MECHANICAL: {
-                'materials': {
-                    'importance': 'critical',
-                    'examples': ['steel, aluminum, carbon fiber', 'specific alloy compositions'],
-                    'suggestion': 'Specify materials used in each component with properties'
-                },
-                'dimensions': {
-                    'importance': 'important', 
-                    'examples': ['length: 10-50cm', 'thickness: 2-5mm'],
-                    'suggestion': 'Provide dimensional ranges that enable reproduction'
-                }
-            },
-            InventionType.ELECTRICAL: {
-                'voltages': {
-                    'importance': 'critical',
-                    'examples': ['5V DC', '120-240V AC', '3.3V logic levels'],
-                    'suggestion': 'Specify all operating voltages and power requirements'
-                },
-                'frequencies': {
-                    'importance': 'critical',
-                    'examples': ['2.4GHz WiFi', '60Hz AC', '100MHz-1GHz'],
-                    'suggestion': 'Define frequency ranges for all signals'
-                }
-            },
-            InventionType.SOFTWARE: {
-                'algorithms': {
-                    'importance': 'critical',
-                    'examples': ['machine learning (CNN)', 'sorting algorithm', 'encryption (AES-256)'],
-                    'suggestion': 'Describe core algorithms with sufficient detail for implementation'
-                },
-                'performance_metrics': {
-                    'importance': 'important',
-                    'examples': ['response time: <100ms', 'accuracy: >95%', 'throughput: 1000 requests/sec'],
-                    'suggestion': 'Provide quantitative performance specifications'
-                }
-            }
-        }
-    
-    def classify_invention_type(self, invention_text: str) -> InventionType:
-        """Classify invention type based on description content."""
-        text_lower = invention_text.lower()
-        
-        if any(term in text_lower for term in ['algorithm', 'software', 'app', 'machine learning', 'ai']):
-            return InventionType.SOFTWARE
-        elif any(term in text_lower for term in ['electrical', 'electronic', 'circuit', 'voltage', 'sensor']):
-            return InventionType.ELECTRICAL
-        elif any(term in text_lower for term in ['chemical', 'composition', 'reaction', 'compound']):
-            return InventionType.CHEMICAL
-        else:
-            return InventionType.MECHANICAL
-    
-    def detect_element_presence(self, invention_text: str, element_type: str) -> bool:
-        """Detect if a technical element is adequately described."""
-        text_lower = invention_text.lower()
-        
-        element_patterns = {
-            'materials': [r'\b\w+\s*(?:steel|aluminum|plastic|carbon|alloy|material)\b'],
-            'dimensions': [r'\b\d+\s*(?:mm|cm|m|inch|ft)\b'],
-            'voltages': [r'\b\d+\.?\d*\s*[vV]\b'],
-            'frequencies': [r'\b\d+\.?\d*\s*(?:Hz|khz|mhz|ghz)\b'],
-            'algorithms': [r'\b(?:algorithm|method|process|neural|cnn|lstm)\b'],
-            'performance_metrics': [r'\b\d+\.?\d*\s*(?:%|percent|accuracy|ms|seconds)\b']
-        }
-        
-        patterns = element_patterns.get(element_type, [])
-        return any(re.search(pattern, text_lower) for pattern in patterns)
-    
-    def analyze_disclosure(self, invention_text: str) -> Dict:
-        """
-        Analyze invention disclosure for technical completeness.
-        
-        Returns:
-            Dict with completeness analysis, missing elements, and recommendations
-        """
-        invention_type = self.classify_invention_type(invention_text)
-        required_elements = self.required_elements.get(invention_type, {})
-        
-        analysis_results = []
-        missing_critical = 0
-        missing_important = 0
-        
-        for element_name, element_config in required_elements.items():
-            is_present = self.detect_element_presence(invention_text, element_name)
-            
-            element_analysis = TechnicalElement(
-                element_type=element_name,
-                importance=element_config['importance'],
-                present=is_present,
-                suggestion=element_config['suggestion'],
-                examples=element_config['examples']
-            )
-            
-            analysis_results.append(element_analysis)
-            
-            if not is_present:
-                if element_config['importance'] == 'critical':
-                    missing_critical += 1
-                elif element_config['importance'] == 'important':
-                    missing_important += 1
-        
-        # Calculate completeness score
-        total_elements = len(required_elements)
-        present_elements = sum(1 for el in analysis_results if el.present)
-        completeness_score = (present_elements / total_elements * 100) if total_elements > 0 else 0
-        
-        # Determine prosecution risk
-        if missing_critical > 0:
-            prosecution_risk = "HIGH - Critical elements missing, likely §112 rejection"
-        elif missing_important > 1:
-            prosecution_risk = "MEDIUM - Important elements missing, possible objections"
-        else:
-            prosecution_risk = "LOW - Technical disclosure appears adequate"
-        
-        return {
-            'invention_type': invention_type.value,
-            'completeness_score': completeness_score,
-            'prosecution_risk': prosecution_risk,
-            'missing_critical': missing_critical,
-            'missing_important': missing_important,
-            'missing_elements': [
-                {
-                    'element': el.element_type,
-                    'importance': el.importance,
-                    'suggestion': el.suggestion,
-                    'examples': el.examples
-                }
-                for el in analysis_results if not el.present
-            ]
-        }
+class NegotiationState:
+    invention_disclosure: str
+    key_concepts: List[str] = field(default_factory=list)
+    prior_art_analysis: Dict = field(default_factory=dict)
+    strategic_mandate: str = ""
+    technical_summary: str = ""
+    patent_claims: str = ""
+    figure_description: str = ""
+    ideogram_image_b64: str = ""
+    negotiation_transcript: List[Dict] = field(default_factory=list)
 
-# ============================================================================
-# AGENT 2: Prior Art Landscape Analyzer  
-# ============================================================================
+# --- Base Agent Class ---
+class BaseAgent:
+    def __init__(self, model_name='gemini-1.5-flash'):
+        if not GEMINI_AVAILABLE:
+            self.model = None
+            return
+        self.model = genai.GenerativeModel(model_name)
 
-class PriorArtLandscapeAgent:
-    """
-    Real AI agent that performs competitive landscape analysis.
-    
-    Addresses: Surprise prior art during prosecution ($10K-25K additional costs)
-    """
-    
-    def analyze_landscape(self, invention_description: str) -> Dict:
+    def _execute_prompt(self, prompt: str) -> str:
+        if not self.model:
+            return f"Error: The '{self.__class__.__name__}' agent could not run because the Gemini API is not configured. Please set the GEMINI_API_KEY."
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            print(f"Error executing prompt for {self.__class__.__name__}: {e}")
+            return f"Error: Could not get a response from the model. Details: {e}"
+
+# --- Specialized Agents ---
+class PriorArtDetective(BaseAgent):
+    def analyze(self, invention_disclosure: str) -> Dict:
+        prompt = f"""
+        Analyze the following invention disclosure to identify the key technical concepts and potential areas of prior art.
+        Invention: "{invention_disclosure}"
+
+        1.  List the 3-5 most important technical keywords or concepts.
+        2.  For each concept, generate a list of 2-3 realistic-sounding, representative prior art titles that likely exist.
+        3.  Based on these, write a brief, 2-3 sentence summary of the prior art landscape, assessing how crowded it might be.
+
+        Return the response as a JSON object with keys: "key_concepts", "simulated_prior_art", and "landscape_summary".
         """
-        Perform competitive landscape analysis.
+        response_text = self._execute_prompt(prompt)
+        try:
+            # Clean the response text before parsing
+            clean_response = response_text.strip().replace("```json", "").replace("```", "")
+            return json.loads(clean_response)
+        except json.JSONDecodeError:
+            return {
+                "key_concepts": [],
+                "simulated_prior_art": [],
+                "landscape_summary": "Error parsing prior art analysis from LLM response.",
+            }
+
+class ChiefStrategistAgent(BaseAgent):
+    def formulate_strategy(self, invention_disclosure: str, prior_art_analysis: Dict) -> str:
+        prompt = f"""
+        You are a Chief Patent Strategist. Your job is to determine the strongest angle for a successful patent application.
         
-        Returns:
-            Dict with competitive landscape, risks, and opportunities
+        Invention Disclosure:
+        "{invention_disclosure}"
+
+        Prior Art Analysis:
+        - Key Concepts: {prior_art_analysis.get('key_concepts', [])}
+        - Simulated Prior Art: {prior_art_analysis.get('simulated_prior_art', [])}
+        - Landscape Summary: {prior_art_analysis.get('landscape_summary', '')}
+
+        Based on the above, formulate a clear, one-sentence "Strategic Mandate". This mandate will direct all other agents. It must identify the single most patentable aspect of the invention to focus on.
+
+        Example Mandates:
+        - "The strategic focus shall be on the novel method for data encryption, not the hardware implementation."
+        - "The patentability of this invention rests on the unique chemical composition of the coating material."
+        - "We will patent the specific algorithm for adaptive lighting control, as the general hardware is well-known."
+
+        Formulate the Strategic Mandate for the provided invention.
         """
-        # Mock competitive analysis based on invention content
-        key_competitors = self._identify_key_competitors(invention_description)
-        prosecution_risks = self._assess_prosecution_risks(invention_description)
-        whitespace_opportunities = self._find_whitespace_opportunities(invention_description)
+        return self._execute_prompt(prompt)
+
+class TechnicalWriterAgent(BaseAgent):
+    def write_summary(self, invention_disclosure: str, strategic_mandate: str) -> str:
+        prompt = f"""
+        You are a professional patent writer. Your task is to write a "Summary of the Invention" section for a patent application.
         
-        return {
-            'key_competitors': key_competitors,
-            'prosecution_risks': prosecution_risks,
-            'whitespace_opportunities': whitespace_opportunities,
-            'landscape_summary': self._create_landscape_summary(key_competitors, prosecution_risks)
-        }
-    
-    def _identify_key_competitors(self, invention_text: str) -> List[Dict]:
-        """Identify key competitors based on invention description."""
-        if 'coffee' in invention_text.lower():
-            return [
-                {'company': 'Ember Technologies', 'patents': 45, 'focus': 'Temperature control'},
-                {'company': 'YETI Holdings', 'patents': 23, 'focus': 'Insulation technology'}
-            ]
-        elif 'sensor' in invention_text.lower():
-            return [
-                {'company': 'Honeywell', 'patents': 1200, 'focus': 'Industrial sensors'},
-                {'company': 'Bosch', 'patents': 890, 'focus': 'Automotive sensors'}
-            ]
-        else:
-            return [
-                {'company': 'Generic Tech Corp', 'patents': 150, 'focus': 'Related technology'}
-            ]
-    
-    def _assess_prosecution_risks(self, invention_text: str) -> Dict:
-        """Assess risks for patent prosecution."""
-        text_lower = invention_text.lower()
+        Invention Disclosure: "{invention_disclosure}"
         
-        # Assess risk based on technology maturity
-        if any(term in text_lower for term in ['smart', 'app', 'bluetooth', 'iot']):
-            risk_level = 'MEDIUM'
-            risk_factors = ['Crowded IoT field', 'Many smartphone integration patents']
-        elif any(term in text_lower for term in ['sensor', 'temperature', 'monitoring']):
-            risk_level = 'HIGH'
-            risk_factors = ['Mature sensor technology field', 'Extensive prior art']
-        else:
-            risk_level = 'LOW'
-            risk_factors = ['Novel technology area']
+        **CRITICAL INSTRUCTION:** You must follow this Strategic Mandate provided by the Chief Strategist:
+        **Strategic Mandate: "{strategic_mandate}"**
+
+        Write a concise, professional summary (2-3 paragraphs). Ensure that the summary heavily emphasizes the aspect highlighted in the Strategic Mandate as the core of the invention.
+        """
+        return self._execute_prompt(prompt)
+
+class ClaimsDrafterAgent(BaseAgent):
+    def draft_claims(self, invention_disclosure: str, strategic_mandate: str) -> str:
+        prompt = f"""
+        You are a patent attorney specializing in claim drafting.
         
-        return {
-            'overall_risk': risk_level,
-            'risk_factors': risk_factors,
-            'mitigation_strategies': [
-                'Focus on specific technical improvements',
-                'Emphasize novel combination of features'
-            ]
-        }
-    
-    def _find_whitespace_opportunities(self, invention_text: str) -> List[Dict]:
-        """Find whitespace opportunities in the patent landscape."""
-        return [
-            {
-                'opportunity': 'Mobile app integration',
-                'description': 'Limited patents on smartphone-controlled devices in this space',
-                'potential_value': 'High - growing IoT market'
-            },
-            {
-                'opportunity': 'Machine learning optimization',
-                'description': 'Few patents combine your core technology with ML algorithms',
-                'potential_value': 'Medium - emerging technology trend'
-            }
-        ]
-    
-    def _create_landscape_summary(self, competitors: List[Dict], risks: Dict) -> str:
-        """Create a summary of the competitive landscape."""
-        total_competitors = len(competitors)
-        total_patents = sum(comp.get('patents', 0) for comp in competitors)
+        Invention Disclosure: "{invention_disclosure}"
         
-        return f"""
-        Competitive Landscape Summary:
-        • {total_competitors} key competitors identified
-        • {total_patents} total patents in competitive analysis
-        • Risk level: {risks['overall_risk']}
-        • Recommendation: Focus on specific technical differentiation
+        **CRITICAL INSTRUCTION:** Your claim set MUST be aligned with the following mandate:
+        **Strategic Mandate: "{strategic_mandate}"**
+
+        Draft a set of 5-7 patent claims.
+        - The independent claim (Claim 1) must be directly focused on the feature identified in the Strategic Mandate.
+        - Dependent claims should add further specifics and variations.
+        - Ensure the claims are clear, concise, and properly formatted.
         """
+        return self._execute_prompt(prompt)
+        
+class FigureDrafterAgent(BaseAgent):
+    def describe_figure(self, invention_disclosure: str, strategic_mandate: str) -> str:
+        prompt = f"""
+        You are a patent illustrator's assistant. You need to describe a key technical figure for a patent application.
 
-# ============================================================================
-# AGENT 3: Claim Architecture Strategist
-# ============================================================================
+        Invention Disclosure: "{invention_disclosure}"
 
-class ClaimArchitectureAgent:
-    """
-    Real AI agent that optimizes claim structure for maximum protection.
-    
-    Addresses: Poor claim strategy leading to weak patents
-    """
-    
-    def design_claim_architecture(self, invention_details: Dict, prior_art_analysis: Dict) -> Dict:
+        **CRITICAL INSTRUCTION:** The figure must visually represent the core idea from the mandate:
+        **Strategic Mandate: "{strategic_mandate}"**
+
+        1.  Decide on the best type of figure to illustrate the mandate (e.g., flowchart, system diagram, cross-section).
+        2.  Write a brief description of this figure.
+        3.  Generate the LaTeX/TikZ code to create this figure.
+
+        Return a single response containing both the description and the LaTeX code block.
         """
-        Design strategic claim architecture for maximum protection.
-        
-        Returns:
-            Dict with claim pyramid, prosecution strategy, and strength analysis
+        return self._execute_prompt(prompt)
+
+class SegmindIdeogramAgent:
+    def __init__(self):
+        self.api_key = os.getenv("SEGMIND_API_KEY", "SG_f5de4e5bf40aa615") # Use user's key as default
+        self.url = "https://api.segmind.com/v1/ideogram-3"
+
+    def generate_image(self, technical_summary: str, strategic_mandate: str) -> Optional[str]:
+        if not self.api_key:
+            return None
+
+        # Create a more cinematic prompt for image generation
+        image_prompt = f"""
+        Create a photorealistic, cinematic photograph representing the following invention.
+        The image should focus on the core concept defined by the strategic mandate.
+
+        Invention Summary: "{technical_summary}"
+        Core Concept (Strategic Mandate): "{strategic_mandate}"
+
+        Translate this technical concept into a visually stunning and professional marketing image.
+        Emphasize the most innovative aspect. For example, if it's an algorithm, show a sleek user interface or an abstract representation of data flow, not just the hardware.
         """
-        prosecution_risks = prior_art_analysis.get('prosecution_risks', {})
-        
-        # Design claim pyramid based on risk assessment
-        claim_pyramid = self._design_claim_pyramid(prosecution_risks)
         
-        # Analyze claim strength
-        claim_strength = self._analyze_claim_strength(claim_pyramid, prosecution_risks)
-        
-        return {
-            'claim_pyramid': claim_pyramid,
-            'claim_strength_analysis': claim_strength,
-            'recommendation_summary': self._create_recommendation_summary(claim_strength)
+        data = {
+          "prompt": image_prompt,
+          "resolution": "1024x1024",
+          "style_type": "REALISTIC"
         }
-    
-    def _design_claim_pyramid(self, prosecution_risks: Dict) -> Dict:
-        """Design strategic claim pyramid."""
-        risk_level = prosecution_risks.get('overall_risk', 'MEDIUM')
-        
-        if risk_level == 'HIGH':
-            # Conservative approach for high-risk fields
-            independent_claims = [
-                {'claim_number': 1, 'type': 'apparatus', 'scope': 'narrow', 'strategy': 'Specific implementation'}
-            ]
-        else:
-            # More aggressive approach for lower-risk fields
-            independent_claims = [
-                {'claim_number': 1, 'type': 'apparatus', 'scope': 'broad', 'strategy': 'Cover core invention'},
-                {'claim_number': 8, 'type': 'method', 'scope': 'broad', 'strategy': 'Protect process aspects'}
-            ]
-        
-        return {
-            'independent_claims': independent_claims,
-            'dependent_claims': [
-                {'claim_number': 2, 'depends_on': 1, 'strategy': 'Narrow fallback position'},
-                {'claim_number': 3, 'depends_on': 1, 'strategy': 'Alternative limitation'}
-            ]
-        }
-    
-    def _analyze_claim_strength(self, claim_pyramid: Dict, prosecution_risks: Dict) -> Dict:
-        """Analyze strength of proposed claims."""
-        risk_level = prosecution_risks.get('overall_risk', 'MEDIUM')
-        
-        # Calculate strength based on risk level and claim scope
-        if risk_level == 'HIGH':
-            overall_strength = 60  # Conservative claims in crowded field
-        elif risk_level == 'MEDIUM':
-            overall_strength = 75  # Balanced approach
-        else:
-            overall_strength = 85  # Aggressive claims in open field
-        
-        return {
-            'overall_strength': overall_strength,
-            'grantability': 'Good' if overall_strength > 70 else 'Moderate',
-            'recommendations': self._generate_strength_recommendations(overall_strength)
-        }
-    
-    def _generate_strength_recommendations(self, strength: float) -> List[str]:
-        """Generate recommendations for improving claim strength."""
-        recommendations = []
-        
-        if strength < 70:
-            recommendations.append("Consider narrowing independent claims to improve grantability")
-            recommendations.append("Add more specific technical limitations")
-        
-        recommendations.append("Ensure all claims are fully supported by specification")
-        recommendations.append("Consider adding method claims if not present")
-        
-        return recommendations
-    
-    def _create_recommendation_summary(self, claim_strength: Dict) -> str:
-        """Create summary of claim architecture recommendations."""
-        overall_strength = claim_strength.get('overall_strength', 0)
-        
-        if overall_strength >= 80:
-            assessment = "STRONG - Claims appear well-positioned for prosecution"
-        elif overall_strength >= 65:
-            assessment = "GOOD - Claims have solid foundation with room for improvement"
-        else:
-            assessment = "NEEDS WORK - Claims require significant refinement"
-        
-        return f"""
-        Claim Architecture Assessment: {assessment}
-        Overall Strength: {overall_strength:.0f}/100
-        
-        Key Recommendations:
-        • Focus on specific technical differentiation
-        • Prepare multiple claim strategies for prosecution
-        • Ensure strong specification support
-        """
+        headers = {'x-api-key': self.api_key}
 
-# ============================================================================
-# AGENT COORDINATOR
-# ============================================================================
+        try:
+            response = requests.post(self.url, json=data, headers=headers)
+            if response.status_code == 200:
+                return base64.b64encode(response.content).decode('utf-8')
+            else:
+                print(f"Segmind API Error: {response.status_code} - {response.text}")
+                return None
+        except Exception as e:
+            print(f"Error calling Segmind API: {e}")
+            return None
 
-class InterAgentCoordinator:
-    """
-    Orchestrates collaboration between specialized patent agents.
-    """
-    
-    def __init__(self):
+
+# --- The Orchestrator ---
+class AgenticNegotiator:
+    def __init__(self, invention_disclosure: str):
+        self.state = NegotiationState(invention_disclosure=invention_disclosure)
         self.agents = {
-            'technical_completeness': TechnicalCompletenessAgent(),
-            'prior_art_landscape': PriorArtLandscapeAgent(),
-            'claim_architecture': ClaimArchitectureAgent()
+            "Prior Art Detective": PriorArtDetective(),
+            "Chief Strategist": ChiefStrategistAgent(),
+            "Technical Writer": TechnicalWriterAgent(),
+            "Claims Drafter": ClaimsDrafterAgent(),
+            "Figure Drafter": FigureDrafterAgent(),
+            "Conceptual Artist": SegmindIdeogramAgent(),
         }
-    
-    def orchestrate_patent_development(self, invention_disclosure: str) -> Dict:
-        """
-        Orchestrate complete patent development process with agent collaboration.
-        """
-        results = {}
-        
-        # Phase 1: Technical Completeness Analysis
-        print("🔬 Phase 1: Analyzing technical completeness...")
-        technical_analysis = self.agents['technical_completeness'].analyze_disclosure(invention_disclosure)
-        results['technical_analysis'] = technical_analysis
-        
-        # Phase 2: Prior Art Landscape Analysis
-        print("🔍 Phase 2: Analyzing prior art landscape...")
-        prior_art_analysis = self.agents['prior_art_landscape'].analyze_landscape(invention_disclosure)
-        results['prior_art_analysis'] = prior_art_analysis
-        
-        # Phase 3: Claim Architecture Design
-        print("⚖️ Phase 3: Designing claim architecture...")
-        invention_details = {'description': invention_disclosure}
-        claims_analysis = self.agents['claim_architecture'].design_claim_architecture(
-            invention_details,
-            prior_art_analysis
-        )
-        results['claims_analysis'] = claims_analysis
-        
-        # Phase 4: Integration and Quality Assessment
-        print("🔄 Phase 4: Integrating analysis and assessing quality...")
-        integrated_analysis = self._integrate_agent_outputs(results)
-        results['integrated_analysis'] = integrated_analysis
-        
-        return results
-    
-    def _integrate_agent_outputs(self, agent_results: Dict) -> Dict:
-        """Integrate outputs from all agents into cohesive analysis."""
-        technical = agent_results.get('technical_analysis', {})
-        prior_art = agent_results.get('prior_art_analysis', {})
-        claims = agent_results.get('claims_analysis', {})
-        
-        # Calculate overall patent readiness score
-        technical_score = technical.get('completeness_score', 0)
-        prior_art_risk = prior_art.get('prosecution_risks', {}).get('overall_risk', 'HIGH')
-        claims_strength = claims.get('claim_strength_analysis', {}).get('overall_strength', 0)
-        
-        # Convert prior art risk to score
-        risk_score_map = {'LOW': 85, 'MEDIUM': 70, 'HIGH': 50}
-        prior_art_score = risk_score_map.get(prior_art_risk, 50)
-        
-        overall_readiness = (technical_score + prior_art_score + claims_strength) / 3
-        
-        return {
-            'overall_readiness_score': overall_readiness,
-            'readiness_assessment': self._get_readiness_assessment(overall_readiness),
-            'estimated_prosecution_timeline': self._estimate_timeline(overall_readiness),
-            'estimated_costs': self._estimate_costs(overall_readiness)
-        }
-    
-    def _get_readiness_assessment(self, score: float) -> str:
-        """Get overall readiness assessment."""
-        if score >= 85:
-            return "EXCELLENT - Ready for immediate filing"
-        elif score >= 75:
-            return "GOOD - Minor refinements recommended"
-        elif score >= 65:
-            return "FAIR - Address key issues before filing"
-        else:
-            return "POOR - Significant development needed"
-    
-    def _estimate_timeline(self, readiness_score: float) -> str:
-        """Estimate prosecution timeline based on readiness."""
-        if readiness_score >= 80:
-            return "12-18 months to allowance (well-prepared application)"
-        elif readiness_score >= 65:
-            return "18-24 months to allowance (likely 1-2 office actions)"
-        else:
-            return "24-36 months to allowance (multiple office actions expected)"
-    
-    def _estimate_costs(self, readiness_score: float) -> str:
-        """Estimate prosecution costs based on readiness."""
-        if readiness_score >= 80:
-            return "$8,000-12,000 (minimal prosecution required)"
-        elif readiness_score >= 65:
-            return "$12,000-18,000 (moderate prosecution complexity)"
+
+    def _update_transcript(self, agent_name: str, message: str, data: Optional[Dict] = None):
+        entry = {"agent": agent_name, "message": message, "data": data or {}}
+        self.state.negotiation_transcript.append(entry)
+
+    def run_negotiation(self) -> Generator[NegotiationState, None, None]:
+        # Step 0: Check for Gemini API Key
+        if not GEMINI_AVAILABLE:
+            self._update_transcript("System", "CRITICAL ERROR: `GEMINI_API_KEY` is not set. The agentic workflow cannot proceed. Please configure the environment variable.")
+            yield self.state
+            return
+
+        # Step 1: Prior Art Detective
+        agent_name = "Prior Art Detective"
+        self._update_transcript(agent_name, "Analyzing the invention to understand the technical landscape...")
+        yield self.state
+        
+        prior_art_result = self.agents[agent_name].analyze(self.state.invention_disclosure)
+        self.state.prior_art_analysis = prior_art_result
+        self.state.key_concepts = prior_art_result.get("key_concepts", [])
+        self._update_transcript(agent_name, f"Analysis complete. The landscape appears to be: {prior_art_result.get('landscape_summary', 'N/A')}", prior_art_result)
+        yield self.state
+
+        # Step 2: Chief Strategist
+        agent_name = "Chief Strategist"
+        self._update_transcript(agent_name, "Reviewing prior art to determine the most defensible patenting strategy...")
+        yield self.state
+        
+        mandate = self.agents[agent_name].formulate_strategy(self.state.invention_disclosure, self.state.prior_art_analysis)
+        self.state.strategic_mandate = mandate
+        self._update_transcript(agent_name, f"Strategy formulated. All agents will now adhere to the following mandate: **{mandate}**")
+        yield self.state
+
+        # Step 3: Guided Content Generation
+        # Technical Summary
+        agent_name = "Technical Writer"
+        self._update_transcript(agent_name, "Acknowledged. Drafting the technical summary to align with the strategic mandate.")
+        yield self.state
+        summary = self.agents[agent_name].write_summary(self.state.invention_disclosure, self.state.strategic_mandate)
+        self.state.technical_summary = summary
+        self._update_transcript(agent_name, "Technical summary drafted.")
+        yield self.state
+        
+        # Patent Claims
+        agent_name = "Claims Drafter"
+        self._update_transcript(agent_name, "Understood. Drafting patent claims focused on the mandated novel aspect.")
+        yield self.state
+        claims = self.agents[agent_name].draft_claims(self.state.invention_disclosure, self.state.strategic_mandate)
+        self.state.patent_claims = claims
+        self._update_transcript(agent_name, "Patent claims drafted.")
+        yield self.state
+
+        # Figure Description (LaTeX)
+        agent_name = "Figure Drafter"
+        self._update_transcript(agent_name, "Affirmative. Designing a technical figure that visually represents the core strategic mandate.")
+        yield self.state
+        figure_desc = self.agents[agent_name].describe_figure(self.state.invention_disclosure, self.state.strategic_mandate)
+        self.state.figure_description = figure_desc
+        self._update_transcript(agent_name, "Technical figure description and LaTeX code generated.")
+        yield self.state
+
+        # Conceptual Image (Ideogram)
+        agent_name = "Conceptual Artist"
+        self._update_transcript(agent_name, "Now generating a high-fidelity conceptual image based on the strategy...")
+        yield self.state
+        image_b64 = self.agents[agent_name].generate_image(self.state.technical_summary, self.state.strategic_mandate)
+        if image_b64:
+            self.state.ideogram_image_b64 = image_b64
+            self._update_transcript(agent_name, "Conceptual image generated successfully.")
         else:
-            return "$18,000-30,000 (extensive prosecution likely)"
+            self._update_transcript(agent_name, "Failed to generate conceptual image. The API may be unavailable or the key may be invalid.")
+        yield self.state
 
-# ============================================================================
-# TESTING AND VALIDATION
-# ============================================================================
 
-def test_real_ai_agents():
-    """Test the real AI agent implementation with a sample invention."""
-    print("🤖 Testing Real AI Agent Implementation")
+        self._update_transcript("AgenticNegotiator", "All tasks complete. The patent application is ready for assembly.")
+        yield self.state
+
+def test_agentic_negotiation():
+    """Test the new agentic negotiation workflow."""
+    print("🤖 Testing True Agentic Workflow")
     print("=" * 60)
     
-    # Sample invention for testing
+    if not GEMINI_AVAILABLE:
+        print("\n❌ Cannot run test: GEMINI_API_KEY is not configured.")
+        return
+
     test_invention = """
-    A smart coffee mug that maintains perfect temperature using phase-change materials 
-    and smartphone app control. The mug includes a double-wall design with PCM chambers 
-    that store and release thermal energy. A temperature sensor monitors the coffee 
-    temperature and communicates with a mobile app via Bluetooth. The app allows users 
-    to set preferred temperatures and receive notifications when coffee is ready.
-    
-    The system uses a microcontroller to manage thermal regulation and wireless 
-    communication. Machine learning algorithms analyze user preferences to optimize 
-    heating patterns over time.
+    My invention is a smart coffee mug that uses a novel phase-change material to keep coffee at a perfect temperature. It also has a mobile app that connects via Bluetooth to let the user set their preferred temperature. The key innovation is a machine learning algorithm that learns the user's drinking habits to pre-warm or cool the mug, optimizing energy use.
     """
     
-    # Initialize coordinator and run analysis
-    coordinator = InterAgentCoordinator()
-    results = coordinator.orchestrate_patent_development(test_invention)
-    
-    # Display results
-    print("\n📊 ANALYSIS RESULTS:")
-    print("=" * 40)
-    
-    # Technical Analysis Results
-    technical = results['technical_analysis']
-    print(f"\n🔬 Technical Completeness: {technical['completeness_score']:.1f}%")
-    print(f"   Prosecution Risk: {technical['prosecution_risk']}")
-    print(f"   Missing Critical Elements: {technical['missing_critical']}")
-    if technical['missing_elements']:
-        print("   Missing Elements:")
-        for element in technical['missing_elements'][:3]:
-            print(f"     • {element['element']}: {element['suggestion']}")
-    
-    # Prior Art Results
-    prior_art = results['prior_art_analysis']
-    print(f"\n🔍 Prior Art Analysis:")
-    print(f"   Risk Level: {prior_art['prosecution_risks']['overall_risk']}")
-    print(f"   Key Competitors: {len(prior_art['key_competitors'])}")
-    for competitor in prior_art['key_competitors'][:2]:
-        print(f"     • {competitor['company']}: {competitor['patents']} patents")
+    negotiator = AgenticNegotiator(invention_disclosure=test_invention)
     
-    # Claims Analysis Results
-    claims = results['claims_analysis']
-    print(f"\n⚖️ Claim Architecture:")
-    print(f"   Overall Strength: {claims['claim_strength_analysis']['overall_strength']:.1f}%")
-    print(f"   Grantability: {claims['claim_strength_analysis']['grantability']}")
-    
-    # Overall Assessment
-    integrated = results['integrated_analysis']
-    print(f"\n🎯 OVERALL ASSESSMENT:")
-    print(f"   Readiness Score: {integrated['overall_readiness_score']:.1f}%")
-    print(f"   Assessment: {integrated['readiness_assessment']}")
-    print(f"   Timeline: {integrated['estimated_prosecution_timeline']}")
-    print(f"   Costs: {integrated['estimated_costs']}")
-    
-    print(f"\n✅ Real AI Agents Successfully Implemented!")
-    print("These agents provide genuine value for patent professionals:")
-    print("• Technical completeness validation prevents §112 rejections")
-    print("• Prior art landscape analysis reduces prosecution surprises")
-    print("• Claim architecture optimization maximizes patent value")
-    print("• Integrated assessment provides realistic business planning")
+    final_state = None
+    for i, state in enumerate(negotiator.run_negotiation()):
+        print(f"\n--- Turn {i+1} ---")
+        last_message = state.negotiation_transcript[-1]
+        print(f"**{last_message['agent']}:** {last_message['message']}")
+        final_state = state
+
+    print("\n\n✅ Negotiation Complete!")
+    print("=" * 60)
+    print(f"\n**Final Strategic Mandate:**\n{final_state.strategic_mandate}")
+    print(f"\n**Generated Claims Preview:**\n{final_state.patent_claims[:300]}...")
+    print(f"\n**Generated Figure Description Preview:**\n{final_state.figure_description[:300]}...")
+    if final_state.ideogram_image_b64:
+        print(f"\n**Ideogram Image:** Generated successfully (Base64 data)")
+    else:
+        print(f"\n**Ideogram Image:** Failed to generate.")
 
 if __name__ == "__main__":
-    test_real_ai_agents() 
+    test_agentic_negotiation() 

requirements.txt

@@ -1,6 +1,7 @@
-gradio==4.44.0
-requests==2.31.0
-openai==1.51.0
-pillow==10.0.0
-python-dotenv==1.0.0
-google-generativeai==0.8.3 
+gradio>=4.44.0
+requests>=2.31.0
+openai>=1.51.0
+pillow>=10.0.0
+python-dotenv>=1.0.0
+google-generativeai>=0.8.3
+segmind>=0.2.2