Self-Hosted Deep Research Systems: 12 Tools Compared

Deep Research has become its own category of software, not just a model pointed at a search box. This article compares twelve self-hosted systems and the research architectures behind them.

The line that actually matters is not whether a product ships a button labelled Deep Research, but what happens after the first round of retrieval. A genuine system notices that its plan was incomplete, chases a newly discovered lead, weighs conflicting sources, and only then writes the report.

Below I compare twelve open-source and self-hosted projects that implement this loop in different ways: recursive research trees, planner-plus-subagent designs, evidence-gap loops, perspective-driven question generation, and model-driven agentic search. For each one I cover the architecture, local-LLM support, RAG or private-document access, deployment complexity, and the license you actually inherit if you self-host. Where a system is also a full product (Open WebUI, Vane), I keep the focus on how it researches and link out to the dedicated guide for installation and configuration. Deep Research is one of the more demanding applied workloads in the AI Systems - it stresses retrieval, planning, and multi-step orchestration all at once, rather than any single layer in isolation.

What Is Deep Research?

A conventional AI web-search workflow is mostly linear. Even when several searches are performed, the model usually just creates related queries, retrieves documents, and summarizes what it finds:

Question
  |
Search
  |
Retrieve pages
  |
Summarize
  |
Answer

Deep Research adds a layer: the research process itself becomes adaptive. After the first pass, the system can branch, re-check, and keep going until the evidence is sufficient.

The distinction matters. A system that searches five times is not necessarily performing Deep Research; a stronger system starts with one question, discovers an unexpected implementation detail, opens a new research branch around it, compares primary and secondary sources, and revises its original assumptions. For the broader Search vs Deep Search vs Deep Research distinction and how cloud offerings frame the same idea, see Search vs Deep Search vs Deep Research in 2026.

There is no single Deep Research architecture. Current self-hosted implementations generally fall into five groups:

1. Recursive research trees.
2. Planner and subagent architectures.
3. Evidence-gap-driven research loops.
4. Perspective and question-driven research.
5. Agentic iterative search.

The first four provide more explicit research structure. The fifth can still perform surprisingly deep investigation when paired with a strong reasoning and tool-calling model, but much of the strategy is delegated to the model itself. The evidence-gap loop in particular is a system-level cousin of the self-reflective retrieval used in Self-RAG-style pipelines — deciding whether to retrieve again, judging relevance, and critiquing the draft before answering. See Advanced RAG: LongRAG, Self-RAG and GraphRAG for that pattern at the retrieval-pipeline level.

Self-Hosted Deep Research Systems Compared

The table below summarizes the major systems. “Recursive depth” does not mean that multiple web searches are possible; it means the system has some mechanism for deriving additional investigation from intermediate findings.

One point stands out: there is no direct relationship between UI sophistication and research depth. Open WebUI and Vane provide polished interfaces, while GPT Researcher and STORM are centered more on the research algorithm. Conversely, Onyx and Unsloth Studio try to provide both a strong user experience and a substantial research workflow. Most of these systems run against the same local inference backends covered in the LLM Hosting guide.

Deep Research Architectures

Before comparing individual products, it is useful to understand the architectural differences.

The categories overlap. Local Deep Research offers several research strategies, and DeerFlow 2.0 is a general-purpose agent platform that can perform research rather than a research-only application. The distinction is nevertheless useful when choosing a system: a recursively branching researcher behaves differently from a chat interface whose model simply has a search_web tool. Systems that retrieve private documents alongside the web lean on the same retrieval patterns described in the RAG cluster.

License Comparison

Licensing is particularly important if the system will become part of an internal platform, commercial service, or redistributed product.

For private self-hosting, none of these licenses prevents normal use. The differences matter when modifying the software, offering it to other users, embedding it into another commercial application, or redistributing derivatives. MIT and Apache-2.0 are generally the simplest options for integration. AGPL-3.0 deserves closer review for network-accessible modified deployments, and Open WebUI’s current license adds its own branding conditions.

