diff --git a/src/backend/clara/agents/simulation_agent.py b/src/backend/clara/agents/simulation_agent.py
index 4a2ba12..9fcf844 100644
--- a/src/backend/clara/agents/simulation_agent.py
+++ b/src/backend/clara/agents/simulation_agent.py
@@ -12,7 +12,9 @@
 from collections.abc import AsyncGenerator
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
+from urllib.parse import urlparse
 
+import anthropic
 import httpx
 from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
 
@@ -483,6 +485,148 @@ async def fetch_website_context(url: str) -> str:
         return f"(Could not fetch website content: {e})"
 
 
+def extract_company_name_from_url(url: str) -> str:
+    """Extract a clean company name from a URL."""
+    try:
+        parsed = urlparse(url)
+        hostname = parsed.hostname or ""
+
+        # Remove common prefixes
+        hostname = hostname.lower()
+        if hostname.startswith("www."):
+            hostname = hostname[4:]
+
+        # Get the main domain part (before TLD)
+        parts = hostname.split(".")
+        if len(parts) >= 2:
+            # Return the main domain name (e.g., "facebook" from "facebook.com")
+            return parts[0].capitalize()
+        return hostname.capitalize()
+    except Exception:
+        return "the company"
+
+
+async def search_company_products(url: str, role: str | None = None) -> str:
+    """Use web search to gather information about a company's products.
+
+    Uses Claude with web search to understand what products/services
+    the company offers, which provides richer context for the persona.
+
+    Args:
+        url: The company's website URL
+        role: Optional role to focus the search (e.g., "Product Manager for Instagram")
+
+    Returns:
+        A summary of the company's products and services
+    """
+    company_name = extract_company_name_from_url(url)
+
+    # Build a focused search query
+    if role:
+        # Extract product name if role mentions it (e.g., "Product Manager for Instagram")
+        role_lower = role.lower()
+        search_query = f"{company_name} products services overview"
+        if "for " in role_lower:
+            product_focus = role.split("for ")[-1].strip()
+            search_query = f"{company_name} {product_focus} product features"
+    else:
+        search_query = f"{company_name} products services overview"
+
+    logger.info(f"Searching for company products: {search_query}")
+
+    try:
+        client = anthropic.Anthropic()
+
+        # Build the research prompt
+        focus_item = ""
+        if role and "for " in role.lower():
+            focus_item = f"\n5. Specifically focus on: {role.split('for ')[-1]}"
+
+        research_prompt = f"""Research {company_name} (website: {url}) and provide a \
+comprehensive summary of their products and services.
+
+Focus on:
+1. Main products and services offered
+2. Key features and capabilities
+3. Target customers/market
+4. Recent developments or notable features{focus_item}
+
+Provide a detailed summary that would help someone understand what it's like \
+to work at this company in a product/technical role."""
+
+        # Use Claude with web search tool
+        response = client.messages.create(
+            model="claude-sonnet-4-20250514",
+            max_tokens=2048,
+            tools=[{"type": "web_search_20250305", "name": "web_search"}],
+            messages=[{"role": "user", "content": research_prompt}],
+        )
+
+        # Extract the text response
+        result_text = ""
+        for block in response.content:
+            if hasattr(block, "text"):
+                result_text += block.text
+
+        if result_text:
+            logger.info(f"Successfully gathered company context via web search for {company_name}")
+            return result_text
+
+        return f"(Could not find detailed product information for {company_name})"
+
+    except anthropic.APIError as e:
+        logger.warning(f"Anthropic API error during web search: {e}")
+        return f"(Web search unavailable: {e})"
+    except Exception as e:
+        logger.warning(f"Error during company product search: {e}")
+        return f"(Could not search for company products: {e})"
+
+
+async def gather_company_context(url: str, role: str | None = None) -> str:
+    """Gather comprehensive context about a company using web search and website scraping.
+
+    This combines web search results with direct website content for richer context.
+
+    Args:
+        url: The company's website URL
+        role: Optional role to focus the research
+
+    Returns:
+        Combined context about the company
+    """
+    # Run web search and website fetch in parallel
+    search_task = asyncio.create_task(search_company_products(url, role))
+    website_task = asyncio.create_task(fetch_website_context(url))
+
+    search_result, website_result = await asyncio.gather(
+        search_task, website_task, return_exceptions=True
+    )
+
+    # Handle any exceptions
+    if isinstance(search_result, Exception):
+        search_result = f"(Web search failed: {search_result})"
+    if isinstance(website_result, Exception):
+        website_result = f"(Website fetch failed: {website_result})"
+
+    # Combine results
+    company_name = extract_company_name_from_url(url)
+    context_parts = [f"## Company: {company_name}"]
+
+    if search_result and not search_result.startswith("("):
+        context_parts.append("\n### Product & Service Information (from web search)")
+        context_parts.append(search_result)
+
+    if website_result and not website_result.startswith("("):
+        context_parts.append("\n### Website Content")
+        context_parts.append(website_result[:2000])  # Limit website content
+
+    if len(context_parts) == 1:
+        # Neither source worked
+        return f"(Could not gather information about {company_name})"
+
+    return "\n".join(context_parts)
+
+
 class SimulationSessionManager:
     """Manages simulation sessions with thread-safe operations."""
 
