feat(agent1): replace placeholders with inferred condition via heuristics; add dynamic bias parsing\n\n- Add infer_biased_condition() to map case text to a plausible biased dx\n- Replace [primary condition] placeholders in diagnostician output\n- Structure Devil’s Advocate output (Critical Analysis + Identified Biases)\n- Parse dynamic biases in UI and display them clearly\n- Improve readability: enforce dark text color in panels

agents.py

@@ -1,73 +1,102 @@
 import torch
 from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
 import logging
+import re
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 class MedicalAgentSystem:
-    def __init__(self):
-        """Initialize the medical agent system with models and pipelines."""
-        self.model_name = "microsoft/DialoGPT-medium"
-        self.tokenizer = None
-        self.model = None
-        self.generator = None
-        self._load_models()
-    
-    def _load_models(self):
-        """Load the language models and tokenizer."""
-        try:
-            logger.info(f"Loading model: {self.model_name}")
-            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-            self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
-            
-            # Add padding token if not present
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-            
-            # Create text generation pipeline
-            self.generator = pipeline(
-                "text-generation",
-                model=self.model,
-                tokenizer=self.tokenizer,
-                max_length=200,
-                do_sample=True,
-                temperature=0.7,
-                pad_token_id=self.tokenizer.eos_token_id
-            )
-            logger.info("Models loaded successfully")
-            
-        except Exception as e:
-            logger.error(f"Error loading models: {e}")
-            # Fallback to simpler text generation
-            self.generator = self._fallback_generator
-    
-    def _fallback_generator(self, prompt, max_length=100):
-        """Fallback generator when models fail to load."""
-        return [{"generated_text": f"{prompt} [Model unavailable - using fallback logic]"}]
-    
-    def _generate_response(self, prompt, max_length=150):
-        """Generate response using the loaded model."""
-        try:
-            if self.generator:
-                result = self.generator(prompt, max_length=max_length)
-                return result[0]["generated_text"].replace(prompt, "").strip()
-            else:
-                return self._fallback_generator(prompt, max_length)[0]["generated_text"]
-        except Exception as e:
-            logger.error(f"Generation error: {e}")
-            return f"[Generation error: {e}]"
+	def __init__(self):
+		"""Initialize the medical agent system with models and pipelines."""
+		self.model_name = "microsoft/DialoGPT-medium"
+		self.tokenizer = None
+		self.model = None
+		self.generator = None
+		self._load_models()
+	
+	def _load_models(self):
+		"""Load the language models and tokenizer."""
+		try:
+			logger.info(f"Loading model: {self.model_name}")
+			self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+			self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
+			
+			# Add padding token if not present
+			if self.tokenizer.pad_token is None:
+				self.tokenizer.pad_token = self.tokenizer.eos_token
+			
+			# Create text generation pipeline
+			self.generator = pipeline(
+				"text-generation",
+				model=self.model,
+				tokenizer=self.tokenizer,
+				max_length=200,
+				do_sample=True,
+				temperature=0.7,
+				pad_token_id=self.tokenizer.eos_token_id
+			)
+			logger.info("Models loaded successfully")
+			
+		except Exception as e:
+			logger.error(f"Error loading models: {e}")
+			# Fallback to simpler text generation
+			self.generator = self._fallback_generator
+	
+	def _fallback_generator(self, prompt, max_length=100):
+		"""Fallback generator when models fail to load."""
+		return [{"generated_text": f"{prompt} [Model unavailable - using fallback logic]"}]
+	
+	def _generate_response(self, prompt, max_length=150):
+		"""Generate response using the loaded model."""
+		try:
+			if self.generator:
+				result = self.generator(prompt, max_length=max_length)
+				return result[0]["generated_text"].replace(prompt, "").strip()
+			else:
+				return self._fallback_generator(prompt, max_length)[0]["generated_text"]
+		except Exception as e:
+			logger.error(f"Generation error: {e}")
+			return f"[Generation error: {e}]"
+
+
+def infer_biased_condition(case_text: str) -> str:
+	"""Infer a plausible biased primary condition from the case text using simple heuristics.
+	This intentionally leans toward common anchoring/confirmation patterns.
+	"""
+	text = case_text.lower()
+	# Case 1 style: RLQ pain, appendectomy history → anchoring to appendicitis
+	if ("right lower quadrant" in text or "rlq" in text or "append" in text) and "pain" in text:
+		return "acute appendicitis"
+	# Case 2 style: dyspnea/chest tightness + prior MI/HTN/DM → anchoring to unstable angina/ACS
+	if ("shortness of breath" in text or "dyspnea" in text or "chest tightness" in text or "chest pain" in text) and ("myocardial infarction" in text or "stent" in text or "coronary" in text or "heart" in text):
+		return "unstable angina (acute coronary syndrome)"
+	# If many respiratory clues but with cardiac history still anchor to cardiac
+	if ("shortness of breath" in text or "chest tightness" in text) and ("hypertension" in text or "diabetes" in text):
+		return "congestive heart failure exacerbation"
+	# Case 3 style: fatigue + joint pain after URI/strep → availability to post-strep/viral
+	if ("fatigue" in text and ("joint pain" in text or "arthralgia" in text)) and ("upper respiratory" in text or "uri" in text or "streptococcal" in text or "strep" in text):
+		return "post-streptococcal reactive arthritis"
+	# Case 4 style: low back pain radiating, positive SLR → anchor to chronic DDD/sciatica
+	if ("back pain" in text or "lumbar" in text) and ("radiates" in text or "radicul" in text or "straight leg raise" in text):
+		return "lumbar radiculopathy (sciatica)"
+	# Generic anchors
+	if "fever" in text and "cough" in text:
+		return "community-acquired pneumonia"
+	if "abdominal pain" in text and "nausea" in text:
+		return "gastroenteritis"
+	return "most likely condition based on prominent symptoms"
 
 def diagnostician_agent(case_text):
