Deep Research Agents

Agents that spend minutes to tens of minutes planning, searching the web in parallel, reading, and synthesising a cited report; architecture, vendor implementations (OpenAI, Google, Anthropic, Perplexity), evaluation, cost and failure modes.

Contents

Deep research agents are LLM agents that take an open-ended question and spend minutes to tens of minutes on it. They plan, run many rounds of web (and private-data) search, read and cross-check sources, and produce a structured report with citations. A survey defines them by five capabilities: dynamic reasoning, long-horizon planning, multi-hop retrieval, iterative tool use and structured report generation (Huang et al.). They are the high-effort end of agentic RAG. The retrieval path is not fixed in advance; the agent chooses its next query based on what it has read so far, unlike static RAG, which retrieves similar chunks once (Anthropic).

Reference architecture

Anthropic’s published design is the clearest public blueprint. It is an orchestrator-worker system (Anthropic):

  1. Lead agent (planner). It analyses the query, writes a plan and saves it to external memory, because context beyond 200k tokens is truncated.
  2. Parallel search subagents. Each gets a specific brief, runs its own search-evaluate-refine loop in a fresh context window, and returns condensed findings. See subagents.
  3. Synthesis loop. The lead merges the findings and decides whether to spawn more subagents or change strategy.
  4. Citation agent. It takes the finished report plus the source documents and attaches a citation to each claim.
flowchart TD
  U["User query"] --> C["Clarify / rewrite brief (optional)"]
  C --> L["Lead agent: plan, save plan to memory"]
  L --> S1["Subagent 1: search, read, refine"]
  L --> S2["Subagent 2: search, read, refine"]
  L --> S3["Subagent N: search, read, refine"]
  S1 --> L2["Lead: synthesise, check gaps"]
  S2 --> L2
  S3 --> L2
  L2 -- "gaps remain" --> L
  L2 -- "enough" --> W["Write report"]
  W --> V["Citation agent: map claims to sources"]
  V --> R["Cited report"]

The clarify step comes from OpenAI’s cookbook (cookbook) and Gemini’s collaborative planning (Gemini). The rest follows Anthropic’s description.

Design rules from the Anthropic write-up:

  • Delegate precisely. Each subagent brief needs an objective, an output format, tool guidance and boundaries. Vague briefs led to duplicated searches.
  • Scale effort to the query. Roughly 1 agent and 3-10 tool calls for a simple fact; 10+ subagents for complex research. Embed these rules in the prompt, because agents misjudge effort.
  • Search broad, then narrow. Start with short queries and refine them.
  • Parallelise at two levels. The lead runs 3-5 subagents at once, and each subagent issues 3+ tool calls in parallel. This cut research time by up to 90% on complex queries.
  • Think between tool calls. The lead plans with extended thinking; subagents use interleaved thinking to judge results and pick the next query.
  • Pass references, not blobs. Subagents can write outputs to external storage and return pointers, which avoids a lossy relay through the lead. See agent memory.

Older academic systems such as STORM use a fixed pipeline instead of a dynamic loop. STORM finds perspectives, simulates writers questioning a grounded “expert”, builds an outline, then writes. Against an outline-driven RAG baseline, its articles were judged more organised (+25% absolute) and broader (+10%) (STORM). The survey classifies systems by static versus dynamic workflow, single versus multi-agent, planning strategy, and API versus browser-based retrieval (survey).

Why it works: tokens and trained persistence

  • On BrowseComp, a benchmark, token usage alone explained about 80% of performance variance in Anthropic’s analysis; tool-call count and model choice explained most of the rest. Multi-agent designs work largely because they let the system spend more tokens in parallel, separate context windows (Anthropic). This is test-time compute applied to retrieval.
  • An Opus 4 lead with Sonnet 4 subagents beat a single Opus 4 agent by 90.2% on Anthropic’s internal eval, with the biggest gains on breadth-first questions (Anthropic).
  • BrowseComp (1,266 hard-to-find, easy-to-check questions): GPT-4o with browsing scored 1.9%, o1 9.9%, and OpenAI Deep Research 51.5%. Accuracy rose smoothly with browsing effort, and aggregating 64 sampled answers (majority vote, confidence-weighted vote, best-of-N) added roughly 15-25%, with best-of-N by the model’s own confidence doing best (BrowseComp). Synthesis: giving a chat model a search tool is not enough; the gain comes from a model trained to search persistently.
  • OpenAI trained its deep research model, an early o3 variant, with reinforcement learning on browsing tasks: searching, clicking, scrolling, reading files and using Python. Tasks were graded against ground truth or rubrics by a chain-of-thought grader (system card).

Vendor implementations (as of 2026-11)

