feat: implement Magentic ChatAgent pattern with semantic state management

- Add src/agents/state.py: Thread-safe MagenticState with contextvars
- Evidence store for structured citation access
- EmbeddingService integration for semantic deduplication

- Add src/agents/tools.py: AIFunction tools that update shared state
- search_pubmed, search_clinical_trials, search_preprints
- get_bibliography for ReportAgent citations
- Tools return strings to LLM AND update state

- Add src/agents/magentic_agents.py: ChatAgent factories
- SearchAgent with search tools
- JudgeAgent, HypothesisAgent, ReportAgent
- Each agent has internal OpenAIChatClient

- Update src/orchestrator_magentic.py: Use ChatAgent pattern
- Initialize MagenticState at workflow start
- Properly stream events from MagenticBuilder

- Fix type errors for pre-commit mypy compatibility

Implements Phase 5 spec for correct Microsoft Agent Framework integration.

src/agents/magentic_agents.py

@@ -0,0 +1,184 @@
+"""Magentic-compatible agents using ChatAgent pattern."""
+
+from agent_framework import ChatAgent
+from agent_framework.openai import OpenAIChatClient
+
+from src.agents.tools import (
+    get_bibliography,
+    search_clinical_trials,
+    search_preprints,
+    search_pubmed,
+)
+from src.utils.config import settings
+
+
+def create_search_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent:
+    """Create a search agent with internal LLM and search tools.
+
+    Args:
+        chat_client: Optional custom chat client. If None, uses default.
+
+    Returns:
+        ChatAgent configured for biomedical search
+    """
+    client = chat_client or OpenAIChatClient(
+        model_id="gpt-4o-mini",  # Fast, cheap for tool orchestration
+        api_key=settings.openai_api_key,
+    )
+
+    return ChatAgent(
+        name="SearchAgent",
+        description=(
+            "Searches biomedical databases (PubMed, ClinicalTrials.gov, bioRxiv) "
+            "for drug repurposing evidence"
+        ),
+        instructions="""You are a biomedical search specialist. When asked to find evidence:
+
+1. Analyze the request to determine what to search for
+2. Extract key search terms (drug names, disease names, mechanisms)
+3. Use the appropriate search tools:
+   - search_pubmed for peer-reviewed papers
+   - search_clinical_trials for clinical studies
+   - search_preprints for cutting-edge findings
+4. Summarize what you found and highlight key evidence
+
+Be thorough - search multiple databases when appropriate.
+Focus on finding: mechanisms of action, clinical evidence, and specific drug candidates.""",
+        chat_client=client,
+        tools=[search_pubmed, search_clinical_trials, search_preprints],
+        temperature=0.3,  # More deterministic for tool use
+    )
+
+
+def create_judge_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent:
+    """Create a judge agent that evaluates evidence quality.
+
+    Args:
+        chat_client: Optional custom chat client. If None, uses default.
+
+    Returns:
+        ChatAgent configured for evidence assessment
+    """
+    client = chat_client or OpenAIChatClient(
+        model_id="gpt-4o",  # Better model for nuanced judgment
+        api_key=settings.openai_api_key,
+    )
+
+    return ChatAgent(
+        name="JudgeAgent",
+        description="Evaluates evidence quality and determines if sufficient for synthesis",
+        instructions="""You are an evidence quality assessor. When asked to evaluate:
+
+1. Review all evidence presented in the conversation
+2. Score on two dimensions (0-10 each):
+   - Mechanism Score: How well is the biological mechanism explained?
+   - Clinical Score: How strong is the clinical/preclinical evidence?
+3. Determine if evidence is SUFFICIENT for a final report:
+   - Sufficient: Clear mechanism + supporting clinical data
+   - Insufficient: Gaps in mechanism OR weak clinical evidence
+4. If insufficient, suggest specific search queries to fill gaps
+
+Be rigorous but fair. Look for:
+- Molecular targets and pathways
+- Animal model studies
+- Human clinical trials
+- Safety data
+- Drug-drug interactions""",
+        chat_client=client,
+        temperature=0.2,  # Consistent judgments
+    )
+
+
+def create_hypothesis_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent:
+    """Create a hypothesis generation agent.
+
+    Args:
+        chat_client: Optional custom chat client. If None, uses default.
+
+    Returns:
+        ChatAgent configured for hypothesis generation
+    """
+    client = chat_client or OpenAIChatClient(
+        model_id="gpt-4o",
+        api_key=settings.openai_api_key,
+    )
+
+    return ChatAgent(
+        name="HypothesisAgent",
+        description="Generates mechanistic hypotheses for drug repurposing",
+        instructions="""You are a biomedical hypothesis generator. Based on evidence:
+
+1. Identify the key molecular targets involved
+2. Map the biological pathways affected
+3. Generate testable hypotheses in this format:
+
+   DRUG -> TARGET -> PATHWAY -> THERAPEUTIC EFFECT
+
+   Example:
+   Metformin -> AMPK activation -> mTOR inhibition -> Reduced tau phosphorylation
+
+4. Explain the rationale for each hypothesis
+5. Suggest what additional evidence would support or refute it
+
+Focus on mechanistic plausibility and existing evidence.""",
+        chat_client=client,
+        temperature=0.5,  # Some creativity for hypothesis generation
+    )
+
+
+def create_report_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent:
+    """Create a report synthesis agent.
+
+    Args:
+        chat_client: Optional custom chat client. If None, uses default.
+
+    Returns:
+        ChatAgent configured for report generation
+    """
+    client = chat_client or OpenAIChatClient(
+        model_id="gpt-4o",
+        api_key=settings.openai_api_key,
+    )
+
+    return ChatAgent(
+        name="ReportAgent",
+        description="Synthesizes research findings into structured reports",
+        instructions="""You are a scientific report writer. When asked to synthesize:
+
+Generate a structured report with these sections:
+
+## Executive Summary
+Brief overview of findings and recommendation
+
+## Methodology
+Databases searched, queries used, evidence reviewed
+
+## Key Findings
+### Mechanism of Action
+- Molecular targets
+- Biological pathways
+- Proposed mechanism
+
+### Clinical Evidence
+- Preclinical studies
+- Clinical trials
+- Safety profile
+
+## Drug Candidates
+List specific drugs with repurposing potential
+
+## Limitations
+Gaps in evidence, conflicting data, caveats
+
+## Conclusion
+Final recommendation with confidence level
+
+## References
+Use the 'get_bibliography' tool to fetch the complete list of citations.
+Format them as a numbered list.
+
+Be comprehensive but concise. Cite evidence for all claims.""",
+        chat_client=client,
+        tools=[get_bibliography],
+        temperature=0.3,
+    )