-    """
-    Agent 1: Generates initial diagnosis with intentional bias.
-    Bias: Anchoring on first symptoms, confirmation bias.
-    """
-    agent_system = MedicalAgentSystem()
-    
-    # Biased prompt that encourages anchoring and confirmation bias
-    biased_prompt = f"""As a medical diagnostician, analyze this case and provide an initial diagnosis.
+	"""
+	Agent 1: Generates initial diagnosis with intentional bias.
+	Bias: Anchoring on first symptoms, confirmation bias.
+	"""
+	agent_system = MedicalAgentSystem()
+	
+	# Biased prompt that encourages anchoring and confirmation bias
+	biased_prompt = f"""As a medical diagnostician, analyze this case and provide an initial diagnosis.
 
 Patient Case:
 {case_text}
@@ -75,23 +104,33 @@ Patient Case:
 Instructions: Focus on the most prominent initial symptoms mentioned. Consider previous medical history as highly relevant to current symptoms. Provide a confident, definitive diagnosis based on the most obvious indicators.
 
 Initial Diagnosis:"""
-    
-    response = agent_system._generate_response(biased_prompt)
-    
-    # Clean up response and ensure it's medical in nature
-    if not response or response.startswith("["):
-        response = "Based on the initial symptoms and medical history, I suspect this is a case of [primary condition]. The patient's previous medical issues and current symptoms strongly suggest this diagnosis."
-    
-    return response
+	
+	response = agent_system._generate_response(biased_prompt)
+	
+	# Ensure a concrete condition name replaces any placeholder
+	condition = infer_biased_condition(case_text)
+	
+	# Replace placeholder tokens if present
+	response = re.sub(r"\[\s*primary condition\s*\]", condition, response, flags=re.IGNORECASE)
+	response = response.replace("[condition]", condition)
+	
+	# If the model produced nothing helpful, compose a biased sentence
+	if not response or response.startswith("[") or "[primary condition]" in response or len(response.split()) < 5:
+		response = (
+			f"Based on the initial symptoms and medical history, I suspect this is a case of {condition}. "
+			"The patient's previous medical issues and current symptoms strongly suggest this diagnosis."
+		)
+	
+	return response
 
 def devils_advocate_agent(case_text, diagnosis):
-    """
-    Agent 2: Critiques the initial diagnosis and identifies bias.
-    Focus: Challenge assumptions, identify cured conditions, detect bias.
-    """
-    agent_system = MedicalAgentSystem()
-    
-    critique_prompt = f"""As a medical devil's advocate, critically review this diagnosis and identify potential biases and errors.
+	"""
+	Agent 2: Critiques the initial diagnosis and identifies bias.
+	Focus: Challenge assumptions, identify cured conditions, detect bias.
+	"""
+	agent_system = MedicalAgentSystem()
+	
+	critique_prompt = f"""You are a medical devil's advocate. Critically review the initial diagnosis and identify potential biases and errors.
 
 Patient Case:
 {case_text}
@@ -99,26 +138,41 @@ Patient Case:
 Initial Diagnosis:
 {diagnosis}
 
-Instructions: Challenge the assumptions in this diagnosis. Identify any anchoring bias, confirmation bias, or overemphasis on previous conditions. Consider if previous medical issues are still relevant. Point out overlooked symptoms or alternative explanations.
+Instructions:
+- Challenge the assumptions in this diagnosis and evaluate alternative explanations.
+- Explicitly determine whether any past conditions are likely resolved/cured and thus irrelevant.
+- Identify specific cognitive biases by name if present from this list: Anchoring Bias, Confirmation Bias, Availability Bias, Overconfidence, Premature Closure, Representativeness, Base Rate Neglect, Search Satisficing.
+- Produce your answer in the following two sections exactly:
 
-Critical Analysis:"""
-    
-    response = agent_system._generate_response(critique_prompt)
-    
-    # Clean up response
-    if not response or response.startswith("["):
-        response = "This diagnosis demonstrates several potential biases: 1) Anchoring on initial symptoms without considering the full picture, 2) Overemphasis on previous medical history that may not be relevant, 3) Confirmation bias in interpreting current symptoms. Alternative explanations should be considered."
-    
-    return response
+Critical Analysis:
+[Write a concise critique here]
+
+Identified Biases:
+- [Bias Name]: [One-line justification]
+- [Bias Name]: [One-line justification]
+(Only include items that truly apply. If none, write: None detected.)
+"""
+	
+	response = agent_system._generate_response(critique_prompt)
+	
+	# Clean up response
+	if not response or response.startswith("["):
+		response = (
+			"Critical Analysis: The initial diagnosis likely over-relies on prior history and the first symptoms. "
+			"Identified Biases:\n- Anchoring Bias: Emphasized earliest symptoms despite later conflicting signs.\n"
+			"- Confirmation Bias: Interpreted findings to support the prior condition without adequate differential consideration."
+		)
+	
+	return response
 
 def synthesizer_agent(case_text, diagnosis, critique):
-    """
-    Agent 3: Synthesizes the diagnosis and critique into improved final diagnosis.
-    Approach: Evidence-based, balanced synthesis addressing identified biases.
-    """
-    agent_system = MedicalAgentSystem()
-    
-    synthesis_prompt = f"""As a medical synthesizer, create a balanced, evidence-based final diagnosis by combining the initial diagnosis and critical analysis.
+	"""
+	Agent 3: Synthesizes the diagnosis and critique into improved final diagnosis.
+	Approach: Evidence-based, balanced synthesis addressing identified biases.
+	"""
+	agent_system = MedicalAgentSystem()
+	
+	synthesis_prompt = f"""As a medical synthesizer, create a balanced, evidence-based final diagnosis by combining the initial diagnosis and critical analysis.
 
 Patient Case:
 {case_text}
@@ -126,55 +180,59 @@ Patient Case:
 Initial Diagnosis:
 {diagnosis}
 
-Critical Analysis:
+Critical Analysis and Identified Biases (from Devil's Advocate):
 {critique}
 
-Instructions: Synthesize these perspectives into a balanced final diagnosis. Address all identified biases. Consider both the initial assessment and the critique. Provide a comprehensive, evidence-based conclusion that incorporates all relevant information.
-
-Final Diagnosis:"""
-    
-    response = agent_system._generate_response(synthesis_prompt)
-    
-    # Clean up response
-    if not response or response.startswith("["):
-        response = "After synthesizing the initial diagnosis and critical analysis, the final diagnosis is: [comprehensive diagnosis]. This conclusion addresses the identified biases by [specific improvements] and provides a balanced assessment based on all available evidence."
-    
-    return response
+Instructions: Address the critique and the listed biases explicitly. Provide a differential diagnosis and a most likely diagnosis with justification, and list 2-3 next diagnostic steps.
+
+Final Diagnosis:
+"""
+	
+	response = agent_system._generate_response(synthesis_prompt)
+	
+	# Clean up response
+	if not response or response.startswith("["):
+		response = (
+			"Final Diagnosis: [comprehensive diagnosis]. This integrates the critique by avoiding anchoring and confirmation, "
+			"and proposes next steps: [tests/interventions]."
+		)
+	
+	return response
 
 # Convenience function to run the complete chain
 def run_medical_analysis(case_text):
-    """
-    Run the complete three-agent medical analysis chain.
-    
-    Args:
-        case_text (str): Medical case description
-        
-    Returns:
-        dict: Results from all three agents
-    """
-    try:
-        # Agent 1: Initial diagnosis
-        initial_diagnosis = diagnostician_agent(case_text)
-        
-        # Agent 2: Devil's advocate critique
-        critique = devils_advocate_agent(case_text, initial_diagnosis)
-        
-        # Agent 3: Final synthesis
-        final_diagnosis = synthesizer_agent(case_text, initial_diagnosis, critique)
-        
-        return {
-            "initial_diagnosis": initial_diagnosis,
-            "critique": critique,
-            "final_diagnosis": final_diagnosis,
-            "status": "success"
-        }
-        
-    except Exception as e:
-        logger.error(f"Error in medical analysis chain: {e}")
-        return {
-            "initial_diagnosis": "Error generating diagnosis",
-            "critique": "Error generating critique", 
-            "final_diagnosis": "Error generating final diagnosis",
-            "status": "error",
-            "error": str(e)
-        }
+	"""
+	Run the complete three-agent medical analysis chain.
+	
+	Args:
+		case_text (str): Medical case description
+		
+	Returns:
+		dict: Results from all three agents
+	"""
+	try:
+		# Agent 1: Initial diagnosis
+		initial_diagnosis = diagnostician_agent(case_text)
+		
+		# Agent 2: Devil's advocate critique
+		critique = devils_advocate_agent(case_text, initial_diagnosis)
+		
+		# Agent 3: Final synthesis
+		final_diagnosis = synthesizer_agent(case_text, initial_diagnosis, critique)
+		
+		return {
+			"initial_diagnosis": initial_diagnosis,
+			"critique": critique,
+			"final_diagnosis": final_diagnosis,
+			"status": "success"
+		}
+		
+	except Exception as e:
+		logger.error(f"Error in medical analysis chain: {e}")
+		return {
+			"initial_diagnosis": "Error generating diagnosis",
+			"critique": "Error generating critique", 
+			"final_diagnosis": "Error generating final diagnosis",
+			"status": "error",
+			"error": str(e)
+		}

app.py

@@ -1,80 +1,107 @@
 import gradio as gr
 import time
+import re
 from agents import run_medical_analysis
 from cases import get_case_titles, get_case_description, get_bias_analysis
 
 # Global variable to store current analysis results
 current_results = None
 
+def extract_dynamic_biases(critique_text: str) -> str:
+	"""Extract a dynamic list of biases from the Devil's Advocate output."""
+	if not critique_text:
+		return "No critique available."
+	# Look for the "Identified Biases:" section and parse bullet lines
+	section_match = re.search(r"Identified Biases:\n([\s\S]*)", critique_text)
+	if not section_match:
+		return "Identified Biases: None detected."
+	section = section_match.group(1)
+	# Stop at next empty line or section-like header
+	section = re.split(r"\n\s*\n|\n[A-Z][A-Za-z ]+:\n", section, maxsplit=1)[0]
+	bullets = []
+	for line in section.splitlines():
+		line = line.strip()
+		if line.startswith("-"):
+			bullets.append(line.lstrip("- "))
+	# Fallback if model wrote a single-line "None detected."
+	if not bullets:
+		if "none" in section.lower():
+			return "**Identified Biases:** None detected."
+		return "**Identified Biases:** Unable to parse."
+	# Render nicely
+	rendered = "\n".join([f"- {b}" for b in bullets])
+	return f"**Identified Biases (dynamic):**\n\n{rendered}"
+
 def analyze_medical_case(case_input, custom_case_text=""):
