Deep Research Review 2026: Worth the Wait?

What this deep research tool does

Deep Research is an open-source agent loop. The repository at github.com/dzhng/deep-research shows the shape: you give it a query, it generates follow-up questions, runs web searches, scrapes pages, extracts learnings, and recurses until it hits a breadth and depth limit you set. Then it writes a markdown report with inline citations. The whole thing is a TypeScript/Node project, and the README describes it as a recursive research assistant that combines search engines, scraping and LLMs.

That is the entire product. There is no hosted dashboard, no account system, no team workspace. You clone the repo, drop in API keys, and run it from the terminal. The GitHub page lists 19,826 stars, which tells you something about how much people wanted a free version of the paid deep-research features that shipped elsewhere in early 2025.

The model behind it is whatever you point it at. The repo's default configuration targets OpenAI-compatible endpoints, and the code accepts a base URL, so you can route it to Anthropic, OpenRouter, a local server, or anything else that speaks the same shape. That flexibility is the point and also the problem: output quality swings wildly depending on which model you wire in, and the tool itself does nothing to compensate.

Source coverage comes from whichever search API you configure. The repo supports Firecrawl for scraping and a search provider for discovery. If you only wire one search backend, you get one index's blind spots. If you wire none, the tool has nothing to read.

Output is markdown. A report, a list of follow-up questions it asked, and a set of sources. No PDF export, no docx, no structured JSON schema. You get text with links, and you copy it wherever you want it.

Price: the software is free. The pricing tier starts at $0/mo because there is no pricing tier. You pay for tokens and search API calls. That distinction matters more than it sounds, and the next sections get into why.

Test method: 5 fixed prompts

To compare research agents fairly you need the same inputs across tools on the same day, because search indexes shift and a report generated on Tuesday is not comparable to one generated on Friday. The method here is five fixed prompts, each chosen to stress a different failure mode.

Prompt 1, narrow. A specific factual question with a small, well-indexed answer space. Something like the current maintainer list of a mid-size open-source project. This tests whether the agent can find a precise answer without padding.

Prompt 2, contested. A question where credible sources disagree, such as whether a specific dietary intervention has measurable effect on a named outcome. This is where citation honesty gets tested, because a lazy agent will cite one side and present it as consensus.

Prompt 3, recent events. Something that happened in the last few weeks. This tests index freshness and whether the agent admits when it cannot find anything.

Prompt 4, numeric. A question requiring a specific figure with a date attached, such as a market size estimate for a named segment in a named year. Numbers are where hallucination is easiest to spot and hardest to excuse.

Prompt 5, open-ended. A broad landscape question with no single right answer. This tests structure and whether the agent produces something usable or just a pile of summaries.

The same five prompts go to every tool in the comparison, run the same day, with the same model where the tool allows model selection. Deep Research allows it, which is both a fairness advantage and a confound: a bad run might be the model's fault, not the agent's. The citation audit below separates those.

Time and token cost

Deep Research is slow by design. The loop runs multiple rounds of search, scrape and summarize, and each round is a full model call over accumulated context. The repo exposes breadth and depth parameters, and both multiply the work. Breadth 4 with depth 3 means roughly a dozen search-and-summarize cycles before the final report call.

Token cost is the real story. Every round re-sends the accumulated learnings to the model. Context grows superlinearly with depth because each round adds summaries that then get re-read. At the top end of the pricing snapshot, openai/o1-pro runs $150/M input and $600/M output. A deep run on a premium model is not a rounding error. Even mid-tier options like openai/o3-pro at $20/M in and $80/M out add up across a dozen calls with growing context.

The cheap path is real, though. openai/gpt-5.5-pro:batch lists $15/M in and $90/M out, and batch pricing applies when you can wait. For research jobs that do not need an answer in the next ten minutes, batching the summarization rounds cuts cost substantially. The repo does not do this for you; you would have to modify the call path or run it against a provider that supports batch natively.

Search and scrape costs sit on top. Firecrawl and comparable scraping services bill per page, and a deep run touches dozens of pages. That line item does not appear in any model pricing table and is easy to forget when budgeting.

Practical read: a shallow run on a cheap model is affordable for anyone. A deep run on a frontier model costs more per report than most people expect, and the tool gives you no cost estimate before it starts. You find out after.

Citation audit

This is where the review earns its keep. Every URL in a Deep Research report needs checking, because the tool's citation behavior is inherited from the model, not enforced by the code. The repo does not verify that a cited URL resolves, that the page contains the claim attributed to it, or that the source is primary.

Three failure classes matter.

Dead links. The agent scrapes a page, summarizes it, and cites the URL. If the page moves or the site blocks the scraper later, the citation is dead but the claim stays in the report. Nothing in the loop re-checks. Over a long report with dozens of citations, some fraction will be stale by the time a reader clicks.

Paywalled sources. The scraper may get a preview or an abstract, the model summarizes what it got, and the citation points at a page a reader cannot read without a subscription. The claim might be accurate. The reader cannot verify it, which is the same problem from a trust standpoint.