GPT Researcher

GPT Researcher is developed by Assaf Elovic and contributors as an autonomous research agent focused specifically on comprehensive online investigation. It is one of the clearest reference implementations of what “Deep Research” means when the term describes an algorithm rather than a user-interface feature.

Its strongest feature is explicit breadth and depth. Deep Research mode exposes parameters such as deep_research_breadth, deep_research_depth, and concurrency, allowing one investigation to generate several branches and those branches to generate additional research. This creates a real research tree rather than a fixed collection of search queries.

That approach also has costs. Recursive expansion can produce many retrieval and LLM operations, and the quality of the final result depends heavily on the model’s ability to formulate useful research questions, extract evidence, and avoid propagating weak assumptions into deeper levels. GPT Researcher is also more research-engine oriented than applications such as Open WebUI or Unsloth Studio.

Installation is moderate rather than trivial: the project uses Python and ships a web application, while useful deployments also require suitable model and search providers. Current project metadata declares the MIT license. Choose GPT Researcher when explicit research depth, configurable recursion, and a research-first architecture matter more than an all-purpose local AI workstation.

Unsloth Studio

Unsloth Studio is developed by the Unsloth team as part of the broader Unsloth ecosystem. Originally best known for efficient model fine-tuning, Unsloth has expanded Studio into a local AI environment for inference, chat, tools, RAG, model management, and now Deep Research.

The interesting aspect of Studio is how tightly research is integrated with local model operation. Its Deep Research workflow includes a planning stage, plan review, evidence gathering, report generation, document handling, and failure handling when research steps fail to gather evidence. For users already running GGUF or other local models, this makes Studio considerably more convenient than assembling a separate research framework, inference server, and frontend.

Studio does not expose the same simple breadth/depth research-tree abstraction as GPT Researcher. Much of the workflow is organized around a research plan and evidence collection rather than arbitrary recursive expansion, and the feature is newer than some dedicated research projects. The quality of local research also remains sensitive to context length, output limits, tool use, and the reasoning quality of the selected model.

Installation is relatively friendly because Unsloth now provides Studio and desktop-oriented workflows across major platforms, although GPU and model configuration can still become substantial for advanced local deployments. The Studio component is AGPL-3.0, while the core Unsloth package remains Apache-2.0. Choose Unsloth Studio when Deep Research should be part of a broader local-model workstation rather than a standalone research service.

Local Deep Research

Local Deep Research is maintained by LearningCircuit and contributors as a privacy-oriented open-source research assistant. Its explicit goal is systematic research using web sources, academic databases, private documents, and local language models.

Its major advantage is architectural flexibility. Rather than enforcing one research algorithm, Local Deep Research supports pipeline-oriented strategies as well as a LangGraph agent strategy in which the model can decide what to search, which specialist sources to use, and when enough evidence has been collected. Academic sources such as arXiv, PubMed, Semantic Scholar, and other search mechanisms make it particularly attractive for technical and scientific research.

The downside of flexibility is complexity. Different strategies can behave substantially differently, which makes results harder to characterize with one simple “depth” parameter. It also has more moving pieces than a conventional chat UI, and users looking only for fast AI-assisted web answers may find it unnecessarily elaborate.

The project supports local operation and has developed a substantial application around the underlying research engine. Its license is MIT. Choose Local Deep Research when privacy, local inference, multiple research strategies, academic information sources, and control over the research process are more important than a minimal setup.

STORM and Co-STORM

STORM, developed by Stanford OVAL, stands for Synthesis of Topic Outlines through Retrieval and Multi-perspective Question Asking. It was designed around knowledge curation and long-form report generation rather than general AI chat.

STORM’s distinctive technique is perspective-driven research. It tries to discover different perspectives on a subject and uses question asking to broaden the information collected before writing an outline and article. Co-STORM extends the concept toward collaborative human-AI knowledge curation. This can uncover dimensions of a topic that a conventional list of keyword searches may overlook.