src/agents/state.py

@@ -0,0 +1,90 @@
+"""Thread-safe state management for Magentic agents.
+
+Uses contextvars to ensure isolation between concurrent requests (e.g., multiple users
+searching simultaneously via Gradio).
+"""
+
+from contextvars import ContextVar
+from typing import TYPE_CHECKING, Any
+
+from pydantic import BaseModel, Field
+
+from src.utils.models import Citation, Evidence
+
+if TYPE_CHECKING:
+    from src.services.embeddings import EmbeddingService
+
+
+class MagenticState(BaseModel):
+    """Mutable state for a Magentic workflow session."""
+
+    evidence: list[Evidence] = Field(default_factory=list)
+    # Type as Any to avoid circular imports/runtime resolution issues
+    # The actual object injected will be an EmbeddingService instance
+    embedding_service: Any = None
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    def add_evidence(self, new_evidence: list[Evidence]) -> int:
+        """Add new evidence, deduplicating by URL.
+
+        Returns:
+            Number of *new* items added.
+        """
+        existing_urls = {e.citation.url for e in self.evidence}
+        count = 0
+        for item in new_evidence:
+            if item.citation.url not in existing_urls:
+                self.evidence.append(item)
+                existing_urls.add(item.citation.url)
+                count += 1
+        return count
+
+    async def search_related(self, query: str, n_results: int = 5) -> list[Evidence]:
+        """Search for semantically related evidence using the embedding service."""
+        if not self.embedding_service:
+            return []
+
+        results = await self.embedding_service.search_similar(query, n_results=n_results)
+
+        # Convert dict results back to Evidence objects
+        evidence_list = []
+        for item in results:
+            meta = item.get("metadata", {})
+            authors_str = meta.get("authors", "")
+            authors = [a.strip() for a in authors_str.split(",") if a.strip()]
+
+            ev = Evidence(
+                content=item["content"],
+                citation=Citation(
+                    title=meta.get("title", "Related Evidence"),
+                    url=item["id"],
+                    source="pubmed",  # Defaulting to pubmed if unknown
+                    date=meta.get("date", "n.d."),
+                    authors=authors,
+                ),
+                relevance=max(0.0, 1.0 - item.get("distance", 0.5)),
+            )
+            evidence_list.append(ev)
+
+        return evidence_list
+
+
+# The ContextVar holds the MagenticState for the current execution context
+_magentic_state_var: ContextVar[MagenticState | None] = ContextVar("magentic_state", default=None)
+
+
+def init_magentic_state(embedding_service: "EmbeddingService | None" = None) -> MagenticState:
+    """Initialize a new state for the current context."""
+    state = MagenticState(embedding_service=embedding_service)
+    _magentic_state_var.set(state)
+    return state
+
+
+def get_magentic_state() -> MagenticState:
+    """Get the current state. Raises RuntimeError if not initialized."""
+    state = _magentic_state_var.get()
+    if state is None:
+        # Auto-initialize if missing (e.g. during tests or simple scripts)
+        return init_magentic_state()
+    return state

