STORM

STORM orchestrates sequential LLM-driven research cycles where an agent formulates search queries, retrieves relevant documents, and iteratively refines its understanding of a topic. The system maintains a research context that evolves across turns, allowing the LLM to identify knowledge gaps and generate follow-up queries that progressively deepen coverage. This differs from single-pass retrieval by implementing a planning-reasoning loop that decomposes complex topics into sub-questions and validates coverage before report generation.

STORM generates structured outlines by explicitly modeling multiple perspectives on a topic, querying sources for each viewpoint, and synthesizing them into a hierarchical outline. The system uses LLM-driven perspective identification to determine relevant viewpoints (e.g., technical, business, ethical angles), retrieves information for each perspective independently, and then merges them into a unified outline structure. This approach ensures balanced coverage and explicit representation of different stakeholder views rather than a single homogenized narrative.

STORM abstracts over multiple LLM providers (OpenAI, Anthropic, Ollama, etc.) and enables switching between models without changing research logic. The system supports configurable model selection for different research phases (e.g., using a cheaper model for query generation and a more capable model for synthesis). Model-specific parameters (temperature, max tokens, etc.) are configurable per phase, enabling fine-tuning of research behavior.

STORM supports saving and loading research sessions, enabling resumable research workflows where a session can be paused, saved to disk, and resumed later with full context preservation. Saved sessions include research context, retrieved documents, generated outlines, and synthesis results. This enables long-running research jobs to be interrupted and resumed without losing progress, and enables sharing research state between team members.

STORM generates full-length reports where each claim is grounded in retrieved sources and includes inline citations. The system maintains a mapping between generated text and source documents, enabling automatic citation insertion and generation of reference lists. The report generation uses LLM-driven synthesis to convert outline sections into prose while preserving source attribution, with fallback mechanisms to handle cases where claims cannot be directly attributed to sources.

STORM integrates with web search APIs (and optionally local document corpora) to retrieve relevant sources for research queries. The system uses hybrid search combining keyword matching and semantic similarity to maximize recall across diverse source types. Retrieved documents are ranked by relevance and filtered for quality signals (domain authority, recency, etc.), with deduplication to avoid redundant sources. The retrieval layer abstracts over multiple search backends, enabling seamless switching between web search, academic databases, and custom corpora.

STORM maintains a structured research context that accumulates knowledge across multiple research turns, preventing redundant queries and enabling progressive deepening of understanding. The context stores retrieved documents, generated queries, outline sections, and synthesis results, with mechanisms to detect when new queries would be redundant. The system uses this context to inform follow-up query generation and to ensure outline sections are grounded in accumulated knowledge rather than isolated retrieval results.

STORM uses LLM reasoning to decompose a broad research topic into specific, researchable sub-questions that can be answered independently and then synthesized. The system prompts the LLM to identify key aspects of a topic, generate clarifying questions, and propose a research strategy before executing queries. This decomposition enables more targeted searches and ensures comprehensive coverage by making implicit knowledge gaps explicit as sub-questions.

STORM executes multiple research queries in parallel or batched fashion, retrieving sources for multiple sub-questions concurrently rather than sequentially. The system manages API rate limits and batches queries to maximize throughput while respecting search API quotas. Retrieved documents are deduplicated across queries to avoid redundant processing, and results are aggregated into a unified research context.

STORM converts a structured outline (with perspective labels and source mappings) into flowing prose by synthesizing information from multiple sources into coherent sections. The system uses LLM-driven synthesis to merge information from different perspectives, resolve conflicts, and generate natural language that reads as a unified narrative rather than a collection of source excerpts. Each section is generated with awareness of its position in the outline hierarchy and its relationship to adjacent sections.

STORM generates reports in multiple formats (Markdown, HTML, PDF) and supports multiple citation styles (APA, MLA, Chicago, IEEE, etc.). The system abstracts formatting logic from content generation, enabling the same research and synthesis pipeline to produce outputs in different formats. Citation formatting is handled by pluggable formatters that convert internal citation representations into style-specific formats.

STORM applies heuristic filters to retrieved sources to prioritize high-quality, credible sources and deprioritize low-quality or unreliable sources. Filters include domain authority checks (e.g., preferring .edu or .gov domains), recency filtering (prioritizing recent sources), and exclusion of known low-quality sources. The system ranks sources by credibility signals and can optionally exclude sources below a quality threshold, though final inclusion decisions are made by the LLM during synthesis.