STORM is less suitable as a general local AI frontend. Its workflow is strongly oriented toward researching and writing structured, Wikipedia-like articles, and the project’s own documentation notes that generated output should not automatically be considered publication-ready. It is therefore better understood as a specialized research and knowledge-curation engine than a replacement for Open WebUI.

Installation is Python oriented, and the pipeline can be customized with different models and retrievers. STORM uses the MIT license. Choose it when the objective is broad topic exploration, perspective discovery, structured outlines, and long-form knowledge synthesis.

DeerFlow

DeerFlow is developed by ByteDance and the DeerFlow community. Its name originally stood for Deep Exploration and Efficient Research Flow, but an important distinction now exists between the original 1.x Deep Research framework and DeerFlow 2.0.

DeerFlow 1.x was specifically designed around Deep Research. DeerFlow 2.0 is a ground-up rewrite into a more general SuperAgent harness capable of orchestrating subagents, memory, sandboxes, tools, and skills. For research, this architecture is powerful because a coordinator can delegate different parts of a problem to separate agents and later synthesize their findings - the same planner-plus-subagent decomposition covered in Multi-Agent Orchestration Patterns.

The trade-off is that DeerFlow 2.0 is no longer a narrowly optimized research engine. It is closer to a general long-horizon agent platform in which research is one workload among coding, artifact generation, and other tasks. If the requirement is a small dedicated research service, this additional machinery can be unnecessary.

Deployment is consequently more involved than a simple search UI, although the architecture provides much more room for customization and extension. DeerFlow is MIT licensed. Choose DeerFlow when Deep Research is expected to become one capability inside a broader multi-agent automation environment.

Onyx

Onyx, originally known as Danswer, is developed by DanswerAI and positioned as a self-hostable AI application layer for organizations. It combines chat, agents, web search, RAG, MCP integration, many enterprise data connectors, and a dedicated Deep Research capability.

Onyx stands out because research can span both the public web and a substantial private knowledge environment. Its Deep Research implementation is a real multi-step research flow rather than merely a search-result summarizer, and the project has published results and execution logs for DeepResearch Bench. For organizations that need research across internal documentation, indexed applications, and external sources, this is a particularly strong combination.

The cost of those capabilities is infrastructure complexity. Onyx is a larger platform than GPT Researcher or a lightweight local research project, and many of its strengths only matter when connectors, indexing, authentication, document stores, and organizational data are actually being used.

Onyx can be deployed self-hosted, including in restricted environments. Most of the main repository is MIT licensed, while code under ee directories uses the Onyx Enterprise License; a separate onyx-foss repository is maintained as a fully MIT-licensed variant. Choose Onyx when Deep Research must coexist with serious enterprise RAG and organizational knowledge retrieval.

Open Deep Research

Open Deep Research was developed by LangChain as an open implementation of a configurable Deep Research agent. It combines planning, research, report generation, multiple model providers, search tools, and MCP integrations using LangGraph.

Its architecture is particularly interesting for developers. Research work can be decomposed and parallelized, making it a useful reference for planner-researcher-synthesizer designs. Because the project was built around LangGraph rather than a monolithic UI, it is also easier to study as an implementation pattern for building custom research agents.

There is one major problem for new deployments: LangChain archived the repository on August 21, 2026, and it is now read-only. The code remains useful, but starting a production system around an archived reference project creates an obvious maintenance risk.

The project is Python based and uses an MIT license. Choose it today mainly for architectural study, experimentation, or as a source of implementation ideas rather than as the default foundation for a new long-lived installation.

Open WebUI

Open WebUI is one of the most popular general-purpose self-hosted interfaces for local and remote LLMs. Its recent agentic tool architecture gives models access to web search, URL fetching, knowledge bases, files, memory, code execution, and other tools. For installation, RAG setup, and the full feature set, see the Open WebUI guide.

Open WebUI’s research model is interesting because the research loop is largely controlled by the language model. In native agentic mode the model can search, inspect snippets, fetch full pages, identify missing information, follow newly discovered URLs, cross-check sources, and repeat the process before generating an answer. With a capable reasoning and tool-calling model, this can produce genuine investigative behavior without a dedicated fixed research tree.