src/agents/tools.py

@@ -0,0 +1,175 @@
+"""Tool functions for Magentic agents.
+
+These functions are decorated with @ai_function to be callable by the ChatAgent's internal LLM.
+They also interact with the thread-safe MagenticState to persist evidence.
+"""
+
+from agent_framework import ai_function
+
+from src.agents.state import get_magentic_state
+from src.tools.biorxiv import BioRxivTool
+from src.tools.clinicaltrials import ClinicalTrialsTool
+from src.tools.pubmed import PubMedTool
+
+# Singleton tool instances (stateless wrappers)
+_pubmed = PubMedTool()
+_clinicaltrials = ClinicalTrialsTool()
+_biorxiv = BioRxivTool()
+
+
+@ai_function  # type: ignore[arg-type, misc]
+async def search_pubmed(query: str, max_results: int = 10) -> str:
+    """Search PubMed for biomedical research papers.
+
+    Use this tool to find peer-reviewed scientific literature about
+    drugs, diseases, mechanisms of action, and clinical studies.
+
+    Args:
+        query: Search keywords (e.g., "metformin alzheimer mechanism")
+        max_results: Maximum results to return (default 10)
+
+    Returns:
+        Formatted list of papers with titles, abstracts, and citations
+    """
+    state = get_magentic_state()
+
+    # 1. Execute raw search
+    results = await _pubmed.search(query, max_results)
+    if not results:
+        return f"No PubMed results found for: {query}"
+
+    # 2. Semantic Deduplication & Expansion (The "Digital Twin" Brain)
+    display_results = results
+    if state.embedding_service:
+        # Deduplicate against what we just found vs what's in the DB
+        unique_results = await state.embedding_service.deduplicate(results)
+
+        # Search for related context in the vector DB (previous searches)
+        related = await state.search_related(query, n_results=3)
+
+        # Combine unique new results + relevant historical results
+        display_results = unique_results + related
+
+    # 3. Update State (Persist for ReportAgent)
+    # We add *all* found results to state, not just the displayed ones
+    new_count = state.add_evidence(results)
+
+    # 4. Format Output for LLM
+    output = [f"Found {len(results)} results ({new_count} new stored):\n"]
+
+    # Limit display to avoid context window overflow, but state has everything
+    limit = min(len(display_results), max_results)
+
+    for i, r in enumerate(display_results[:limit], 1):
+        title = r.citation.title
+        date = r.citation.date
+        source = r.citation.source
+        content_clean = r.content[:300].replace("\n", " ")
+        url = r.citation.url
+
+        output.append(f"{i}. **{title}** ({date})")
+        output.append(f"   Source: {source} | {url}")
+        output.append(f"   {content_clean}...")
+        output.append("")
+
+    return "\n".join(output)
+
+
+@ai_function  # type: ignore[arg-type, misc]
+async def search_clinical_trials(query: str, max_results: int = 10) -> str:
+    """Search ClinicalTrials.gov for clinical studies.
+
+    Use this tool to find ongoing and completed clinical trials
+    for drug repurposing candidates.
+
+    Args:
+        query: Search terms (e.g., "metformin cancer phase 3")
+        max_results: Maximum results to return (default 10)
+
+    Returns:
+        Formatted list of clinical trials with status and details
+    """
+    state = get_magentic_state()
+
+    results = await _clinicaltrials.search(query, max_results)
+    if not results:
+        return f"No clinical trials found for: {query}"
+
+    # Update state
+    new_count = state.add_evidence(results)
+
+    output = [f"Found {len(results)} clinical trials ({new_count} new stored):\n"]
+    for i, r in enumerate(results[:max_results], 1):
+        title = r.citation.title
+        date = r.citation.date
+        source = r.citation.source
+        content_clean = r.content[:300].replace("\n", " ")
+        url = r.citation.url
+
+        output.append(f"{i}. **{title}**")
+        output.append(f"   Status: {source} | Date: {date}")
+        output.append(f"   {content_clean}...")
+        output.append(f"   URL: {url}\n")
+
+    return "\n".join(output)
+
+
+@ai_function  # type: ignore[arg-type, misc]
+async def search_preprints(query: str, max_results: int = 10) -> str:
+    """Search bioRxiv/medRxiv for preprint papers.
+
+    Use this tool to find the latest research that hasn't been
+    peer-reviewed yet. Good for cutting-edge findings.
+
+    Args:
+        query: Search terms (e.g., "long covid treatment")
+        max_results: Maximum results to return (default 10)
+
+    Returns:
+        Formatted list of preprints with abstracts and links
+    """
+    state = get_magentic_state()
+
+    results = await _biorxiv.search(query, max_results)
+    if not results:
+        return f"No preprints found for: {query}"
+
+    # Update state
+    new_count = state.add_evidence(results)
+
+    output = [f"Found {len(results)} preprints ({new_count} new stored):\n"]
+    for i, r in enumerate(results[:max_results], 1):
+        title = r.citation.title
+        date = r.citation.date
+        source = r.citation.source
+        content_clean = r.content[:300].replace("\n", " ")
+        url = r.citation.url
+
+        output.append(f"{i}. **{title}**")
+        output.append(f"   Server: {source} | Date: {date}")
+        output.append(f"   {content_clean}...")
+        output.append(f"   URL: {url}\n")
+
+    return "\n".join(output)
+
+
+@ai_function  # type: ignore[arg-type, misc]
+async def get_bibliography() -> str:
+    """Get the full list of collected evidence for the bibliography.
+
+    Use this tool when generating the final report to get the complete
+    list of references.
+
+    Returns:
+        Formatted bibliography string.
+    """
+    state = get_magentic_state()
+    if not state.evidence:
+        return "No evidence collected."
+
+    output = ["## References"]
+    for i, ev in enumerate(state.evidence, 1):
+        output.append(f"{i}. {ev.citation.formatted}")
+        output.append(f"   URL: {ev.citation.url}")
+
+    return "\n".join(output)