-    """
-    Run the complete medical analysis using the three-agent system.
-    
-    Args:
-        case_input (str): Selected case ID from dropdown
-        custom_case_text (str): Custom case text input
-        
-    Returns:
-        tuple: (case_display, agent1_output, agent2_output, agent3_output, bias_analysis)
-    """
-    global current_results
-    
-    # Determine which case to analyze
-    if case_input == "custom" and custom_case_text.strip():
-        case_text = custom_case_text.strip()
-        case_display = f"**Custom Case:**\n\n{case_text}"
-        bias_analysis = "Custom case - bias analysis will be generated by the agents"
-    else:
-        case_text = get_case_description(case_input)
-        case_display = f"**{get_case_titles()[case_input]}**\n\n{case_text}"
-        bias_info = get_bias_analysis(case_input)
-        bias_analysis = f"**Expected Bias Types:** {bias_info['bias_type']}\n\n**Expected Bias Pattern:** {bias_info['expected_bias']}"
-    
-    # Run the three-agent analysis
-    try:
-        results = run_medical_analysis(case_text)
-        current_results = results
-        
-        if results["status"] == "success":
-            return (
-                case_display,
-                f"**Agent 1 (Diagnostician) - Initial Diagnosis:**\n\n{results['initial_diagnosis']}",
-                f"**Agent 2 (Devil's Advocate) - Critical Analysis:**\n\n{results['critique']}",
-                f"**Agent 3 (Synthesizer) - Final Diagnosis:**\n\n{results['final_diagnosis']}",
-                bias_analysis
-            )
-        else:
-            error_msg = f"Error in analysis: {results.get('error', 'Unknown error')}"
-            return (
-                case_display,
-                f"**Error:** {error_msg}",
-                f"**Error:** {error_msg}",
-                f"**Error:** {error_msg}",
-                bias_analysis
-            )
-            
-    except Exception as e:
-        error_msg = f"Unexpected error: {str(e)}"
-        return (
-            case_display,
-            f"**Error:** {error_msg}",
-            f"**Error:** {error_msg}",
-            f"**Error:** {error_msg}",
-            bias_analysis
-        )
+	"""
+	Run the complete medical analysis using the three-agent system.
+	
+	Args:
+		case_input (str): Selected case ID from dropdown
+		custom_case_text (str): Custom case text input
+		
+	Returns:
+		tuple: (case_display, agent1_output, agent2_output, agent3_output, bias_analysis)
+	"""
+	global current_results
+	
+	# Determine which case to analyze
+	if case_input == "custom" and custom_case_text.strip():
+		case_text = custom_case_text.strip()
+		case_display = f"**Custom Case:**\n\n{case_text}"
+		static_bias = ""
+	else:
+		case_text = get_case_description(case_input)
+		case_display = f"**{get_case_titles()[case_input]}**\n\n{case_text}"
+		bias_info = get_bias_analysis(case_input)
+		static_bias = f"\n\n> Static bias hint: {bias_info['bias_type']} — {bias_info['expected_bias']}" if bias_info else ""
+	
+	# Run the three-agent analysis
+	try:
+		results = run_medical_analysis(case_text)
+		current_results = results
+		
+		if results["status"] == "success":
+			dynamic_bias = extract_dynamic_biases(results.get("critique", ""))
+			return (
+				case_display,
+				f"**Agent 1 (Diagnostician) - Initial Diagnosis:**\n\n{results['initial_diagnosis']}",
+				f"**Agent 2 (Devil's Advocate) - Critical Analysis:**\n\n{results['critique']}",
+				f"**Agent 3 (Synthesizer) - Final Diagnosis:**\n\n{results['final_diagnosis']}",
+				f"{dynamic_bias}{static_bias}"
+			)
+		else:
+			error_msg = f"Error in analysis: {results.get('error', 'Unknown error')}"
+			return (
+				case_display,
+				f"**Error:** {error_msg}",
+				f"**Error:** {error_msg}",
+				f"**Error:** {error_msg}",
+				""
+			)
+			
+	except Exception as e:
+		error_msg = f"Unexpected error: {str(e)}"
+		return (
+			case_display,
+			f"**Error:** {error_msg}",
+			f"**Error:** {error_msg}",
+			f"**Error:** {error_msg}",
+			""
+		)
 
 def clear_analysis():