The limitation is precisely that this structure is model driven. Open WebUI does not provide the same explicit breadth/depth research topology as GPT Researcher, and there is less deterministic control over how many independent branches will be explored. A weak tool-calling model can stop too early, search poorly, or fail to follow important leads.

Installation is among the easiest in this comparison, particularly for users who already run Ollama, llama.cpp, vLLM, or another OpenAI-compatible inference server. Current releases use the Open WebUI License, which retains substantial permissive characteristics but adds branding restrictions; earlier portions of the project have MIT and BSD-3-Clause history. Choose Open WebUI when you want excellent local-LLM integration and a general AI interface in which research is one of many agentic capabilities.

Khoj

Khoj is developed as a self-hostable personal AI and “second brain.” It combines local or cloud language models with web retrieval, personal documents, semantic search, custom agents, automations, and an experimental /research mode.

Its strongest use case is research that crosses the boundary between public information and a user’s existing knowledge base. A question can be investigated in the context of PDFs, Markdown files, notes, office documents, or connected information rather than treating every task as web research from scratch. This makes Khoj useful for ongoing personal or team knowledge work.

Khoj is not primarily designed around a visible recursive research tree. Its research functionality is better understood as autonomous investigation within a larger personal knowledge system. Users seeking explicit breadth/depth controls or a dedicated research-engine API may prefer GPT Researcher or Local Deep Research.

Self-hosting is supported and the system can work with local models including the Llama, Qwen, Gemma, and Mistral families. Khoj is licensed under AGPL-3.0-or-later. Choose it when Deep Research should be closely integrated with a long-lived personal knowledge base rather than treated as an isolated web research job.

SurfSense

SurfSense is an open-source research workspace that evolved from a NotebookLM-style knowledge system toward an agent-oriented open-web research platform. It combines a searchable knowledge base with web and platform-specific data connectors, reports, automations, MCP access, and local model support.

SurfSense’s distinctive advantage is its data surface. It is designed to give agents structured access not only to ordinary web pages and search results but also to sources such as Reddit, YouTube, Google Maps, and other live information services. Research findings can then remain in the same environment as uploaded documents and previously collected knowledge.

It is less purely focused on the research algorithm than GPT Researcher or STORM. A significant part of SurfSense’s value comes from retrieval infrastructure, connectors, knowledge management, and downstream artifacts rather than an explicit recursively expanding research graph.

Self-hosting is supported through Docker-oriented installation, and local models can be connected through common local inference interfaces. The current repository is Apache-2.0 licensed. Choose SurfSense when the difficult part of research is obtaining, structuring, retaining, and reusing information from many different data sources.

Vane, Formerly Perplexica

Vane, formerly known as Perplexica, is an open-source AI answering engine designed as a self-hosted alternative to search-first products such as Perplexity. It combines an AI chat interface, search backend, citations, local model support, and semantic search over uploaded files. For the Docker quickstart, SEARXNG_API_URL wiring, and Ollama/llama.cpp setup, see Vane (Perplexica 2.0) Quickstart With Ollama and llama.cpp.

Vane is good at the search-and-answer experience. It classifies questions, conducts web research, retrieves useful information, and generates cited responses through a polished interface. Most deployments back it with SearXNG as the search layer. For users who mainly want a private AI search engine backed by SearXNG and local models, it provides a much more focused experience than a large general agent platform.

Its limitation in this comparison is research depth. Although the system can run research operations, its architecture is still primarily that of an answering engine rather than a recursively branching Deep Research framework. It should therefore not be treated as equivalent to GPT Researcher merely because both can perform multiple searches before responding.

Vane is relatively straightforward to deploy with Docker and supports common model providers and local inference systems. It is MIT licensed. Choose Vane when the primary requirement is high-quality self-hosted AI search with citations rather than long-running autonomous investigation.

Deep Research by lukeswade