src/orchestrator_factory.py

@@ -5,18 +5,10 @@ from typing import Any, Literal
 from src.orchestrator import JudgeHandlerProtocol, Orchestrator, SearchHandlerProtocol
 from src.utils.models import OrchestratorConfig
 
-# Define protocols again or import if they were in a shared place.
-
-# Since they are in src/orchestrator.py, we can import them?
-
-# But SearchHandler and JudgeHandler in arguments are concrete classes in the type hint,
-
-# which satisfy the protocol.
-
 
 def create_orchestrator(
-    search_handler: SearchHandlerProtocol,
-    judge_handler: JudgeHandlerProtocol,
+    search_handler: SearchHandlerProtocol | None = None,
+    judge_handler: JudgeHandlerProtocol | None = None,
     config: OrchestratorConfig | None = None,
     mode: Literal["simple", "magentic"] = "simple",
 ) -> Any:
@@ -24,27 +16,33 @@ def create_orchestrator(
     Create an orchestrator instance.
 
     Args:
-        search_handler: The search handler
-        judge_handler: The judge handler
+        search_handler: The search handler (required for simple mode)
+        judge_handler: The judge handler (required for simple mode)
         config: Optional configuration
-        mode: "simple" for Phase 4 loop, "magentic" for Phase 5 multi-agent
+        mode: "simple" for Phase 4 loop, "magentic" for ChatAgent-based multi-agent
 
     Returns:
-        Orchestrator instance (same interface regardless of mode)
+        Orchestrator instance
+
+    Note:
+        Magentic mode does NOT use search_handler/judge_handler.
+        It creates ChatAgent instances with internal LLMs that call tools directly.
     """
     if mode == "magentic":
         try:
             from src.orchestrator_magentic import MagenticOrchestrator
 
             return MagenticOrchestrator(
-                search_handler=search_handler,
-                judge_handler=judge_handler,
                 max_rounds=config.max_iterations if config else 10,
             )
         except ImportError:
             # Fallback to simple if agent-framework not installed
             pass
 
+    # Simple mode requires handlers
+    if search_handler is None or judge_handler is None:
+        raise ValueError("Simple mode requires search_handler and judge_handler")
+
     return Orchestrator(
         search_handler=search_handler,
         judge_handler=judge_handler,

src/orchestrator_magentic.py

@@ -1,18 +1,9 @@
-"""Magentic-based orchestrator for DeepCritical.
-
-NOTE: Magentic mode currently requires OpenAI API keys. The MagenticBuilder's
-standard manager uses OpenAIChatClient. Anthropic support may be added when
-the agent_framework provides an AnthropicChatClient.
-"""
+"""Magentic-based orchestrator using ChatAgent pattern."""
 
 from collections.abc import AsyncGenerator
 from typing import TYPE_CHECKING, Any
 
 import structlog
-
-if TYPE_CHECKING:
-    from src.services.embeddings import EmbeddingService
-
 from agent_framework import (
     MagenticAgentDeltaEvent,
     MagenticAgentMessageEvent,
@@ -23,45 +14,49 @@ from agent_framework import (
 )
 from agent_framework.openai import OpenAIChatClient
 
-from src.agents.hypothesis_agent import HypothesisAgent
-from src.agents.judge_agent import JudgeAgent
-from src.agents.report_agent import ReportAgent
-from src.agents.search_agent import SearchAgent
-from src.orchestrator import JudgeHandlerProtocol, SearchHandlerProtocol
+from src.agents.magentic_agents import (
+    create_hypothesis_agent,
+    create_judge_agent,
+    create_report_agent,
+    create_search_agent,
+)
+from src.agents.state import init_magentic_state
 from src.utils.config import settings
 from src.utils.exceptions import ConfigurationError
-from src.utils.models import AgentEvent, Evidence
-
-logger = structlog.get_logger()
+from src.utils.models import AgentEvent
 
+if TYPE_CHECKING:
+    from src.services.embeddings import EmbeddingService
 
-def _truncate(text: str, max_len: int = 100) -> str:
-    """Truncate text with ellipsis only if needed."""
-    return f"{text[:max_len]}..." if len(text) > max_len else text
+logger = structlog.get_logger()
 
 
 class MagenticOrchestrator:
     """
-    Magentic-based orchestrator - same API as Orchestrator.
-
-    Uses Microsoft Agent Framework's MagenticBuilder for multi-agent coordination.
+    Magentic-based orchestrator using ChatAgent pattern.
 
-    Note:
-        Magentic mode requires OPENAI_API_KEY. The MagenticBuilder's standard
-        manager currently only supports OpenAI. If you have only an Anthropic
-        key, use the "simple" orchestrator mode instead.
+    Each agent has an internal LLM that understands natural language
+    instructions from the manager and can call tools appropriately.
     """
 
     def __init__(
         self,
-        search_handler: SearchHandlerProtocol,
-        judge_handler: JudgeHandlerProtocol,
         max_rounds: int = 10,
+        chat_client: OpenAIChatClient | None = None,
     ) -> None:
-        self._search_handler = search_handler
-        self._judge_handler = judge_handler
+        """Initialize orchestrator.
+
+        Args:
+            max_rounds: Maximum coordination rounds
+            chat_client: Optional shared chat client for agents
+        """
+        if not settings.openai_api_key:
+            raise ConfigurationError(
+                "Magentic mode requires OPENAI_API_KEY. " "Set the key or use mode='simple'."
+            )
+
         self._max_rounds = max_rounds
-        self._evidence_store: dict[str, list[Evidence]] = {"current": []}
+        self._chat_client = chat_client
 
     def _init_embedding_service(self) -> "EmbeddingService | None":
         """Initialize embedding service if available."""
@@ -77,19 +72,19 @@ class MagenticOrchestrator:
             logger.warning("Failed to initialize embedding service", error=str(e))
         return None
 
-    def _build_workflow(
-        self,
-        search_agent: SearchAgent,
-        hypothesis_agent: HypothesisAgent,
-        judge_agent: JudgeAgent,
-        report_agent: ReportAgent,
-    ) -> Any:
-        """Build the Magentic workflow with participants."""
-        if not settings.openai_api_key:
-            raise ConfigurationError(
-                "Magentic mode requires OPENAI_API_KEY. "
-                "Set the key or use mode='simple' with Anthropic."
-            )
+    def _build_workflow(self) -> Any:
+        """Build the Magentic workflow with ChatAgent participants."""
+        # Create agents with internal LLMs
+        search_agent = create_search_agent(self._chat_client)
+        judge_agent = create_judge_agent(self._chat_client)
+        hypothesis_agent = create_hypothesis_agent(self._chat_client)
+        report_agent = create_report_agent(self._chat_client)
+
+        # Manager chat client (orchestrates the agents)
+        manager_client = OpenAIChatClient(
+            model_id="gpt-4o",  # Good model for planning/coordination
+            api_key=settings.openai_api_key,
+        )
 
         return (
             MagenticBuilder()
@@ -100,9 +95,7 @@ class MagenticOrchestrator:
                 reporter=report_agent,
             )
             .with_standard_manager(
-                chat_client=OpenAIChatClient(
-                    model_id=settings.openai_model, api_key=settings.openai_api_key
-                ),
+                chat_client=manager_client,
                 max_round_count=self._max_rounds,
                 max_stall_count=3,
                 max_reset_count=2,
@@ -110,46 +103,15 @@ class MagenticOrchestrator:
             .build()
         )
 
-    def _format_task(self, query: str, has_embeddings: bool) -> str:
-        """Format the task instruction for the manager."""
-        semantic_note = ""
-        if has_embeddings:
-            semantic_note = """
-The system has semantic search enabled. When evidence is found:
-1. Related concepts will be automatically surfaced
-2. Duplicates are removed by meaning, not just URL
-3. Use the surfaced related concepts to refine searches
-"""
-        return f"""Research drug repurposing opportunities for: {query}
-{semantic_note}
-Workflow:
-1. SearcherAgent: Find initial evidence from PubMed and web. SEND ONLY A SIMPLE KEYWORD QUERY.
-2. HypothesisAgent: Generate mechanistic hypotheses (Drug -> Target -> Pathway -> Effect).
-3. SearcherAgent: Use hypothesis-suggested queries for targeted search.
-4. JudgeAgent: Evaluate if evidence supports hypotheses.
-5. If sufficient -> ReportAgent: Generate structured research report.
-6. If not sufficient -> Repeat from step 1 with refined queries.
-
-Focus on:
-- Identifying specific molecular targets
-- Understanding mechanism of action
-- Finding supporting/contradicting evidence for hypotheses
-
-The final output should be a complete research report with:
-- Executive summary
-- Methodology
-- Hypotheses tested
-- Mechanistic and clinical findings
-- Drug candidates
-- Limitations
-- Conclusion with references
-"""
-
     async def run(self, query: str) -> AsyncGenerator[AgentEvent, None]:
         """
-        Run the Magentic workflow - same API as simple Orchestrator.
+        Run the Magentic workflow.
+
+        Args:
+            query: User's research question
 
-        Yields AgentEvent objects for real-time UI updates.
+        Yields:
+            AgentEvent objects for real-time UI updates
         """
         logger.info("Starting Magentic orchestrator", query=query)
 
@@ -159,20 +121,27 @@ The final output should be a complete research report with:
             iteration=0,
         )
 
-        # Initialize services and agents
+        # Initialize context state
         embedding_service = self._init_embedding_service()
-        search_agent = SearchAgent(
-            self._search_handler, self._evidence_store, embedding_service=embedding_service
-        )
-        judge_agent = JudgeAgent(self._judge_handler, self._evidence_store)
-        hypothesis_agent = HypothesisAgent(
-            self._evidence_store, embedding_service=embedding_service
-        )
-        report_agent = ReportAgent(self._evidence_store, embedding_service=embedding_service)
+        init_magentic_state(embedding_service)
+
+        workflow = self._build_workflow()
+
+        task = f"""Research drug repurposing opportunities for: {query}
 
-        # Build workflow and task
-        workflow = self._build_workflow(search_agent, hypothesis_agent, judge_agent, report_agent)
-        task = self._format_task(query, embedding_service is not None)
+Workflow:
+1. SearchAgent: Find evidence from PubMed, ClinicalTrials.gov, and bioRxiv
+2. HypothesisAgent: Generate mechanistic hypotheses (Drug -> Target -> Pathway -> Effect)
+3. JudgeAgent: Evaluate if evidence is sufficient
+4. If insufficient -> SearchAgent refines search based on gaps
+5. If sufficient -> ReportAgent synthesizes final report
+
+Focus on:
+- Identifying specific molecular targets
+- Understanding mechanism of action
+- Finding clinical evidence supporting hypotheses
+
+The final output should be a structured research report."""
 
         iteration = 0
         try:
@@ -182,6 +151,7 @@ The final output should be a complete research report with:
                     if isinstance(event, MagenticAgentMessageEvent):
                         iteration += 1
                     yield agent_event
+
         except Exception as e:
             logger.error("Magentic workflow failed", error=str(e))
             yield AgentEvent(
@@ -191,35 +161,41 @@ The final output should be a complete research report with:
             )
 
     def _process_event(self, event: Any, iteration: int) -> AgentEvent | None:
-        """Process a workflow event and return an AgentEvent if applicable."""
+        """Process workflow event into AgentEvent."""
         if isinstance(event, MagenticOrchestratorMessageEvent):
-            message_text = (
-                event.message.text if event.message and hasattr(event.message, "text") else ""
-            )
-            kind = getattr(event, "kind", "manager")
-            if message_text:
+            text = event.message.text if event.message else ""
+            if text:
                 return AgentEvent(
                     type="judging",
-                    message=f"Manager ({kind}): {_truncate(message_text)}",
+                    message=f"Manager ({event.kind}): {text[:200]}...",
                     iteration=iteration,
                 )
 
         elif isinstance(event, MagenticAgentMessageEvent):
             agent_name = event.agent_id or "unknown"
-            msg_text = (
-                event.message.text if event.message and hasattr(event.message, "text") else ""
+            text = event.message.text if event.message else ""
+
+            event_type = "judging"
+            if "search" in agent_name.lower():
+                event_type = "search_complete"
+            elif "judge" in agent_name.lower():
+                event_type = "judge_complete"
+            elif "hypothes" in agent_name.lower():
+                event_type = "hypothesizing"
+            elif "report" in agent_name.lower():
+                event_type = "synthesizing"
+
+            return AgentEvent(
+                type=event_type,  # type: ignore[arg-type]
+                message=f"{agent_name}: {text[:200]}...",
+                iteration=iteration + 1,
             )
-            return self._agent_message_event(agent_name, msg_text, iteration + 1)
 
         elif isinstance(event, MagenticFinalResultEvent):
-            final_text = (
-                event.message.text
-                if event.message and hasattr(event.message, "text")
-                else "No result"
-            )
+            text = event.message.text if event.message else "No result"
             return AgentEvent(
                 type="complete",
-                message=final_text,
+                message=text,
                 data={"iterations": iteration},
                 iteration=iteration,
             )
@@ -242,35 +218,3 @@ The final output should be a complete research report with:
                 )
 
         return None
-
-    def _agent_message_event(self, agent_name: str, msg_text: str, iteration: int) -> AgentEvent:
-        """Create an AgentEvent for an agent message."""
-        if "search" in agent_name.lower():
-            return AgentEvent(
-                type="search_complete",
-                message=f"Search agent: {_truncate(msg_text)}",
-                iteration=iteration,
-            )
-        elif "hypothes" in agent_name.lower():
-            return AgentEvent(
-                type="hypothesizing",
-                message=f"Hypothesis agent: {_truncate(msg_text)}",
-                iteration=iteration,
-            )
-        elif "judge" in agent_name.lower():
-            return AgentEvent(
-                type="judge_complete",
-                message=f"Judge agent: {_truncate(msg_text)}",
-                iteration=iteration,
-            )
-        elif "report" in agent_name.lower():
-            return AgentEvent(
-                type="synthesizing",
-                message=f"Report agent: {_truncate(msg_text)}" if msg_text else "Report generated.",
-                iteration=iteration,
-            )
-        return AgentEvent(
-            type="judging",
-            message=f"{agent_name}: {_truncate(msg_text)}",
-            iteration=iteration,
-        )