@@ -532,9 +676,12 @@ async def create_session(
         if model and model not in VALID_MODELS:
             raise ValueError(f"Invalid model '{model}'. Must be one of: {', '.join(VALID_MODELS)}")
 
-        # Fetch website context if persona has a URL (outside lock for performance)
+        # Gather company context using web search if persona has a URL
+        # (outside lock for performance)
         if persona and persona.company_url and not persona.company_context:
-            persona.company_context = await fetch_website_context(persona.company_url)
+            persona.company_context = await gather_company_context(
+                persona.company_url, persona.role
+            )
 
         session = SimulationSession(
             session_id=session_id,
@@ -562,9 +709,11 @@ async def update_persona(
         """Update the persona for a session."""
         session = self._sessions.get(session_id)
         if session:
-            # Fetch website context if needed
+            # Gather company context using web search if needed
             if persona.company_url and not persona.company_context:
-                persona.company_context = await fetch_website_context(persona.company_url)
+                persona.company_context = await gather_company_context(
+                    persona.company_url, persona.role
+                )
 
             # Need to restart session with new persona
             await session.stop()
diff --git a/src/backend/clara/api/simulation_sessions.py b/src/backend/clara/api/simulation_sessions.py
index d18849a..60b807a 100644
--- a/src/backend/clara/api/simulation_sessions.py
+++ b/src/backend/clara/api/simulation_sessions.py
@@ -17,7 +17,12 @@
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from clara.agents.simulation_agent import VALID_MODELS, AGUIEvent, simulation_manager
+from clara.agents.simulation_agent import (
+    VALID_MODELS,
+    AGUIEvent,
+    PersonaConfig,
+    simulation_manager,
+)
 from clara.db.models import DesignSession
 from clara.db.session import get_db
 from clara.security import InputSanitizer
@@ -85,6 +90,79 @@ class SimulationStateResponse(BaseModel):
     messages: list[dict]
 
 
+class PersonaRequest(BaseModel):
+    """Request model for persona configuration."""
+    role: str = Field(
+        ..., min_length=1, max_length=200,
+        description="Role like 'Product Manager', 'Senior Engineer'"
+    )
+    company_url: str | None = Field(
+        None, description="Website URL to fetch company context from"
+    )
+    name: str | None = Field(
+        None, max_length=100, description="Optional name for the persona"
+    )
+    experience_years: int | None = Field(
+        None, ge=0, le=50, description="Years of experience"
+    )
+    communication_style: str = Field(
+        "professional", description="Style: professional, casual, detailed, brief"
+    )
+
+    @field_validator('company_url')
+    @classmethod
+    def validate_url(cls, v: str | None) -> str | None:
+        if v is not None:
+            v = v.strip()
+            if not v.startswith(('http://', 'https://')):
+                raise ValueError("URL must start with http:// or https://")
+        return v
+
+    @field_validator('communication_style')
+    @classmethod
+    def validate_style(cls, v: str) -> str:
+        valid_styles = {"professional", "casual", "detailed", "brief"}
+        if v not in valid_styles:
+            raise ValueError(f"Style must be one of: {', '.join(valid_styles)}")
+        return v
+
+
+class CreateAutoSimulationRequest(BaseModel):
+    """Request to create an automated simulation session."""
+    system_prompt: str = Field(..., min_length=1, max_length=50000)
+    persona: PersonaRequest
+    model: str | None = Field(
+        None, description="Model: sonnet (default), haiku (fast), opus (capable)"
+    )
+
+    @field_validator('system_prompt')
+    @classmethod
+    def sanitize_prompt(cls, v: str) -> str:
+        return InputSanitizer.sanitize_system_prompt(v)
+
+    @field_validator('model')
+    @classmethod
+    def validate_model(cls, v: str | None) -> str | None:
+        if v is not None and v not in VALID_MODELS:
+            valid = ', '.join(sorted(VALID_MODELS))
+            raise ValueError(f"Invalid model '{v}'. Must be one of: {valid}")
+        return v
+
+
+class AutoSimulationResponse(BaseModel):
+    """Response after creating an automated simulation session."""
+    session_id: str
+    system_prompt_preview: str
+    model: str
+    persona_role: str
+    persona_name: str | None
+
+
+class RunAutoSimulationRequest(BaseModel):
+    """Request to run an automated simulation."""
+    num_turns: int = Field(5, ge=1, le=20, description="Number of conversation turns")
+
+
 class BlueprintAgent(BaseModel):
     """Validated agent from blueprint state."""
     name: str | None = None
@@ -300,3 +378,187 @@ async def event_generator() -> AsyncGenerator[str, None]:
             "X-Accel-Buffering": "no",
         }
     )
+
+
+# ============================================================================
+# Automated Simulation Endpoints
+# ============================================================================
+
+
+@router.post("/auto", response_model=AutoSimulationResponse)
+async def create_auto_simulation(
+    request: CreateAutoSimulationRequest,
+) -> AutoSimulationResponse:
+    """Create an automated simulation session with a persona.
+
+    The persona will act as the interviewee, responding to the interview agent
+    automatically. You can optionally provide a company URL to fetch context.
+    """
+    session_id = str(uuid.uuid4())
+
+    # Convert request persona to PersonaConfig
+    persona = PersonaConfig(
+        role=request.persona.role,
+        company_url=request.persona.company_url,
+        name=request.persona.name,
+        experience_years=request.persona.experience_years,
+        communication_style=request.persona.communication_style,
+    )
+
+    session = await simulation_manager.create_session(
+        session_id=session_id,
+        interviewer_prompt=request.system_prompt,
+        persona=persona,
+        model=request.model,
+    )
+
+    logger.info(f"Created auto-simulation session {session_id} with persona: {persona.role}")
+
+    prompt = request.system_prompt
+    preview = prompt[:200] + "..." if len(prompt) > 200 else prompt
+
+    return AutoSimulationResponse(
+        session_id=session_id,
+        system_prompt_preview=preview,
+        model=session.model,
+        persona_role=persona.role,
+        persona_name=persona.name,
+    )
+
+
+@router.post("/auto/from-design-session/{design_session_id}", response_model=AutoSimulationResponse)
+async def create_auto_simulation_from_design_session(
+    design_session_id: str,
+    persona: PersonaRequest,
+    model: str | None = None,
+    db: AsyncSession = Depends(get_db),
+) -> AutoSimulationResponse:
+    """Create an automated simulation from a design session's blueprint.
+
+    Uses the system prompt from the blueprint and the provided persona.
+    """
+    # Validate model if provided
+    if model is not None and model not in VALID_MODELS:
+        valid = ', '.join(sorted(VALID_MODELS))
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid model '{model}'. Must be one of: {valid}"
+        )
+
+    try:
+        result = await db.execute(
+            select(DesignSession).where(DesignSession.id == design_session_id)
+        )
+        design_session = result.scalar_one_or_none()
+    except SQLAlchemyError:
+        logger.exception("Database error fetching design session")
+        raise HTTPException(status_code=500, detail="Database error")
+
+    if not design_session:
+        raise HTTPException(status_code=404, detail="Design session not found")
+
+    # Validate blueprint_state
+    try:
+        blueprint = BlueprintState.model_validate(design_session.blueprint_state or {})
+    except Exception as e:
+        logger.warning(f"Invalid blueprint state: {e}")
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid blueprint configuration. Please re-run the design process."
+        )
+
+    if not blueprint.agents:
+        raise HTTPException(
+            status_code=400,
+            detail="No agents configured in blueprint. Complete the design process first."
+        )
+
+    agent = blueprint.agents[0]
+    system_prompt = agent.system_prompt
+
+    if not system_prompt:
+        raise HTTPException(
+            status_code=400,
+            detail="No system prompt found in agent configuration. Complete Phase 3 first."
+        )
+
+    system_prompt = InputSanitizer.sanitize_system_prompt(system_prompt)
+
+    session_id = str(uuid.uuid4())
+
+    # Convert request persona to PersonaConfig
+    persona_config = PersonaConfig(
+        role=persona.role,
+        company_url=persona.company_url,
+        name=persona.name,
+        experience_years=persona.experience_years,
+        communication_style=persona.communication_style,
+    )
+
+    session = await simulation_manager.create_session(
+        session_id=session_id,
+        interviewer_prompt=system_prompt,
+        persona=persona_config,
+        model=model,
+    )
+
+    logger.info(
+        f"Created auto-simulation {session_id} from design {design_session_id} "
+        f"with persona: {persona_config.role}"
+    )
+
+    preview = system_prompt[:200] + "..." if len(system_prompt) > 200 else system_prompt
+
+    return AutoSimulationResponse(
+        session_id=session_id,
+        system_prompt_preview=preview,
+        model=session.model,
+        persona_role=persona_config.role,
+        persona_name=persona_config.name,
+    )
+
+
+@router.post("/{session_id}/run-auto")
+async def run_auto_simulation(
+    session_id: str,
+    request: RunAutoSimulationRequest = RunAutoSimulationRequest(),
+):
+    """Run an automated simulation conversation.
+
+    The interview agent and simulated user will have a back-and-forth
+    conversation for the specified number of turns. Streams SSE events
+    for both sides of the conversation.
+    """
+    session = await simulation_manager.get_session(session_id)
+
+    if not session:
+        raise HTTPException(status_code=404, detail="Simulation session not found")
+
+    if not session.persona:
+        raise HTTPException(
+            status_code=400,
+            detail="Session has no persona. Use /auto endpoint for auto-simulation."
+        )
+
+    async def event_generator() -> AsyncGenerator[str, None]:
+        """Generate SSE events from the auto-simulation."""
+        try:
+            async for event in session.run_auto_simulation(num_turns=request.num_turns):
+                yield format_sse_event(event)
+        except Exception as e:
+            logger.exception("Error running auto-simulation")
+            error_event = AGUIEvent(
+                type="ERROR",
+                data={"message": str(e)}
+            )
+            yield format_sse_event(error_event)
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        }
+    )
diff --git a/src/frontend/src/App.tsx b/src/frontend/src/App.tsx
index 0c87362..9a9409c 100644
--- a/src/frontend/src/App.tsx
+++ b/src/frontend/src/App.tsx
@@ -3,6 +3,7 @@ import ProjectsPage from './pages/ProjectsPage'
 import ProjectDetailPage from './pages/ProjectDetailPage'
 import { DesignAssistantPage } from './pages/DesignAssistantPage'
 import { SimulationPage } from './pages/SimulationPage'