OpenAIGoogle GeminiAnthropicPerplexity
FormResponses API: reasoning model + hosted web_search, background: trueManaged agent via Interactions APIClaude Research product; in the API you build it from web_search/web_fetch + subagentsAgent API effort presets
Current IDsdedicated o3-/o4-mini-deep-research shut down 2026-07-23 (replacement gpt-5.6-sol); guide now recommends gpt-6-astra at high/xhigh reasoningdeep-research-preview-04-2026, deep-research-max-preview-04-2026orchestrator-worker design (Opus lead, Sonnet workers in the 2025 write-up)high (40 steps), xhigh (300 steps, Claude Opus 5.5 by default), ultra
Data sourcesweb search, MCP, file search, code interpretergoogle_search, url_context, code_execution, file_search, mcp_serverany tools, incl. MCPweb_search, fetch_url, sandbox, finance search
Async / steeringbackground mode + polling; max_tool_calls capbackground=True, polling or streaming with thought summaries, resume with last_event_id; collaborative_planninglead waits synchronously per subagent batchpreset step budget
Citationsurl_citation annotations with char spanscited reportdedicated citation agentgrounded citations

Sources: OpenAI cookbook, deprecations, OpenAI web search guide, Gemini, Anthropic, Perplexity.

Synthesis: the market has moved from dedicated “deep research models” to two forms. One is a general reasoning model at high effort with hosted search in background mode (OpenAI, Perplexity presets). The other is a managed research agent behind an async API (Gemini). Building your own on web search APIs remains the way to control sources, cost and private data.

Building one yourself

  • Front-load clarification. OpenAI’s deep research API never asks questions, so its cookbook puts a cheap model first to ask a few scoping questions and rewrite the answers into a detailed brief (cookbook). Gemini offers a plan-review loop instead (Gemini). This is a natural human-in-the-loop checkpoint.
  • Run it as a job, not a request. Runs take minutes. Use background mode or polling and checkpointing; Anthropic resumes from checkpoints because errors compound in long runs (Anthropic). See durable agent execution.
  • Cap the budget. Use max_uses per search tool (Claude), max_tool_calls (OpenAI cookbook) and step budgets (Perplexity presets). Expect about 15x chat-level tokens for multi-agent research (Anthropic).
  • Keep worker context lean. Use pre-chunked results or dynamic filtering so subagents return conclusions, not page dumps (Claude search). See context engineering.
  • Verify citations separately. A final pass checks that each claim is supported by the cited span. Anthropic uses a dedicated agent for this (Anthropic); see verification and evals.
  • Trace everything. Paths are non-deterministic, so full production tracing is the only way to debug (Anthropic). See LLM observability.

Evaluation

Grade outcomes, not trajectories: different valid paths reach the same answer. Anthropic started with about 20 real queries and used one LLM-as-judge rubric covering factual accuracy, citation accuracy, completeness, source quality and tool efficiency, scored 0-1 with pass/fail. Human testers still caught a preference for SEO content farms (Anthropic). For short-answer browsing ability, BrowseComp is the standard benchmark (BrowseComp). The survey argues that current benchmarks fit the practical goals of deep research poorly (survey). See agent evaluation.

Failure modes

  • Prompt injection and exfiltration. Browsed pages can steer the agent to wrong answers or try to leak context such as API keys through URLs. OpenAI trained against injections and blocked the agent from navigating to or constructing arbitrary URLs (system card). Claude’s fetch tool similarly fetches only URLs already in context (web fetch). Keep public search and private MCP calls in separate requests (OpenAI guide). See prompt injection.
  • Source bias and bad sources. STORM found that bias in sources transfers into the article and that unrelated facts get over-associated (STORM). Agents also prefer SEO farms unless told otherwise (Anthropic).
  • Overconfidence. Deep Research’s BrowseComp calibration error was 91% (BrowseComp). Do not trust stated confidence.
  • Duplicated or runaway work. Vague briefs make subagents overlap; without effort rules agents over-search simple questions (Anthropic).
  • Synchronous bottleneck. A lead waiting on its slowest subagent cannot steer mid-flight. Async execution adds coordination and error-propagation problems (Anthropic).
  • Model churn. Dedicated deep research models were retired within about a year (deprecations). Wrap the vendor call behind your own interface (see model routing and fallbacks).

When to use / when not

  • Use for high-value, breadth-first questions whose sub-questions can run in parallel: market and competitor scans, literature reviews, due diligence, multi-entity comparisons (Anthropic).
  • Don’t use for single-fact lookups (one search call is enough), latency-sensitive UX, or tightly coupled work like most coding, where sub-tasks share too much context to parallelise (Anthropic). Synthesis: if the answer lives in your own documents, try agentic RAG over internal data first; web-scale research costs much more.

Sources

Suggest changes →