The lukeswade/deep-research project is a smaller self-hosted research system, but it implements one of the more interesting workflows in this comparison. It supports both cloud models and local OpenAI-compatible endpoints including llama.cpp, LM Studio, Ollama, vLLM, and MLX - for the server side of that endpoint, see llama.cpp Quickstart with CLI and Server.

Its research loop is explicitly gap driven. A run decomposes the question into targeted searches, reads relevant pages, produces per-source notes containing evidence, and analyzes what remains unknown before deciding what should be searched next. Higher depth settings allow several rounds and progressively larger source budgets, while saturation detection can stop research early when new searches cease producing useful information.

It does not have the ecosystem, organizational connectors, or general AI workstation capabilities of Onyx, Open WebUI, or Unsloth Studio. It is much more narrowly focused on doing one thing: researching a question deeply and storing the resulting research in a searchable local library.

That focus also makes deployment relatively understandable. The system has a web UI and is particularly friendly to local OpenAI-compatible model servers; the documentation recommends capable models and supports using a smaller fast model for high-volume note processing. It is MIT licensed. Choose it when local inference, transparent evidence collection, and information-gap-driven research matter more than a large surrounding platform.

Which Deep Research System Should You Choose?

There is no single winner, because these systems solve somewhat different problems.

For an explicit research algorithm with understandable depth controls, GPT Researcher remains one of the clearest starting points. Its breadth/depth model makes it easy to reason about why research expands and how expensive a run may become.

For a strongly local workflow, Local Deep Research and Unsloth Studio are particularly attractive. Local Deep Research provides more research-strategy flexibility, while Unsloth Studio integrates research with model management, inference, RAG, and the broader local-model workflow.

For long-form knowledge curation, STORM remains unusually interesting because its multi-perspective question-generation technique attacks a problem that many research systems ignore: discovering the questions that the original user did not know to ask.

For multi-agent systems, DeerFlow represents a different direction. Instead of building a specialized research loop, it treats research as a long-running agent task that can be delegated among subagents and combined with tools, memory, code execution, and other capabilities.

For organizations, Onyx has one of the strongest combinations of Deep Research, RAG, web investigation, and enterprise knowledge connectors. Its heavier infrastructure is justified when internal information sources matter as much as the public web.

For an existing local AI installation, Open WebUI may be all that is necessary. A sufficiently capable local model with native tool calling can repeatedly search, read pages, follow links, verify information, and fill gaps without installing a separate research engine.

Finally, lukeswade/deep-research is worth watching precisely because it is smaller. Its gap-driven workflow is conceptually clean, supports llama.cpp directly through an OpenAI-compatible endpoint, and separates expensive planning and synthesis from high-volume per-source processing.

How to Tell Real Deep Research from Repeated Search

The most useful way to evaluate these systems is not to ask whether they have a button labelled “Deep Research.” Instead, inspect what happens after the first round of information is collected.

A genuine research system should be able to discover that its original plan was incomplete. It should recognize a contradiction, missing source, unexpected implementation detail, or newly relevant subtopic and change its subsequent investigation accordingly. That is the line separating sophisticated retrieval from research.

For self-hosting, the ecosystem is now broad enough that the choice is no longer simply between a cloud Deep Research service and a home-grown script. There are dedicated recursive researchers, academic knowledge-curation systems, enterprise research platforms, local-model workstations, general agent frameworks, and lightweight gap-driven tools.

The right choice therefore depends less on which project advertises the most features and more on the research architecture you want to operate: explicit recursion, multi-agent delegation, evidence-gap analysis, perspective discovery, or model-driven autonomous search.

References

• GPT Researcher
• Unsloth Studio
• Local Deep Research
• STORM / Co-STORM
• DeerFlow
• Onyx
• Open Deep Research
• Open WebUI
• Khoj
• SurfSense
• Vane (formerly Perplexica)
• lukeswade/deep-research
• Search vs Deep Search vs Deep Research in 2026
• Multi-Agent Orchestration Patterns