-    """Clear all analysis outputs."""
-    global current_results
-    current_results = None
-    return "", "", "", "", ""
+	"""Clear all analysis outputs."""
+	global current_results
+	current_results = None
+	return "", "", "", "", ""
 
 def get_learning_points():
-    """Generate learning points based on the current analysis."""
-    if not current_results or current_results.get("status") != "success":
-        return "No analysis results available. Please run an analysis first."
-    
-    learning_points = """
+	"""Generate learning points based on the current analysis."""
+	if not current_results or current_results.get("status") != "success":
+		return "No analysis results available. Please run an analysis first."
+	
+	learning_points = """
 ## 🎯 Key Learning Points from This Analysis
 
 ### 1. **Bias Identification**
@@ -102,182 +129,189 @@ def get_learning_points():
 - **Agent 2**: Identifies and challenges biases
 - **Agent 3**: Synthesizes for improved final diagnosis
 """
-    return learning_points
+	return learning_points
 
 # Create the Gradio interface
 def create_interface():
-    """Create and configure the Gradio interface."""
-    
-    with gr.Blocks(
-        title="Devil's Advocate Multi-Agent Medical Analysis System",
-        theme=gr.themes.Soft(),
-        css="""
-        .bias-highlight { 
-            background-color: #fff3cd; 
-            border-left: 4px solid #ffc107; 
-            padding: 10px; 
-            margin: 10px 0; 
-        }
-        .agent-output { 
-            background-color: #f8f9fa; 
-            border: 1px solid #dee2e6; 
-            border-radius: 5px; 
-            padding: 15px; 
-            margin: 10px 0; 
-        }
-        .case-display { 
-            background-color: #e3f2fd; 
-            border: 1px solid #2196f3; 
-            border-radius: 5px; 
-            padding: 15px; 
-            margin: 10px 0; 
-        }
-        """
-    ) as interface:
-        
-        gr.Markdown("""
-        # 🏥 Devil's Advocate Multi-Agent Medical Analysis System
-        
-        This demo shows how multiple AI agents can overcome diagnostic bias by simulating a clinical review process.
-        
-        ## How It Works:
-        1. **Agent 1 (Diagnostician)**: Provides initial diagnosis (may be biased)
-        2. **Agent 2 (Devil's Advocate)**: Critiques and identifies bias
-        3. **Agent 3 (Synthesizer)**: Creates improved final diagnosis
-        
-        ## Instructions:
-        - Select a sample case or input your own medical case
-        - Click "Run Analysis" to see the three-agent process
-        - Observe how bias is identified and addressed
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📋 Case Selection")
-                
-                # Case selection dropdown
-                case_dropdown = gr.Dropdown(
-                    choices=["Select a case..."] + list(get_case_titles().keys()),
-                    label="Choose a Sample Case",
-                    value="Select a case...",
-                    interactive=True
-                )
-                
-                # Custom case input
-                custom_case = gr.Textbox(
-                    label="Or Input Custom Medical Case",
-                    placeholder="Describe the patient's symptoms, history, and examination findings...",
-                    lines=8,
-                    interactive=True
-                )
-                
-                # Analysis button
-                analyze_btn = gr.Button(
-                    "🔍 Run Analysis",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                # Clear button
-                clear_btn = gr.Button(
-                    "🗑️ Clear Analysis",
-                    variant="secondary"
-                )
-                
-                # Learning points button
-                learning_btn = gr.Button(
-                    "📚 Show Learning Points",
-                    variant="secondary"
-                )
-            
-            with gr.Column(scale=2):
-                gr.Markdown("### 📊 Analysis Results")
-                
-                # Case display
-                case_display = gr.Markdown(
-                    label="Case Information",
-                    elem_classes=["case-display"]
-                )
-                
-                # Agent outputs
-                agent1_output = gr.Markdown(
-                    label="Agent 1: Initial Diagnosis",
-                    elem_classes=["agent-output"]
-                )
-                
-                agent2_output = gr.Markdown(
-                    label="Agent 2: Devil's Advocate Critique",
-                    elem_classes=["agent-output"]
-                )
-                
-                agent3_output = gr.Markdown(
-                    label="Agent 3: Final Synthesis",
-                    elem_classes=["agent-output"]
-                )
-                
-                # Bias analysis
-                bias_analysis = gr.Markdown(
-                    label="Expected Bias Analysis",
-                    elem_classes=["bias-highlight"]
-                )
-                
-                # Learning points
-                learning_points = gr.Markdown(
-                    label="Learning Points",
-                    visible=False
-                )
-        
-        # Event handlers
-        analyze_btn.click(
-            fn=analyze_medical_case,
-            inputs=[case_dropdown, custom_case],
-            outputs=[case_display, agent1_output, agent2_output, agent3_output, bias_analysis]
-        )
-        
-        clear_btn.click(
-            fn=clear_analysis,
-            outputs=[case_display, agent1_output, agent2_output, agent3_output, bias_analysis]
-        )
-        
-        learning_btn.click(
-            fn=get_learning_points,
-            outputs=learning_points
-        )
-        
-        # Show learning points when button is clicked
-        learning_btn.click(
-            fn=lambda: gr.update(visible=True),
-            outputs=learning_points
-        )
-        
-        # Auto-select custom case when custom text is entered
-        def on_custom_text_change(text):
-            if text.strip():
-                return "custom"
-            return case_dropdown.value
-        
-        custom_case.change(
-            fn=on_custom_text_change,
-            inputs=custom_case,
-            outputs=case_dropdown
-        )
-        
-        gr.Markdown("""
-        ---
-        **Note**: This is a demonstration system for educational purposes. 
-        The AI agents simulate medical reasoning but should not be used for actual clinical decision-making.
-        """)
-    
-    return interface
+	"""Create and configure the Gradio interface."""
+	
+	with gr.Blocks(
+		title="Devil's Advocate Multi-Agent Medical Analysis System",
+		theme=gr.themes.Soft(),
+		css="""
+		/* Ensure dark text for light panels */
+		.bias-highlight, .agent-output, .case-display { 
+			color: #111 !important;
+		}
+		.bias-highlight * , .agent-output * , .case-display * {
+			color: inherit !important;
+		}
+		.bias-highlight { 
+			background-color: #fff3cd; 
+			border-left: 4px solid #ffc107; 
+			padding: 10px; 
+			margin: 10px 0; 
+		}
+		.agent-output { 
+			background-color: #f8f9fa; 
+			border: 1px solid #dee2e6; 
+			border-radius: 5px; 
+			padding: 15px; 
+			margin: 10px 0; 
+		}
+		.case-display { 
+			background-color: #e3f2fd; 
+			border: 1px solid #2196f3; 
+			border-radius: 5px; 
+			padding: 15px; 
+			margin: 10px 0; 
+		}
+		"""
+	) as interface:
+		
+		gr.Markdown("""
+		# 🏥 Devil's Advocate Multi-Agent Medical Analysis System
+		
+		This demo shows how multiple AI agents can overcome diagnostic bias by simulating a clinical review process.
+		
+		## How It Works:
+		1. **Agent 1 (Diagnostician)**: Provides initial diagnosis (may be biased)
+		2. **Agent 2 (Devil's Advocate)**: Critiques and identifies bias
+		3. **Agent 3 (Synthesizer)**: Creates improved final diagnosis
+		
+		## Instructions:
+		- Select a sample case or input your own medical case
+		- Click "Run Analysis" to see the three-agent process
+		- Observe how bias is identified and addressed
+		""")
+		
+		with gr.Row():
+			with gr.Column(scale=1):
+				gr.Markdown("### 📋 Case Selection")
+				
+				# Case selection dropdown
+				case_dropdown = gr.Dropdown(
+					choices=["Select a case..."] + list(get_case_titles().keys()),
+					label="Choose a Sample Case",
+					value="Select a case...",
+					interactive=True
+				)
+				
+				# Custom case input
+				custom_case = gr.Textbox(
+					label="Or Input Custom Medical Case",
+					placeholder="Describe the patient's symptoms, history, and examination findings...",
+					lines=8,
+					interactive=True
+				)
+				
+				# Analysis button
+				analyze_btn = gr.Button(
+					"🔍 Run Analysis",
+					variant="primary",
+					size="lg"
+				)
+				
+				# Clear button
+				clear_btn = gr.Button(
+					"🗑️ Clear Analysis",
+					variant="secondary"
+				)
+				
+				# Learning points button
+				learning_btn = gr.Button(
+					"📚 Show Learning Points",
+					variant="secondary"
+				)
+			
+			with gr.Column(scale=2):
+				gr.Markdown("### 📊 Analysis Results")
+				
+				# Case display
+				case_display = gr.Markdown(
+					label="Case Information",
+					elem_classes=["case-display"]
+				)
+				
+				# Agent outputs
+				agent1_output = gr.Markdown(
+					label="Agent 1: Initial Diagnosis",
+					elem_classes=["agent-output"]
+				)
+				
+				agent2_output = gr.Markdown(
+					label="Agent 2: Devil's Advocate Critique",
+					elem_classes=["agent-output"]
+				)
+				
+				agent3_output = gr.Markdown(
+					label="Agent 3: Final Synthesis",
+					elem_classes=["agent-output"]
+				)
+				
+				# Bias analysis
+				bias_analysis = gr.Markdown(
+					label="Expected Bias Analysis",
+					elem_classes=["bias-highlight"]
+				)
+				
+				# Learning points
+				learning_points = gr.Markdown(
+					label="Learning Points",
+					visible=False
+				)
+		
+		# Event handlers
+		analyze_btn.click(
+			fn=analyze_medical_case,
+			inputs=[case_dropdown, custom_case],
+			outputs=[case_display, agent1_output, agent2_output, agent3_output, bias_analysis]
+		)
+		
+		clear_btn.click(
+			fn=clear_analysis,
+			outputs=[case_display, agent1_output, agent2_output, agent3_output, bias_analysis]
+		)
+		
+		learning_btn.click(
+			fn=get_learning_points,
+			outputs=learning_points
+		)
+		
+		# Show learning points when button is clicked
+		learning_btn.click(
+			fn=lambda: gr.update(visible=True),
+			outputs=learning_points
+		)
+		
+		# Auto-select custom case when custom text is entered
+		def on_custom_text_change(text):
+			if text.strip():
+				return "custom"
+			return case_dropdown.value
+		
+		custom_case.change(
+			fn=on_custom_text_change,
+			inputs=custom_case,
+			outputs=case_dropdown
+		)
+		
+		gr.Markdown("""
+		---
+		**Note**: This is a demonstration system for educational purposes. 
+		The AI agents simulate medical reasoning but should not be used for actual clinical decision-making.
+		""")
+	
+	return interface
 
 # Main execution
 if __name__ == "__main__":
-    # Create and launch the interface
-    interface = create_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        quiet=False
-    )
+	# Create and launch the interface
+	interface = create_interface()
+	interface.launch(
+		server_name="0.0.0.0",
+		server_port=7860,
+		share=False,
+		show_error=True,
+		quiet=False
+	)