fix(ui): simplify BYOK settings with auto-detection (#58)

* docs: add UI simplification spec for BYOK cleanup

Addresses GitHub issues #52 and #53:
- Remove api_provider dropdown (auto-detect from key prefix)
- Simplify examples table to just query + mode
- Clearer free tier messaging

Spec: docs/bugs/FIX_UI_SIMPLIFICATION.md

* docs: update UI simplification spec with senior review fixes

Incorporates all feedback from senior review:
- Change 6: Fix Advanced mode check (was using removed param)
- Change 7: Remove 'Using your X key' message (would crash)
- Change 8: Remove api_provider from function call
- All 11 changes now explicitly documented with line numbers
- Added GPT-5.1 and Claude Sonnet 4.5 to compatibility matrix
- Added comprehensive testing checklist

* fix(ui): simplify BYOK settings with auto-detection

Removes api_provider dropdown and auto-detects provider from key prefix (sk- vs sk-ant-). Simplifies examples table and clarifies free tier messaging.

Fixes #52, Fixes #53

* fix(ui): remove empty API key column from examples table

* docs: add UI/UX brainstorming for mode selection

Documents current state after PR #58:
- Anthropic key only works for Simple mode (no AnthropicChatClient)
- Advanced mode requires OpenAI key (Magentic limitation)
- Screenshot analysis showing current UI issues
- Decision needed: remove Anthropic or keep?

* fix(ui): apply CodeRabbit review suggestions

- Use ConfigurationError instead of ValueError for invalid API key
- Add env var override for server_name with nosec B104 comment

docs/brainstorming/UI_MODE_SELECTION_UX.md

@@ -0,0 +1,133 @@
+# UI/UX Brainstorm: Mode Selection & API Key Experience
+
+**Date**: 2025-11-28
+**Status**: IMPLEMENTED (2025-11-28)
+**Related**: Issues #52, #53, PR #58
+
+---
+
+## CRITICAL FINDING: Anthropic Key is Nearly Useless
+
+**Code verification** (2025-11-28):
+```
+grep -r "AnthropicChatClient" src/  → NO RESULTS
+grep -r "OpenAIChatClient" src/     → 22 RESULTS (all Magentic agents)
+```
+
+The `agent-framework` package (Microsoft's Magentic) **ONLY** has `OpenAIChatClient`.
+There is no `AnthropicChatClient`. This means:
+
+| Feature | OpenAI Key | Anthropic Key |
+|---------|------------|---------------|
+| Simple mode (Judge LLM) | ✅ GPT-5.1 | ✅ Claude Sonnet 4.5 |
+| Advanced mode (Multi-agent) | ✅ Full orchestration | ❌ **DOES NOT WORK** |
+| Value proposition | Full access | Simple mode only |
+
+**Decision**: Keep Anthropic support for Simple mode, but ensure UX clearly differentiates capabilities.
+
+---
+
+## Current State (After PR #58)
+
+### What Users See (Screenshot 2025-11-28)
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ ≡ Examples                                                                   │
+├──────────────────────────────────────────────────────┬──────────────────────┤
+│                                                      │ Orchestrator Mode    │
+├──────────────────────────────────────────────────────┼──────────────────────┤
+│ What drugs improve female libido post-menopause?     │ simple               │
+│ Clinical trials for erectile dysfunction altern...   │ advanced             │
+│ Evidence for testosterone therapy in women with...   │ simple               │
+└──────────────────────────────────────────────────────┴──────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ ⚙️ Mode & API Key (Free tier works!)                                  [▼]   │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│ Orchestrator Mode                                                           │
+│ ⚡ Simple: Fast (Free/Any Key) | 🔬 Advanced: Deep Multi-Agent (OpenAI Key Only)    │
+│ [● simple] [○ advanced]                                                     │
+│                                                                             │
+│ 🔑 API Key (Optional)                                                       │
+│ Leave empty for free tier. Auto-detects provider from key prefix.           │
+│ ┌─────────────────────────────────────────────────────────────────────────┐ │
+│ │ sk-... (OpenAI) or sk-ant-... (Anthropic)                               │ │
+│ └─────────────────────────────────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Observations from Screenshot
+
+1. **Examples table**: 2 columns (Query + Mode) - clean, one example now shows "advanced" ✅
+2. **One example shows "advanced"**: Improves discoverability of Advanced mode ✅
+3. **Accordion collapsed by default**: Still collapsed, but with more inviting label ✅
+4. **Placeholder mentions Anthropic**: Correct, but now clearly tied to Simple mode only via info text ✅
+5. **"Advanced: Requires OpenAI key"**: Now more prominent with emojis and clearer phrasing in info text ✅
+
+### The Two Modes
+
+| Mode | Backend | Capabilities | Requirements |
+|------|---------|--------------|--------------|
+| **Simple** | Linear orchestrator | Search → Judge → Report (single pass) | None (free tier) or any API key |
+| **Advanced** | Magentic multi-agent | SearchAgent, JudgeAgent, HypothesisAgent, ReportAgent working together with iterative refinement | **OpenAI API key only** |
+
+---
+
+## Problems Identified (Addressed)
+
+### P1: Advanced Mode is Hidden → ADDRESSED
+- **Fix**: One example now shows "advanced" mode.
+- **Fix**: Accordion label is more descriptive.
+
+### P2: Mode/Key Relationship is Unclear → ADDRESSED
+- **Fix**: `gr.Radio` info text clearly states "OpenAI Key Only" for Advanced mode, using emojis for emphasis.
+
+### P3: No Incentive to Try Advanced → PARTIALLY ADDRESSED
+- **Fix**: Emojis and "Deep Multi-Agent" hint at the value. Further marketing/documentation still needed for full "wow" moment.
+
+### P4: Anthropic Users Left Out → ADDRESSED (Clarified)
+- **Fix**: Anthropic keys still work for Simple mode, and the info text clarifies the limitation for Advanced mode.
+
+---
+
+## Options to Consider (Decision Made)
+
+The recommendation of **Modified Option A (Better Education + Examples)** with slight modification to accordion label was implemented.
+
+---
+
+## Implementation Notes (Completed)
+
+```python
+# From src/app.py
+examples=[
+    ["What drugs improve female libido post-menopause?", "simple"],
+    ["Clinical trials for erectile dysfunction alternatives to PDE5 inhibitors?", "advanced"],  # Changed
+    ["Evidence for testosterone therapy in women with HSDD?", "simple"],
+],
+
+additional_inputs_accordion=gr.Accordion(
+    label="⚙️ Mode & API Key (Free tier works!)", # Changed
+    open=False
+),
+
+gr.Radio(
+    choices=["simple", "advanced"],
+    value="simple",
+    label="Orchestrator Mode",
+    info=( # Changed
+        "⚡ Simple: Fast (Free/Any Key) | "
+        "🔬 Advanced: Deep Multi-Agent (OpenAI Key Only)"
+    ),
+),
+```
+
+---
+
+## Decision Log
+
+| Date | Decision | Rationale |
+|------|----------|-----------|
+| 2025-11-28 | Implemented Modified Option A | Minimal changes, high impact on discoverability, graceful fallback, user-approved accordion label. |

docs/bugs/FIX_UI_SIMPLIFICATION.md

@@ -0,0 +1,314 @@
+# UI Simplification: Remove API Provider Dropdown
+
+**Issues**: #52, #53
+**Priority**: P1 - UX improvement for hackathon demo
+**Estimated Time**: 30 minutes
+**Senior Review**: ✅ Approved with changes (incorporated below)
+
+---
+
+## Problem
+
+The current UI has confusing BYOK (Bring Your Own Key) settings:
+
+1. **Provider dropdown is misleading** - Shows "openai" but actually uses free tier when no key
+2. **Examples table shows useless columns** - API Key (empty), Provider (ignored)
+3. **Anthropic doesn't work with Advanced mode** - Only OpenAI has `agent-framework` support
+
+## Solution
+
+Remove `api_provider` dropdown entirely. Auto-detect provider from key prefix.
+
+**Functionality preserved:**
+- Simple mode: Free tier, OpenAI, OR Anthropic (all work)
+- Advanced mode: OpenAI only (Magentic multi-agent requires `OpenAIChatClient`)
+
+---
+
+## Implementation
+
+### File: `src/app.py`
+
+#### Change 1: Update `configure_orchestrator()` signature (lines 23-28)
+
+```python
+# BEFORE
+def configure_orchestrator(
+    use_mock: bool = False,
+    mode: str = "simple",
+    user_api_key: str | None = None,
+    api_provider: str = "openai",  # ← REMOVE
+) -> tuple[Any, str]:
+
+# AFTER
+def configure_orchestrator(
+    use_mock: bool = False,
+    mode: str = "simple",
+    user_api_key: str | None = None,
+) -> tuple[Any, str]:
+```
+
+#### Change 2: Update docstring (lines 29-40)
+
+```python
+# AFTER
+    """
+    Create an orchestrator instance.
+
+    Args:
+        use_mock: If True, use MockJudgeHandler (no API key needed)
+        mode: Orchestrator mode ("simple" or "advanced")
+        user_api_key: Optional user-provided API key (BYOK) - auto-detects provider
+
+    Returns:
+        Tuple of (Orchestrator instance, backend_name)
+    """
+```
+
+#### Change 3: Replace provider logic with auto-detection (lines 62-88)
+
+```python
+# BEFORE (lines 62-88) - complex provider checking with api_provider param
+
+# AFTER - auto-detect from key prefix
+    # 2. Paid API Key (User provided or Env)
+    elif user_api_key and user_api_key.strip():
+        # Auto-detect provider from key prefix
+        model: AnthropicModel | OpenAIModel
+        if user_api_key.startswith("sk-ant-"):
+            # Anthropic key
+            anthropic_provider = AnthropicProvider(api_key=user_api_key)
+            model = AnthropicModel(settings.anthropic_model, provider=anthropic_provider)
+            backend_info = "Paid API (Anthropic)"
+        elif user_api_key.startswith("sk-"):
+            # OpenAI key
+            openai_provider = OpenAIProvider(api_key=user_api_key)
+            model = OpenAIModel(settings.openai_model, provider=openai_provider)
+            backend_info = "Paid API (OpenAI)"
+        else:
+            raise ValueError(
+                "Invalid API key format. Expected sk-... (OpenAI) or sk-ant-... (Anthropic)"
+            )
+        judge_handler = JudgeHandler(model=model)
+
+    # 3. Environment API Keys (fallback)
+    elif os.getenv("OPENAI_API_KEY"):
+        judge_handler = JudgeHandler(model=None)  # Uses env key
+        backend_info = "Paid API (OpenAI from env)"
+
+    elif os.getenv("ANTHROPIC_API_KEY"):
+        judge_handler = JudgeHandler(model=None)  # Uses env key
+        backend_info = "Paid API (Anthropic from env)"
+
+    # 4. Free Tier (HuggingFace Inference)
+    else:
+        judge_handler = HFInferenceJudgeHandler()
+        backend_info = "Free Tier (Llama 3.1 / Mistral)"
+```
+
+#### Change 4: Update `research_agent()` signature (lines 105-111)
+
+```python
+# BEFORE
+async def research_agent(
+    message: str,
+    history: list[dict[str, Any]],
+    mode: str = "simple",
+    api_key: str = "",
+    api_provider: str = "openai",  # ← REMOVE
+) -> AsyncGenerator[str, None]:
+
+# AFTER
+async def research_agent(
+    message: str,
+    history: list[dict[str, Any]],
+    mode: str = "simple",
+    api_key: str = "",
+) -> AsyncGenerator[str, None]:
+```
+
+#### Change 5: Update docstring (lines 112-124)
+
+```python
+# AFTER
+    """
+    Gradio chat function that runs the research agent.
+
+    Args:
+        message: User's research question
+        history: Chat history (Gradio format)
+        mode: Orchestrator mode ("simple" or "advanced")
+        api_key: Optional user-provided API key (BYOK - auto-detects provider)
+
+    Yields:
+        Markdown-formatted responses for streaming
+    """
+```
+
+#### Change 6: Fix Advanced mode check (line 139)
+
+```python
+# BEFORE
+if mode == "advanced" and not (has_openai or (has_user_key and api_provider == "openai")):
+
+# AFTER - auto-detect OpenAI key from prefix
+is_openai_user_key = user_api_key and user_api_key.startswith("sk-") and not user_api_key.startswith("sk-ant-")
+if mode == "advanced" and not (has_openai or is_openai_user_key):
+    yield (
+        "⚠️ **Advanced mode requires OpenAI API key.** "
+        "Anthropic keys only work in Simple mode. Falling back to Simple.\n\n"
+    )
+    mode = "simple"
+```
+
+#### Change 7: Remove premature "Using your key" message (lines 146-151)
+
+```python
+# BEFORE - uses api_provider which no longer exists
+if has_user_key:
+    yield (
+        f"🔑 **Using your {api_provider.upper()} API key** - "
+        "Your key is used only for this session and is never stored.\n\n"
+    )
+
+# AFTER - remove this block entirely
+# The backend_name from configure_orchestrator already shows "Paid API (OpenAI)" or "Paid API (Anthropic)"
+# No need for duplicate messaging
+```
+
+#### Change 8: Update configure_orchestrator call (lines 165-170)
+
+```python
+# BEFORE
+orchestrator, backend_name = configure_orchestrator(
+    use_mock=False,
+    mode=mode,
+    user_api_key=user_api_key,
+    api_provider=api_provider,  # ← REMOVE
+)
+
+# AFTER
+orchestrator, backend_name = configure_orchestrator(
+    use_mock=False,
+    mode=mode,
+    user_api_key=user_api_key,
+)
+```
+
+#### Change 9: Simplify examples (lines 210-229)
+
+```python
+# BEFORE - 4 items per example
+examples=[
+    ["What drugs improve female libido post-menopause?", "simple", "", "openai"],
+    ["Clinical trials for erectile dysfunction alternatives to PDE5 inhibitors?", "simple", "", "openai"],
+    ["Evidence for testosterone therapy in women with HSDD?", "simple", "", "openai"],
+],
+
+# AFTER - 2 items per example (query, mode) - API key always empty in examples
+examples=[
+    ["What drugs improve female libido post-menopause?", "simple"],
+    ["Clinical trials for ED alternatives to PDE5 inhibitors?", "simple"],
+    ["Evidence for testosterone therapy in women with HSDD?", "simple"],
+],
+```
+
+#### Change 10: Update additional_inputs (lines 231-252)
+
+```python
+# BEFORE - 3 inputs (mode, api_key, api_provider)
+additional_inputs=[
+    gr.Radio(
+        choices=["simple", "advanced"],
+        value="simple",
+        label="Orchestrator Mode",
+        info="Simple: Linear (Free Tier Friendly) | Advanced: Multi-Agent (Requires OpenAI)",
+    ),
+    gr.Textbox(
+        label="🔑 API Key (Optional - BYOK)",
+        placeholder="sk-... or sk-ant-...",
+        type="password",
+        info="Enter your own API key. Never stored.",
+    ),
+    gr.Radio(  # ← REMOVE THIS ENTIRE BLOCK
+        choices=["openai", "anthropic"],
+        value="openai",
+        label="API Provider",
+        info="Select the provider for your API key",
+    ),
+],
+
+# AFTER - 2 inputs (mode, api_key)
+additional_inputs=[
+    gr.Radio(
+        choices=["simple", "advanced"],
+        value="simple",
+        label="Orchestrator Mode",
+        info="Simple: Works with any key or free tier | Advanced: Requires OpenAI key",
+    ),
+    gr.Textbox(
+        label="🔑 API Key (Optional)",
+        placeholder="sk-... (OpenAI) or sk-ant-... (Anthropic)",
+        type="password",
+        info="Leave empty for free tier. Auto-detects provider from key prefix.",
+    ),
+],
+```
+
+#### Change 11: Update accordion label (line 230)
+
+```python
+# BEFORE
+additional_inputs_accordion=gr.Accordion(label="⚙️ Settings", open=False),
+
+# AFTER
+additional_inputs_accordion=gr.Accordion(label="⚙️ Settings (Free tier works without API key)", open=False),
+```
+
+---
+
+## Testing Checklist
+
+### Manual Tests
+- [ ] **No key**: Shows "Free Tier (Llama 3.1 / Mistral)" in backend
+- [ ] **OpenAI key (sk-...)**: Shows "Paid API (OpenAI)" in backend
+- [ ] **Anthropic key (sk-ant-...)**: Shows "Paid API (Anthropic)" in backend
+- [ ] **Invalid key format**: Shows error message
+- [ ] **Anthropic key + Advanced mode**: Falls back to Simple with warning
+- [ ] **OpenAI key + Advanced mode**: Uses full Magentic multi-agent
+- [ ] **Examples table**: Shows only 2 columns (query, mode)
+- [ ] **MCP server**: Still accessible at `/gradio_api/mcp/`
+
+### Unit Test Updates
+- [ ] `tests/unit/test_app_smoke.py` - may need update if checking input count
+
+---
+
+## Definition of Done
+
+- [ ] `api_provider` parameter removed from `configure_orchestrator()`
+- [ ] `api_provider` parameter removed from `research_agent()`
+- [ ] Auto-detection logic works for `sk-` and `sk-ant-` prefixes
+- [ ] Advanced mode check uses auto-detection (not removed param)
+- [ ] "Using your X key" message removed (backend_name handles this)
+- [ ] Examples table shows 2 columns
+- [ ] Accordion label updated
+- [ ] Placeholder text shows both key formats
+- [ ] All existing tests pass
+- [ ] MCP server still works
+
+---
+
+## Mode Compatibility Matrix (Unchanged)
+
+| Mode | No Key | OpenAI Key | Anthropic Key |
+|------|--------|------------|---------------|
+| **Simple** | ✅ Free tier | ✅ GPT-5.1 | ✅ Claude Sonnet 4.5 |
+| **Advanced** | ⚠️ Falls back | ✅ Full Magentic | ⚠️ Falls back to Simple |
+
+---
+
+## Related
+- Issue #52: UI Polish - Examples table confusion
+- Issue #53: API Provider Simplification
+- Senior Review: Approved 2025-11-28

src/app.py

@@ -17,6 +17,7 @@ from src.tools.europepmc import EuropePMCTool
 from src.tools.pubmed import PubMedTool
 from src.tools.search_handler import SearchHandler
 from src.utils.config import settings
+from src.utils.exceptions import ConfigurationError
 from src.utils.models import OrchestratorConfig
 
 
@@ -24,7 +25,6 @@ def configure_orchestrator(
     use_mock: bool = False,
     mode: str = "simple",
     user_api_key: str | None = None,
-    api_provider: str = "openai",
 ) -> tuple[Any, str]:
     """
     Create an orchestrator instance.
@@ -32,8 +32,7 @@ def configure_orchestrator(
     Args:
         use_mock: If True, use MockJudgeHandler (no API key needed)
         mode: Orchestrator mode ("simple" or "advanced")
-        user_api_key: Optional user-provided API key (BYOK)
-        api_provider: API provider ("openai" or "anthropic")
+        user_api_key: Optional user-provided API key (BYOK) - auto-detects provider
 
     Returns:
         Tuple of (Orchestrator instance, backend_name)
@@ -60,34 +59,35 @@ def configure_orchestrator(
         backend_info = "Mock (Testing)"
 
     # 2. Paid API Key (User provided or Env)
-    elif (
-        user_api_key
-        or (api_provider == "openai" and os.getenv("OPENAI_API_KEY"))
-        or (api_provider == "anthropic" and os.getenv("ANTHROPIC_API_KEY"))
-    ):
-        model: AnthropicModel | OpenAIModel | None = None
-        if user_api_key:
-            # Validate key/provider match to prevent silent auth failures
-            if api_provider == "openai" and user_api_key.startswith("sk-ant-"):
-                raise ValueError("Anthropic key provided but OpenAI provider selected")
-            is_openai_key = user_api_key.startswith("sk-") and not user_api_key.startswith(
-                "sk-ant-"
-            )
-            if api_provider == "anthropic" and is_openai_key:
-                raise ValueError("OpenAI key provided but Anthropic provider selected")
-            if api_provider == "anthropic":
-                anthropic_provider = AnthropicProvider(api_key=user_api_key)
-                model = AnthropicModel(settings.anthropic_model, provider=anthropic_provider)
-            elif api_provider == "openai":
-                openai_provider = OpenAIProvider(api_key=user_api_key)
-                model = OpenAIModel(settings.openai_model, provider=openai_provider)
-            backend_info = f"Paid API ({api_provider.upper()})"
+    elif user_api_key and user_api_key.strip():
+        # Auto-detect provider from key prefix
+        model: AnthropicModel | OpenAIModel
+        if user_api_key.startswith("sk-ant-"):
+            # Anthropic key
+            anthropic_provider = AnthropicProvider(api_key=user_api_key)
+            model = AnthropicModel(settings.anthropic_model, provider=anthropic_provider)
+            backend_info = "Paid API (Anthropic)"
+        elif user_api_key.startswith("sk-"):
+            # OpenAI key
+            openai_provider = OpenAIProvider(api_key=user_api_key)
+            model = OpenAIModel(settings.openai_model, provider=openai_provider)
+            backend_info = "Paid API (OpenAI)"
         else:
-            backend_info = "Paid API (Env Config)"
-
+            raise ConfigurationError(
+                "Invalid API key format. Expected sk-... (OpenAI) or sk-ant-... (Anthropic)"
+            )
         judge_handler = JudgeHandler(model=model)
 
-    # 3. Free Tier (HuggingFace Inference)
+    # 3. Environment API Keys (fallback)
+    elif os.getenv("OPENAI_API_KEY"):
+        judge_handler = JudgeHandler(model=None)  # Uses env key
+        backend_info = "Paid API (OpenAI from env)"
+
+    elif os.getenv("ANTHROPIC_API_KEY"):
+        judge_handler = JudgeHandler(model=None)  # Uses env key
+        backend_info = "Paid API (Anthropic from env)"
+
+    # 4. Free Tier (HuggingFace Inference)
     else:
         judge_handler = HFInferenceJudgeHandler()
         backend_info = "Free Tier (Llama 3.1 / Mistral)"
@@ -107,7 +107,6 @@ async def research_agent(
     history: list[dict[str, Any]],
     mode: str = "simple",
     api_key: str = "",
-    api_provider: str = "openai",
 ) -> AsyncGenerator[str, None]:
     """
     Gradio chat function that runs the research agent.
@@ -116,8 +115,7 @@ async def research_agent(
         message: User's research question
         history: Chat history (Gradio format)
         mode: Orchestrator mode ("simple" or "advanced")
-        api_key: Optional user-provided API key (BYOK - Bring Your Own Key)
-        api_provider: API provider ("openai" or "anthropic")
+        api_key: Optional user-provided API key (BYOK - auto-detects provider)
 
     Yields:
         Markdown-formatted responses for streaming
@@ -132,24 +130,22 @@ async def research_agent(
     # Check available keys
     has_openai = bool(os.getenv("OPENAI_API_KEY"))
     has_anthropic = bool(os.getenv("ANTHROPIC_API_KEY"))
-    has_user_key = bool(user_api_key)
-    has_paid_key = has_openai or has_anthropic or has_user_key
+    # Check for OpenAI user key
+    is_openai_user_key = (
+        user_api_key and user_api_key.startswith("sk-") and not user_api_key.startswith("sk-ant-")
+    )
+    has_paid_key = has_openai or has_anthropic or bool(user_api_key)
 
     # Advanced mode requires OpenAI specifically (due to agent-framework binding)
-    if mode == "advanced" and not (has_openai or (has_user_key and api_provider == "openai")):
+    if mode == "advanced" and not (has_openai or is_openai_user_key):
         yield (
             "⚠️ **Warning**: Advanced mode currently requires OpenAI API key. "
-            "Falling back to simple mode.\n\n"
+            "Anthropic keys only work in Simple mode. Falling back to Simple.\n\n"
         )
         mode = "simple"
 
-    # Inform user about their key being used
-    if has_user_key:
-        yield (
-            f"🔑 **Using your {api_provider.upper()} API key** - "
-            "Your key is used only for this session and is never stored.\n\n"
-        )
-    elif not has_paid_key:
+    # Inform user about fallback if no keys
+    if not has_paid_key:
         # No paid keys - will use FREE HuggingFace Inference
         yield (
             "🤗 **Free Tier**: Using HuggingFace Inference (Llama 3.1 / Mistral) for AI analysis.\n"
@@ -166,7 +162,6 @@ async def research_agent(
             use_mock=False,  # Never use mock in production - HF Inference is the free fallback
             mode=mode,
             user_api_key=user_api_key,
-            api_provider=api_provider,
         )
 
         yield f"🧠 **Backend**: {backend_name}\n\n"
@@ -187,13 +182,16 @@ async def research_agent(
         yield f"❌ **Error**: {e!s}"
 
 
-def create_demo() -> gr.ChatInterface:
+def create_demo() -> tuple[gr.ChatInterface, gr.Accordion]:
     """
     Create the Gradio demo interface with MCP support.
 
     Returns:
         Configured Gradio Blocks interface with MCP server enabled
     """
+    additional_inputs_accordion = gr.Accordion(
+        label="⚙️ Mode & API Key (Free tier works!)", open=False
+    )
     # 1. Unwrapped ChatInterface (Fixes Accordion Bug)
     demo = gr.ChatInterface(
         fn=research_agent,
@@ -211,55 +209,44 @@ def create_demo() -> gr.ChatInterface:
             [
                 "What drugs improve female libido post-menopause?",
                 "simple",
-                "",
-                "openai",
             ],
             [
                 "Clinical trials for erectile dysfunction alternatives to PDE5 inhibitors?",
-                "simple",
-                "",
-                "openai",
+                "advanced",
             ],
             [
                 "Evidence for testosterone therapy in women with HSDD?",
                 "simple",
-                "",
-                "openai",
             ],
         ],
-        additional_inputs_accordion=gr.Accordion(label="⚙️ Settings", open=False),
+        additional_inputs_accordion=additional_inputs_accordion,
         additional_inputs=[
             gr.Radio(
                 choices=["simple", "advanced"],
                 value="simple",
                 label="Orchestrator Mode",
                 info=(
-                    "Simple: Linear (Free Tier Friendly) | Advanced: Multi-Agent (Requires OpenAI)"
+                    "⚡ Simple: Fast (Free/Any Key) | "
+                    "🔬 Advanced: Deep Multi-Agent (OpenAI Key Only)"
                 ),
             ),
             gr.Textbox(
-                label="🔑 API Key (Optional - BYOK)",
-                placeholder="sk-... or sk-ant-...",
+                label="🔑 API Key (Optional)",
+                placeholder="sk-... (OpenAI) or sk-ant-... (Anthropic)",
                 type="password",
-                info="Enter your own API key. Never stored.",
-            ),
-            gr.Radio(
-                choices=["openai", "anthropic"],
-                value="openai",
-                label="API Provider",
-                info="Select the provider for your API key",
+                info="Leave empty for free tier. Auto-detects provider from key prefix.",
             ),
         ],
     )
 
-    return demo
+    return demo, additional_inputs_accordion
 
 
 def main() -> None:
     """Run the Gradio app with MCP server enabled."""
-    demo = create_demo()
+    demo, _ = create_demo()
     demo.launch(
-        server_name="0.0.0.0",
+        server_name=os.getenv("GRADIO_SERVER_NAME", "0.0.0.0"),  # nosec B104
         server_port=7860,
         share=False,
         mcp_server=True,

tests/unit/test_ui_elements.py

@@ -0,0 +1,35 @@
+import gradio as gr
+
+from src.app import create_demo
+
+
+def test_examples_include_advanced_mode():
+    """Verify that one example entry uses 'advanced' mode."""
+    demo, _ = create_demo()
+    assert any(
+        "advanced" == example[1] for example in demo.examples
+    ), "Expected at least one example to be 'advanced' mode"
+
+
+def test_accordion_label_updated():
+    """Verify the accordion label reflects the new, concise text."""
+    _, accordion = create_demo()
+    assert (
+        accordion.label == "⚙️ Mode & API Key (Free tier works!)"
+    ), "Accordion label not updated to '⚙️ Mode & API Key (Free tier works!)'"
+
+
+def test_orchestrator_mode_info_text_updated():
+    """Verify the Orchestrator Mode info text contains the new emojis and phrasing."""
+    demo, _ = create_demo()
+    # Assuming additional_inputs is a list and the Radio is the first element
+    orchestrator_radio = demo.additional_inputs[0]
+    expected_info = (
+        "⚡ Simple: Fast (Free/Any Key) | " "🔬 Advanced: Deep Multi-Agent " "(OpenAI Key Only)"
+    )
+    assert isinstance(
+        orchestrator_radio, gr.Radio
+    ), "Expected first additional input to be gr.Radio"
+    assert (
+        orchestrator_radio.info == expected_info
+    ), "Orchestrator Mode info text not updated correctly"