Deep Research Mode

• Deep Research Mode is a structured, multi-step agentic workflow that converts free-form prompts into targeted searches and produces detailed, reference-rich reports.
• It employs iterative query refinement, transparent progress notifications, and reproducible state management to ensure verifiable synthesis.
• UDR decouples research strategies from language models, enabling flexible, user-editable protocols and domain-specific research customization.

Deep Research Mode is defined as a search-intensive, multi-step agentic workflow in which a natural-language prompt is analyzed, a targeted sequence of web or document searches is planned and executed, retrieved information is aggregated and validated, and the output is a structured, reference-rich report with full markdown formatting. Key features include iterativity (the agent issues and refines queries through multiple cycles), transparency of progress, and highly structured outputs. Unlike retrieval-augmented generation (RAG) or single-shot QA, Deep Research Mode empowers explicit planning, dynamic query adaptation, multi-tool orchestration—including APIs, browsers, or code interpreters—and end-to-end synthesis grounded in live evidence. Universal Deep Research (UDR) further generalizes this paradigm by dissociating the agent’s “strategy” from the underlying LLM or toolchain, making both first-class, user-editable abstractions (Belcak et al., 29 Aug 2025).

1. Formal Definition and Motivations

Deep research is framed as a multi-stage workflow:

• Prompt analysis: conversion of a free-form user request into a plan.
• Sequential information seeking: issuing queries, inspecting results, and generating follow-up queries.
• Aggregation and validation: combining and cross-verifying retrieved facts across heterogeneous sources.
• Synthesis and reporting: generating markdown-structured, citation-anchored documents (Belcak et al., 29 Aug 2025).

Existing systems tightly couple an agent to a research strategy and model, introducing three core limitations:

• Inflexibility in encoding resource hierarchies or budget constraints.
• Inaccessibility for domain-specific strategies.
• Coupling of research strategies with specific LLMs.

UDR decouples these axes, allowing arbitrary pairing of models and strategies (Belcak et al., 29 Aug 2025).

2. System Architecture: Universal Deep Research (UDR)

The UDR architecture comprises five main components:

1. Strategy Repository & Editor: Stores and enables free-form, real-time editing of research strategies formulated in natural language. Strategies can encode arbitrary policies for search, validation, and report synthesis.
2. Policy Manager (StrategyParser): Uses a selected LLM to translate a user or template strategy from natural language into a strictly controlled Python function def research(prompt): ..., which yields notifications and, ultimately, a complete Markdown report. The function only permits specific tool primitives (e.g., search, call_llm).
3. Tool Registry: A registry exposing synchronous primitives, such as search(phrase) → List[Document] and call_llm(text, instructions) → str. Arbitrary backends and endpoints may be connected.
4. Execution Engine & Sandbox: A secure Python sandbox executes the generated code, managing internal state variables and providing stepwise progress notifications, eliminating context bloat typical in token-based state management.
5. UI Layer: Facilitates strategy selection and editing, research prompt input, progress visualization, and Markdown report rendering (Belcak et al., 29 Aug 2025).

This modularization allows both arbitrary research strategies and arbitrary LLMs to be interchanged at will.

3. Research Strategy as a Formal Object

A research strategy $S$ is represented as a state transition function:

$$S : \text{Prompt} \times \text{State} \to (\text{Notification}, \text{State}^\prime) \cup \text{FinalReport}$$

Execution proceeds as a deterministic state machine, with the agent iteratively transforming state and producing transparent progress outputs:

• $s_0 = \text{init\_state}(P)$
• For $t = 0,1,2,\ldots$:
  • $(n_t, s_{t+1}) \gets S(P, s_t)$

Notifications provide step-by-step status to the user (searches issued, results processed, subgoals completed). The process continues until a structured final report is available, ensuring all intermediate state is both preserved and made transparent in the output stream. The mechanism enforces that all tool use and reasoning be reproducible (sandboxed state, pure functions, no hidden side-effects) (Belcak et al., 29 Aug 2025).

4. Research Strategy Design: Minimal, Expansive, Intensive

UDR supports arbitrary user-specified strategies, including but not limited to:

• Minimal: Issue one query, aggregate results, synthesize report.
• Expansive: Explore recursively, emit multiple broad queries at each step, summarize at various granularities before reporting.
• Intensive: Iteratively refine queries, validate new evidence, perform multi-round verification, defer report synthesis until subgoals are all complete.

Each strategy can encode preferred resource orderings and dynamically adapt to findings. Strategies are encoded as free-form natural language, parsed into code on demand, and can be shared, forked, and edited by users without model retraining (Belcak et al., 29 Aug 2025).

5. Agentic Execution and State Handling

All execution proceeds within a secure Python sandbox. State is stored in explicit, versioned variables, avoiding LLM context length constraints. The execution environment supports generator syntax, allowing the strategy to yield fine-grained progress and intermediate results as it proceeds (e.g., per-search or per-evidence-aggregation notifications). Tool calls are dispatched synchronously, with results appended to the state. This architecture enables real-time inspection, debugging, and user intervention at any step (Belcak et al., 29 Aug 2025).

The agent delivers final structured Markdown documents with section headings, citations, tables, and inline references, leveraging the user-specified formatting policy embedded in the research strategy.

6. Transparency, Auditability, and User Control

UDR emphasizes progress transparency (step-by-step notifications), full user editability for all strategies, and strict reproducibility of execution via explicit state management. The user may:

• Select or input arbitrary research strategies.
• Edit and re-execute strategies without system redeployment.
• Observe all internal steps, input/output pairs, and decision points as notifications.

By separating strategy from model and tool, researchers can encode domain-specific protocols (e.g., legal, financial), impose budget constraints, or enforce custom evidence standards without touching base LLM or tool implementation (Belcak et al., 29 Aug 2025).

7. Implications and Impact

Universal Deep Research demonstrates that a flexible architecture decoupling model, tool, and strategy unlocks new forms of customization, auditability, and domain adaptability, previously obstructed by monolithic, hard-coded agent designs. Empirical studies with example minimal, expansive, and intensive strategies document the broad scope of research behaviors achievable without LLM retraining.

This approach overcomes the three limitations identified for classical DRTs—enabling users to encode resource/budget preferences, instantiate specialized strategies per domain, and bring their own LLMs. As a result, Deep Research Mode in UDR represents a fundamental step toward general, auditable, and researcher-controllable agentic systems for search, analysis, and scholarly synthesis (Belcak et al., 29 Aug 2025).