+import { AutomatedSimulationPage } from './pages/AutomatedSimulationPage'
 
 function AppLayout({ children }: { children: React.ReactNode }) {
   return (
@@ -21,14 +22,15 @@ function AppLayout({ children }: { children: React.ReactNode }) {
 
 function App() {
   const location = useLocation()
-  const isFullScreenPage = location.pathname.includes('/design') || location.pathname.includes('/simulate')
+  const isFullScreenPage = location.pathname.includes('/design') || location.pathname.includes('/simulate') || location.pathname.includes('/auto-simulate')
 
-  // Design Assistant and Simulation use full-screen layout
+  // Design Assistant and Simulation pages use full-screen layout
   if (isFullScreenPage) {
     return (
       <Routes>
         <Route path="/projects/:projectId/design" element={<DesignAssistantPage />} />
         <Route path="/projects/:projectId/simulate" element={<SimulationPage />} />
+        <Route path="/projects/:projectId/auto-simulate" element={<AutomatedSimulationPage />} />
       </Routes>
     )
   }
diff --git a/src/frontend/src/api/simulation-sessions.ts b/src/frontend/src/api/simulation-sessions.ts
index 509a72f..89d5a71 100644
--- a/src/frontend/src/api/simulation-sessions.ts
+++ b/src/frontend/src/api/simulation-sessions.ts
@@ -25,6 +25,30 @@ export interface SimulationState {
   messages: Array<{ role: 'user' | 'assistant'; content: string }>;
 }
 
+export type CommunicationStyle = 'professional' | 'casual' | 'detailed' | 'brief';
+
+export interface PersonaConfig {
+  role: string;
+  company_url?: string;
+  name?: string;
+  experience_years?: number;
+  communication_style?: CommunicationStyle;
+}
+
+export interface CreateAutoSimulationRequest {
+  system_prompt: string;
+  persona: PersonaConfig;
+  model?: SimulationModel;
+}
+
+export interface AutoSimulationResponse {
+  session_id: string;
+  system_prompt_preview: string;
+  model: SimulationModel;
+  persona_role: string;
+  persona_name: string | null;
+}
+
 /**
  * Create a new simulation session with a custom prompt.
  */
@@ -171,3 +195,110 @@ export async function* sendSimulationMessage(
     }
   }
 }
+
+// ============================================================================
+// Automated Simulation API Functions
+// ============================================================================
+
+export interface AutoSimulationEvent {
+  type: string;
+  delta?: string;
+  content?: string;
+  message?: string;
+  role?: string;
+  turns?: number;
+}
+
+/**
+ * Create an automated simulation session with a persona.
+ */
+export async function createAutoSimulation(
+  request: CreateAutoSimulationRequest
+): Promise<AutoSimulationResponse> {
+  const response = await fetch(`${API_BASE}/auto`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(request),
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(error.detail || `Failed to create auto-simulation: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Create an automated simulation from a design session's blueprint.
+ */
+export async function createAutoSimulationFromDesignSession(
+  designSessionId: string,
+  persona: PersonaConfig,
+  model?: SimulationModel
+): Promise<AutoSimulationResponse> {
+  const params = new URLSearchParams();
+  if (model) params.set('model', model);
+
+  const url = `${API_BASE}/auto/from-design-session/${designSessionId}${params.toString() ? `?${params}` : ''}`;
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(persona),
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(error.detail || `Failed to create auto-simulation: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Run an automated simulation and stream the conversation.
+ */
+export async function* runAutoSimulation(
+  sessionId: string,
+  numTurns: number = 5
+): AsyncGenerator<AutoSimulationEvent> {
+  const response = await fetch(`${API_BASE}/${sessionId}/run-auto`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ num_turns: numTurns }),
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(error.detail || `Failed to run auto-simulation: ${response.statusText}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('No response body');
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (line.startsWith('data: ')) {
+        try {
+          const data = JSON.parse(line.slice(6));
+          yield data;
+        } catch {
+          // Skip invalid JSON
+        }
+      }
+    }
+  }
+}
diff --git a/src/frontend/src/pages/AutomatedSimulationPage.tsx b/src/frontend/src/pages/AutomatedSimulationPage.tsx
new file mode 100644
index 0000000..90dc951
--- /dev/null
+++ b/src/frontend/src/pages/AutomatedSimulationPage.tsx
@@ -0,0 +1,595 @@
+/**
+ * Automated Simulation Page - Run simulated interviews with AI personas.
+ *
+ * Users configure a persona (role, company, experience) and watch the
+ * interview agent have a conversation with the simulated interviewee.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useParams, Link, useSearchParams } from 'react-router-dom';
+import clsx from 'clsx';
+import {
+  createAutoSimulation,
+  createAutoSimulationFromDesignSession,
+  runAutoSimulation,
+  deleteSimulation,
+  SimulationModel,
+  CommunicationStyle,
+  PersonaConfig,
+} from '../api/simulation-sessions';
+
+interface Message {
+  id: string;
+  role: 'interviewer' | 'interviewee';
+  content: string;
+  isStreaming?: boolean;
+}
+
+type SimulationStatus = 'configuring' | 'ready' | 'running' | 'completed' | 'error';
+
+const DEFAULT_SYSTEM_PROMPT = `You are an expert discovery interviewer. Your goal is to understand the interviewee's role, responsibilities, challenges, and workflows.
+
+Guidelines:
+- Start by introducing yourself and explaining the purpose of the interview
+- Ask open-ended questions to encourage detailed responses
+- Follow up on interesting points to dig deeper
+- Be empathetic and create a comfortable environment
+- Cover key topics: current processes, pain points, tools used, and desired improvements
+- Summarize key findings periodically`;
+
+export function AutomatedSimulationPage() {
+  const { projectId } = useParams<{ projectId: string }>();
+  const [searchParams] = useSearchParams();
+  const designSessionId = searchParams.get('designSessionId');
+  const messagesEndRef = useRef<HTMLDivElement>(null);
+
+  // Session state
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  const [status, setStatus] = useState<SimulationStatus>('configuring');
+  const [error, setError] = useState<string | null>(null);
+
+  // Persona configuration
+  const [persona, setPersona] = useState<PersonaConfig>({
+    role: 'Product Manager',
+    company_url: '',
+    name: '',
+    experience_years: 5,
+    communication_style: 'professional',
+  });
+
+  // Simulation settings
+  const [systemPrompt, setSystemPrompt] = useState(DEFAULT_SYSTEM_PROMPT);
+  const [selectedModel, setSelectedModel] = useState<SimulationModel>('sonnet');
+  const [numTurns, setNumTurns] = useState(5);
+
+  // Messages
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+
+  // Auto-scroll
+  useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+  }, [messages]);
+
+  // Cleanup session on unmount
+  useEffect(() => {
+    return () => {
+      if (sessionId) {
+        deleteSimulation(sessionId).catch(() => {});
+      }
+    };
+  }, [sessionId]);
+
+  // Load system prompt from design session if provided
+  useEffect(() => {
+    async function loadDesignSession() {
+      if (!designSessionId) return;
+
+      try {
+        setIsLoading(true);
+        // We'll create the session when starting, but could pre-fetch the prompt here
+      } catch (err) {
+        console.error('Failed to load design session:', err);
+      } finally {
+        setIsLoading(false);
+      }
+    }
+
+    loadDesignSession();
+  }, [designSessionId]);
+
+  const handleStartSimulation = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      setMessages([]);
+
+      // Create the auto-simulation session
+      let result;
+      if (designSessionId) {
+        result = await createAutoSimulationFromDesignSession(
+          designSessionId,
+          persona,
+          selectedModel
+        );
+      } else {
+        result = await createAutoSimulation({
+          system_prompt: systemPrompt,
+          persona,
+          model: selectedModel,
+        });
+      }
+
+      setSessionId(result.session_id);
+      setStatus('ready');
+
+      // Now run the simulation
+      setStatus('running');
+
+      for await (const event of runAutoSimulation(result.session_id, numTurns)) {
+        if (event.type === 'TEXT_MESSAGE_CONTENT') {
+          // Interviewer (assistant) message content
+          setMessages((prev) => {
+            const lastMsg = prev[prev.length - 1];
+            if (lastMsg?.role === 'interviewer' && lastMsg?.isStreaming) {
+              return prev.map((msg, i) =>
+                i === prev.length - 1
+                  ? { ...msg, content: msg.content + (event.delta || '') }
+                  : msg
+              );
+            }
+            // New interviewer message
+            return [
+              ...prev,
+              {
+                id: `interviewer-${Date.now()}`,
+                role: 'interviewer',
+                content: event.delta || '',
+                isStreaming: true,
+              },
+            ];
+          });
+        } else if (event.type === 'TEXT_MESSAGE_END') {
+          // Interviewer message complete
+          setMessages((prev) =>
+            prev.map((msg) =>
+              msg.role === 'interviewer' && msg.isStreaming
+                ? { ...msg, isStreaming: false }
+                : msg
+            )
+          );
+        } else if (event.type === 'SIMULATED_USER_CONTENT') {
+          // Interviewee (simulated user) message content
+          setMessages((prev) => {
+            const lastMsg = prev[prev.length - 1];
+            if (lastMsg?.role === 'interviewee' && lastMsg?.isStreaming) {
+              return prev.map((msg, i) =>
+                i === prev.length - 1
+                  ? { ...msg, content: msg.content + (event.delta || '') }
+                  : msg
+              );
+            }
+            // New interviewee message
+            return [
+              ...prev,
+              {
+                id: `interviewee-${Date.now()}`,
+                role: 'interviewee',
+                content: event.delta || '',
+                isStreaming: true,
+              },
+            ];
+          });
+        } else if (event.type === 'SIMULATED_USER_END') {
+          // Interviewee message complete
+          setMessages((prev) =>
+            prev.map((msg) =>
+              msg.role === 'interviewee' && msg.isStreaming
+                ? { ...msg, isStreaming: false }
+                : msg
+            )
+          );
+        } else if (event.type === 'SIMULATION_COMPLETE') {
+          setStatus('completed');
+        } else if (event.type === 'ERROR') {
+          setError(event.message || 'An error occurred');
+          setStatus('error');
+        }
+      }
+
+      setStatus('completed');
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to start simulation';
+      setError(errorMessage);
+      setStatus('error');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [designSessionId, persona, systemPrompt, selectedModel, numTurns]);
+
+  const handleReset = useCallback(() => {
+    if (sessionId) {
+      deleteSimulation(sessionId).catch(() => {});
+    }
+    setSessionId(null);
+    setStatus('configuring');
+    setMessages([]);
+    setError(null);
+  }, [sessionId]);
+
+  if (!projectId) {
+    return (
+      <div className="flex items-center justify-center h-screen">
+        <p className="text-gray-500">No project selected</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex h-screen bg-gray-50">
+      {/* Configuration Panel */}
+      <div className="w-96 bg-white border-r border-gray-200 flex flex-col">
+        <div className="p-4 border-b border-gray-200">
+          <div className="flex items-center gap-3 mb-2">
+            <Link
+              to={`/projects/${projectId}`}
+              className="text-gray-400 hover:text-gray-600 transition-colors"
+            >
+              <svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M10 19l-7-7m0 0l7-7m-7 7h18" />
+              </svg>
+            </Link>
+            <h1 className="text-lg font-semibold text-gray-900">Automated Simulation</h1>
+          </div>
+          <p className="text-sm text-gray-500">
+            Configure a persona to simulate an interview conversation
+          </p>
+        </div>
+
+        <div className="flex-1 overflow-y-auto p-4 space-y-6">
+          {/* Persona Configuration */}
+          <section>
+            <h3 className="text-sm font-medium text-gray-900 mb-3">Persona</h3>
+            <div className="space-y-4">
+              <div>
+                <label className="block text-sm text-gray-600 mb-1">Role *</label>
+                <input
+                  type="text"
+                  value={persona.role}
+                  onChange={(e) => setPersona((p) => ({ ...p, role: e.target.value }))}
+                  placeholder="e.g., Product Manager, Senior Engineer"
+                  disabled={status !== 'configuring'}
+                  className="w-full px-3 py-2 text-sm border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:bg-gray-50"
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm text-gray-600 mb-1">Name (optional)</label>
+                <input
+                  type="text"
+                  value={persona.name || ''}
+                  onChange={(e) => setPersona((p) => ({ ...p, name: e.target.value || undefined }))}
+                  placeholder="e.g., Sarah Chen"
+                  disabled={status !== 'configuring'}
+                  className="w-full px-3 py-2 text-sm border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:bg-gray-50"
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm text-gray-600 mb-1">Company Website (optional)</label>
+                <input
+                  type="url"
+                  value={persona.company_url || ''}
+                  onChange={(e) => setPersona((p) => ({ ...p, company_url: e.target.value || undefined }))}
+                  placeholder="https://company.com"
+                  disabled={status !== 'configuring'}
+                  className="w-full px-3 py-2 text-sm border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:bg-gray-50"
+                />
+                <p className="mt-1 text-xs text-gray-400">
+                  We'll fetch context about the company to inform responses
+                </p>
+              </div>
+
+              <div>
+                <label className="block text-sm text-gray-600 mb-1">Years of Experience</label>
+                <input
+                  type="number"
+                  value={persona.experience_years || ''}
+                  onChange={(e) => setPersona((p) => ({ ...p, experience_years: parseInt(e.target.value) || undefined }))}
+                  min={0}
+                  max={50}
+                  disabled={status !== 'configuring'}
+                  className="w-full px-3 py-2 text-sm border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:bg-gray-50"
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm text-gray-600 mb-1">Communication Style</label>
+                <select
+                  value={persona.communication_style || 'professional'}
+                  onChange={(e) => setPersona((p) => ({ ...p, communication_style: e.target.value as CommunicationStyle }))}
+                  disabled={status !== 'configuring'}
+                  className="w-full px-3 py-2 text-sm border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:bg-gray-50"
+                >
+                  <option value="professional">Professional</option>
+                  <option value="casual">Casual</option>
+                  <option value="detailed">Detailed</option>
+                  <option value="brief">Brief</option>
+                </select>
+              </div>
+            </div>
+          </section>
+
+          {/* Simulation Settings */}
+          <section>
+            <h3 className="text-sm font-medium text-gray-900 mb-3">Settings</h3>
+            <div className="space-y-4">
+              <div>
+                <label className="block text-sm text-gray-600 mb-1">Model</label>
+                <select
+                  value={selectedModel}
+                  onChange={(e) => setSelectedModel(e.target.value as SimulationModel)}
+                  disabled={status !== 'configuring'}
+                  className="w-full px-3 py-2 text-sm border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:bg-gray-50"
+                >
+                  <option value="haiku">Haiku (Fast)</option>
+                  <option value="sonnet">Sonnet (Balanced)</option>
+                  <option value="opus">Opus (Most Capable)</option>
+                </select>
+              </div>
+
+              <div>
+                <label className="block text-sm text-gray-600 mb-1">
+                  Conversation Turns: {numTurns}
+                </label>
+                <input
+                  type="range"
+                  value={numTurns}
+                  onChange={(e) => setNumTurns(parseInt(e.target.value))}
+                  min={1}
+                  max={20}
+                  disabled={status !== 'configuring'}
+                  className="w-full"
+                />
+                <p className="mt-1 text-xs text-gray-400">
+                  Number of back-and-forth exchanges
+                </p>
+              </div>
+            </div>
+          </section>
+
+          {/* System Prompt (only if no design session) */}
+          {!designSessionId && (
+            <section>
+              <h3 className="text-sm font-medium text-gray-900 mb-3">Interview Prompt</h3>
+              <textarea
+                value={systemPrompt}
+                onChange={(e) => setSystemPrompt(e.target.value)}
+                disabled={status !== 'configuring'}
+                rows={8}
+                className="w-full px-3 py-2 text-xs font-mono border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:bg-gray-50"
+              />
+            </section>
+          )}
+        </div>
+
+        {/* Actions */}
+        <div className="p-4 border-t border-gray-200">
+          {status === 'configuring' && (
+            <button
+              onClick={handleStartSimulation}
+              disabled={!persona.role || isLoading}
+              className="w-full px-4 py-3 bg-blue-600 text-white text-sm font-medium rounded-lg hover:bg-blue-700 transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+            >
+              {isLoading ? 'Starting...' : 'Start Simulation'}
+            </button>
+          )}
+
+          {(status === 'running' || status === 'completed' || status === 'error') && (
+            <button
+              onClick={handleReset}
+              className="w-full px-4 py-3 bg-gray-100 text-gray-700 text-sm font-medium rounded-lg hover:bg-gray-200 transition-colors"
+            >
+              New Simulation
+            </button>
+          )}
+        </div>
+      </div>
+
+      {/* Conversation View */}
+      <div className="flex-1 flex flex-col">
+        {/* Header */}
+        <header className="flex items-center justify-between px-6 py-4 bg-white border-b border-gray-200">
+          <div>
+            <h2 className="text-lg font-semibold text-gray-900">Interview Conversation</h2>
+            <p className="text-sm text-gray-500">
+              {status === 'configuring' && 'Configure a persona to start'}
+              {status === 'ready' && 'Ready to begin'}
+              {status === 'running' && 'Simulation in progress...'}
+              {status === 'completed' && `Completed - ${messages.length} messages`}
+              {status === 'error' && 'Simulation failed'}
+            </p>
+          </div>
+
+          {status !== 'configuring' && (
+            <div className="flex items-center gap-2">
+              <span className={clsx(
+                'px-3 py-1 text-xs font-medium rounded-full',
+                status === 'running' && 'bg-yellow-100 text-yellow-700',
+                status === 'completed' && 'bg-green-100 text-green-700',
+                status === 'error' && 'bg-red-100 text-red-700',
+                status === 'ready' && 'bg-blue-100 text-blue-700'
+              )}>
+                {status === 'running' && 'Running'}
+                {status === 'completed' && 'Complete'}
+                {status === 'error' && 'Error'}
+                {status === 'ready' && 'Ready'}
+              </span>
+            </div>
+          )}
+        </header>
+
+        {/* Error Banner */}
+        {error && (
+          <div className="mx-6 mt-4 p-4 bg-red-50 border border-red-200 rounded-lg flex items-center justify-between">
+            <p className="text-sm text-red-700">{error}</p>
+            <button
+              onClick={() => setError(null)}
+              className="text-red-500 hover:text-red-700"
+            >
+              <svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+              </svg>
+            </button>
+          </div>
+        )}
+
+        {/* Active Persona Card */}
+        {status !== 'configuring' && (
+          <div className="mx-6 mt-4 p-4 bg-purple-50 border border-purple-200 rounded-lg">
+            <div className="flex items-center gap-4">
+              <div className="w-12 h-12 bg-purple-100 rounded-full flex items-center justify-center">
+                <svg className="w-6 h-6 text-purple-600" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z" />
+                </svg>
+              </div>
+              <div className="flex-1">
+                <div className="flex items-center gap-2">
+                  <h3 className="font-semibold text-purple-900">
+                    {persona.name || 'Simulated Interviewee'}
+                  </h3>
+                  <span className="px-2 py-0.5 text-xs font-medium bg-purple-200 text-purple-700 rounded-full">
+                    {persona.communication_style || 'professional'}
+                  </span>
+                </div>
+                <p className="text-sm text-purple-700">{persona.role}</p>
+                <div className="flex items-center gap-4 mt-1 text-xs text-purple-600">
+                  {persona.experience_years && (
+                    <span>{persona.experience_years} years experience</span>
+                  )}
+                  {persona.company_url && (() => {
+                    try {
+                      const hostname = new URL(persona.company_url).hostname.replace('www.', '');
+                      return (
+                        <span className="flex items-center gap-1">
+                          <svg className="w-3 h-3" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M21 12a9 9 0 01-9 9m9-9a9 9 0 00-9-9m9 9H3m9 9a9 9 0 01-9-9m9 9c1.657 0 3-4.03 3-9s-1.343-9-3-9m0 18c-1.657 0-3-4.03-3-9s1.343-9 3-9m-9 9a9 9 0 019-9" />
+                          </svg>
+                          {hostname}
+                        </span>
+                      );
+                    } catch {
+                      return null;
+                    }
+                  })()}
+                </div>
+              </div>
+              <div className="text-right">
+                <div className="text-xs text-purple-500 uppercase tracking-wide">Model</div>
+                <div className="text-sm font-medium text-purple-700 capitalize">{selectedModel}</div>
+              </div>
+            </div>
+          </div>
+        )}
+
+        {/* Empty State */}
+        {status === 'configuring' && (
+          <div className="flex-1 flex items-center justify-center">
+            <div className="text-center max-w-md">
+              <div className="w-16 h-16 bg-purple-100 rounded-full flex items-center justify-center mx-auto mb-4">
+                <svg className="w-8 h-8 text-purple-600" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0zm6 3a2 2 0 11-4 0 2 2 0 014 0zM7 10a2 2 0 11-4 0 2 2 0 014 0z" />
+                </svg>
+              </div>
+              <h3 className="text-lg font-medium text-gray-900 mb-2">Automated Interview Simulation</h3>
+              <p className="text-gray-500 mb-4">
+                Configure a persona on the left to simulate an interview. The AI will play the role
+                of an interviewee with the specified characteristics.
+              </p>
+              <p className="text-sm text-gray-400">
+                Example: "Product Manager at Facebook working on Instagram"
+              </p>
+            </div>
+          </div>
+        )}
+
+        {/* Messages */}
+        {status !== 'configuring' && (
+          <div className="flex-1 overflow-y-auto px-6 py-4">
+            {messages.length === 0 && status === 'running' ? (
+              <div className="h-full flex items-center justify-center">
+                <div className="text-center">
+                  <div className="w-12 h-12 border-4 border-blue-500 border-t-transparent rounded-full animate-spin mx-auto" />
+                  <p className="mt-4 text-gray-500">Starting simulation...</p>
+                </div>
+              </div>
+            ) : (
+              <div className="space-y-4 max-w-3xl mx-auto">
+                {messages.map((message) => (
+                  <div
+                    key={message.id}
+                    className={clsx(
+                      'flex',
+                      message.role === 'interviewee' ? 'justify-end' : 'justify-start'
+                    )}
+                  >
+                    <div className="flex items-start gap-3 max-w-[80%]">
+                      {message.role === 'interviewer' && (
+                        <div className="w-8 h-8 bg-blue-100 rounded-full flex items-center justify-center flex-shrink-0">
+                          <svg className="w-4 h-4 text-blue-600" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9.663 17h4.673M12 3v1m6.364 1.636l-.707.707M21 12h-1M4 12H3m3.343-5.657l-.707-.707m2.828 9.9a5 5 0 117.072 0l-.548.547A3.374 3.374 0 0014 18.469V19a2 2 0 11-4 0v-.531c0-.895-.356-1.754-.988-2.386l-.548-.547z" />
+                          </svg>
+                        </div>
+                      )}
+                      <div
+                        className={clsx(
+                          'rounded-lg px-4 py-3',
+                          message.role === 'interviewer'
+                            ? 'bg-white text-gray-900 border border-gray-200'
+                            : 'bg-purple-600 text-white',
+                          message.isStreaming && 'animate-pulse'
+                        )}
+                      >
+                        <div className="text-xs font-medium mb-1 opacity-70">
+                          {message.role === 'interviewer' ? 'Interviewer' : persona.name || persona.role}
+                        </div>
+                        <div className="whitespace-pre-wrap text-sm leading-relaxed">
+                          {message.content || (message.isStreaming && '...')}
+                        </div>
+                      </div>
+                      {message.role === 'interviewee' && (
+                        <div className="w-8 h-8 bg-purple-100 rounded-full flex items-center justify-center flex-shrink-0">
+                          <svg className="w-4 h-4 text-purple-600" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z" />
+                          </svg>
+                        </div>
+                      )}
+                    </div>
+                  </div>
+                ))}
+                <div ref={messagesEndRef} />
+              </div>
+            )}
+          </div>
+        )}
+
+        {/* Completion Summary */}
+        {status === 'completed' && messages.length > 0 && (
+          <div className="px-6 py-4 bg-white border-t border-gray-200">
+            <div className="max-w-3xl mx-auto flex items-center justify-between">
+              <div className="text-sm text-gray-600">
+                Simulation completed with {Math.ceil(messages.length / 2)} conversation turns
+              </div>
+              <button
+                onClick={handleReset}
+                className="px-4 py-2 text-sm font-medium text-blue-600 hover:text-blue-700"
+              >
+                Run Another Simulation
+              </button>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/frontend/src/pages/ProjectDetailPage.tsx b/src/frontend/src/pages/ProjectDetailPage.tsx
index 85d3bd3..775b536 100644
--- a/src/frontend/src/pages/ProjectDetailPage.tsx
+++ b/src/frontend/src/pages/ProjectDetailPage.tsx
@@ -358,6 +358,12 @@ export default function ProjectDetailPage() {
                     >
                       Simulate
                     </Link>
+                    <Link
+                      to={`/projects/${projectId}/auto-simulate?designSessionId=${designSession.session_id}&agentIndex=${index}`}
+                      className="px-3 py-1.5 text-sm font-medium text-white bg-purple-600 hover:bg-purple-700 rounded-md"
+                    >
+                      Auto-Simulate
+                    </Link>
                     <button
                       onClick={() => {
                         // TODO: Implement assign interviews modal