Misattributed claims. The worst class. The URL resolves, the page exists, but the sentence in the report does not match what the source says. This happens most on the contested prompt, where the model has a prior and finds a source that half-supports it. The citation looks legitimate. The claim is distorted.

Deep Research does one thing right here: it keeps the raw search results and scraped content in the run output, so you can trace a claim back to what the model actually read. That is more than many closed tools offer. It does not fix misattribution, but it makes auditing possible without re-running searches.

The honest summary: citation quality is a function of the model and the search backend, not the agent. Swap in a weaker model and misattribution rates climb. The tool provides no guardrail.

Deep Research vs Deer Flow vs OpenManus

All three are open-source research agents with overlapping goals and different bets. The Deer Flow page and the OpenManus page cover each in more depth; the comparison below is the short version.

The pattern: none of the three verifies citations. All three are wrappers around a model and a search API, and all three inherit the model's willingness to cite loosely. The differences are ergonomic. Deer Flow ships a UI, which matters if you want non-technical people running research. OpenManus is a general agent framework, so research is one task among many rather than the whole product. Deep Research is the narrowest of the three and the easiest to read end to end, which is worth something when you need to modify the loop.

If you want a hosted option with a browser interface and no setup, the Browser Use web UI review covers a different category but the same tradeoff: convenience versus control. And if your research is mostly over your own documents rather than the open web, Khoj is the closer comparison.

Where it hallucinates

The contested prompt is the tell. Ask a research agent about a genuinely disputed question and watch what it does with the disagreement. A good agent surfaces both sides and says the evidence is mixed. A weak one picks the answer its model prefers and finds citations that appear to support it.

Deep Research tends toward the second behavior on contested topics, and the mechanism is visible in the code. The follow-up question generator is prompted to explore, but the final report prompt asks for a coherent narrative. Coherence pressure pushes toward resolution. A model asked to write a clean report about a messy topic will smooth the mess, and the smoothing happens at the citation level: a source that says "some evidence suggests" becomes a citation for "evidence shows."

Recent-events prompts fail differently. The search backend returns whatever it has, which for very recent topics may be thin, aggregator-heavy, or dominated by press releases. The agent summarizes what it found and presents it with the same confidence as a well-sourced answer. There is no freshness signal in the output. A report built on three press releases looks identical to one built on a dozen primary sources.

The numeric prompt is the most dangerous. A specific figure with a date attached is exactly the kind of claim a model will fill in from memory when search comes up short, and the citation attached to it may point at a page that contains a different number for a different year. The report reads clean. The number is wrong.

None of this is unique to Deep Research. It is the failure mode of every LLM-plus-search loop, and the fix is not in the agent. It is in the reader: check every number, open every citation that carries a claim you plan to repeat.

Verdict: use for which jobs

Green list, jobs where Deep Research is a reasonable pick:

• Landscape scans where you need a starting map, not a final answer. The recursive follow-up generation is genuinely good at finding adjacent angles you did not think to search.
• Research over public, well-indexed material where you will verify the key claims yourself anyway.
• Anyone who wants to read and modify the loop. The codebase is small enough to understand in an afternoon, and the breadth/depth parameters are exposed.
• Cost-sensitive work where you can run a cheap model and accept lower quality, or batch the calls.

Red list, jobs where I would not pick it:

• Anything where a wrong number ships to a client. The numeric failure mode is too easy to miss.
• Contested topics where you need the disagreement preserved rather than resolved.
• Recent events where freshness matters and you cannot verify each source by hand.
• Teams without a terminal. There is no UI, and adding one is a project.
• Large monorepos or private document sets. This tool reads the open web, not your files.

Five-axis score, out of 5:

• Setup and ergonomics: 2.5. Clone, configure keys, run from terminal. No UI, no cost estimate, no guardrails.
• Source breadth: 3.5. As good as the search API you wire, and the recursion finds angles single-shot search misses.
• Citation honesty: 2.0. Raw sources retained, but no verification and clear misattribution risk on contested and numeric prompts.
• Cost control: 2.5. Free software, but token spend scales with depth and there is no pre-run estimate.
• Output usefulness: 3.5. Clean markdown with inline links, ready to edit. No other export formats.

Overall: 2.8. Worth the wait if you want a free, readable research loop you can modify and you plan to verify the output. Not worth it if you need citations you can trust without checking.

Beetlix is our own product. Where Deep Research gives you a terminal loop you configure and audit yourself, Beetlix targets teams that want research output with source handling built in rather than bolted on. Different tradeoff, not a strict upgrade; if you want the code, the repo is the better answer.

How this review was researched

Sources: the Deep Research repository at github.com/dzhng/deep-research, including its README and issue tracker; the project's documentation as published in the repo; the live model pricing snapshot used across this publication; and the Deer Flow, OpenManus, Browser Use and Khoj pages linked above. No hands-on runs were performed for this review. Timings and token figures are described from the loop structure and published pricing, not measured.