STORM by Stanford: The Free, Open Source AI Research Agent That Writes Wikipedia-Grade Articles With Citations (2026 Guide)

Ask any LLM to "write a report" and you get a shallow summary riddled with hallucinations and zero citations. ChatGPT, Claude, and Gemini all suffer from the same problem: they generate text first and worry about sources never. For academic research, technical briefings, or any document that needs to be grounded in verifiable facts, that approach is fundamentally broken.

STORM (Synthesis of Topic Outlines through Retrieval and Multi-perspective Question Asking) is a free, open source autonomous research system built by the Stanford Open Virtual Assistant Lab (OVAL). It produces full-length, Wikipedia-grade articles from scratch with comprehensive citations by completely re-engineering the pre-writing phase. Instead of blindly searching the web and generating text, it simulates expert interviews from multiple perspectives, gathers sources, builds an outline, and only then writes the article.

In this guide, you'll learn what STORM is, who it's for, and how to install it and generate your first citation-grounded research article from the command line.

What is STORM?

STORM is an open source autonomous research system that generates full-length, Wikipedia-style articles with comprehensive citations from a single topic prompt. While standard LLMs hallucinate and produce shallow summaries when asked to write a report, STORM engineers the entire pre-writing phase of research to ensure factual grounding and breadth of coverage.

When you give STORM a topic, it does not just search the internet and start writing. It automatically identifies 6 to 8 different perspectives relevant to the topic, such as a historian, an economist, or a technologist. It then spawns multiple AI agents that simulate an expert interview: one agent acts as the writer asking deep probing questions, and another acts as the expert answering by searching the live internet in real time. This multi-perspective approach ensures the final article covers the topic from angles a single-perspective prompt would miss entirely.

The newest version includes Co-STORM, which allows a human user to jump into the middle of the agent debate and guide the research direction before the AI curates the final outline and drafts the document. Every single claim in the final report is tied back to a specific URL discovered during the research phase. STORM actively minimizes hallucination by refusing to write facts it cannot find a source for, which is a fundamentally different architecture from standard LLM generation.

STORM is built on the DSPy framework, which means you can swap out its internal engine components. You can use GPT-4o for the writing agent, Claude 3.5 Sonnet for the outlining agent, and Bing, Tavily, or You.com for the search retriever. This modular architecture lets you optimize for cost, speed, or quality depending on your needs.

Who is it for?

Academics and PhD students: Researchers looking to rapidly generate thorough literature reviews and heavily cited background reports before starting their own original writing.
Technical writers and journalists: Writers who need deep-dive briefings on complex new technologies like quantum computing or new AI models that gather multiple viewpoints automatically.
AI developers: Engineers interested in learning how to build multi-agent orchestration frameworks and retrieval-augmented generation pipelines that enforce strict factual grounding.
Knowledge management teams: Organizations that need to produce internally cited research documents, competitive analyses, or technology briefings without relying on a single black-box commercial tool.

What makes STORM different from other AI research tools?

Perspective-guided discovery: It does not just ask "What is X?" It simulates the brain of different experts. If researching a new drug, the AI will ask questions from the perspective of a patient, a pharmaceutical executive, and a regulatory lawyer, ensuring the final article has incredible breadth.
Strict citation grounding: Every single claim generated in the final report is tied back to a specific URL discovered during the research phase. It actively minimizes hallucination by refusing to write facts it cannot find a source for.
Multi-perspective interview simulation: Instead of a single search-and-summarize pass, STORM runs a multi-turn conversation between a writer agent and an expert agent, producing deeper questions and more thorough source gathering than a flat retrieval pipeline.
Co-STORM human-in-the-loop: The newest version lets a human user jump into the agent debate, guiding the research direction before the AI curates the final outline and drafts the document.
Modular architecture with DSPy: Built on the DSPy framework, STORM lets you swap out its internal engine. Use GPT-4o for writing, Claude for outlining, and Tavily or Bing for search, all configurable per pipeline stage.
Free and open source: The entire framework is free and open source under the MIT license. No subscription, no vendor lock-in, full access to the source code for research and modification.

What you need before you start

Because STORM is a multi-agent backend pipeline, you will need to run it via the terminal or Python scripts. Make sure you have the following:

Python 3.11: The required version for the current codebase. A Conda environment is highly recommended to avoid dependency conflicts.
Search API key: You need a search engine for the agents to query. Bing Search API, Tavily, or You.com are natively supported. Tavily has a free tier that works for testing.
LLM API keys: An active API key for OpenAI (GPT-4o), Anthropic, or an Azure OpenAI endpoint. Local Ollama models are technically possible but difficult due to the complex multi-step reasoning required by the agents.
Git: To clone the repository from GitHub.
Disk space: At least 2 GB free for the repository, dependencies, and generated output files.

Step-by-step installation

Step 1: Clone the repository and set up the environment

Open your terminal, clone the codebase, and create a fresh Conda environment using Python 3.11:

git clone https://github.com/stanford-oval/storm.git
cd storm
conda create -n storm python=3.11
conda activate storm
pip install -r requirements.txt

If you run into dependency conflicts with the raw GitHub source, you can alternatively install the PyPI package which is more rigorously version-locked: pip install knowledge-storm.

Step 2: Configure API keys

STORM manages credentials using a secrets file. Create a new file named secrets.toml in the root directory and add your keys. For example, if you are using OpenAI and Tavily for search:

OPENAI_API_KEY="sk-proj-your-openai-key"
OPENAI_API_TYPE="openai"
TAVILY_API_KEY="tvly-your-tavily-key"

If you prefer to use Anthropic instead of OpenAI, replace the OpenAI entries with your Anthropic API key and set the appropriate model type in the run command.

Step 3: Run the STORM pipeline

Execute the pipeline directly from the command line using the provided demonstration script. Tell it to use Tavily for search and GPT-4o for writing:

python scripts/run_storm.py \
  --topic "The history and impact of open-source AI" \
  --retriever tavily \
  --lm-type openai \
  --engine-model gpt-4o

Sit back and watch the terminal. The agents will begin talking to each other, searching the web, evaluating sources, generating an outline, and finally writing the article. The final Markdown file along with the references and conversation logs will be saved in the generated output folder.

Step 4: Review the output

Open the generated Markdown file in your preferred editor. You will see a full-length article with inline citations linking back to the original sources. The conversation logs and reference list are saved alongside the article, so you can trace every claim back to the specific URL where the agent found it.

Common errors and how to fix them

Error	What it means	How to fix it
Massive API token costs	STORM simulates an ongoing multi-turn interview between agents while feeding them large amounts of scraped website text, consuming a tremendous amount of input tokens.	Swap the heavy engine models like GPT-4o out for faster, cheaper models like `gpt-4o-mini` or `claude-3-5-haiku` for the question-asking and outlining phases. Reserve the expensive model for the final writing stage only.
Search API rate limits hit	The expert agent tried to perform too many searches per minute, triggering a block from your search provider.	Upgrade your Tavily or Bing Search API tier from the free tier to a paid tier. A single STORM article generation can execute dozens of complex search queries in seconds.
DSPy configuration error or missing imports	You are likely running a Python version older than 3.11, or the DSPy library updated and broke backwards compatibility with Stanford's code.	Ensure you strictly followed the Conda `python=3.11` requirement. If issues persist, run `pip install knowledge-storm` instead of running the raw source code from GitHub, as the PyPI package is more rigorously version-locked.
Output article is empty or incomplete	The pipeline failed silently during the outline generation or writing phase, often due to an LLM API timeout on a complex topic.	Check the conversation logs in the output folder for the exact failure point. Try simplifying your topic, or increase the `max_tokens` limit in your configuration to allow the writing agent enough room to complete the article.

STORM vs commercial research tools

Feature	STORM (Stanford, open source)	Commercial tools (Perplexity Pro, Google Deep Research)
Cost	Free software, pay only for raw API tokens	Approximately $20 per month subscription
Research depth	Phenomenal, simulates multi-perspective interviews	High, but often lacks the specific Wikipedia structure
Human-in-the-loop	Yes, via Co-STORM interface	No, fully automated black-box
Customization	Total control over which LLMs and search APIs are used	Locked into the provider's ecosystem
Citation transparency	Every claim linked to a specific URL with full conversation logs	Citations provided but retrieval process is opaque
Best for	Researchers who need academic-grade, citation-grounded articles	Users who want quick answers with zero setup

Bottom line: Stanford's STORM is arguably the most impressive open source research agent available today. It proves that simply prompting an LLM with "write a good article" is the wrong approach. By forcing the AI into a strict workflow of perspective-gathering, interviewing, and outlining before a single word of the final article is written, STORM generates content that rivals human analysts. While Perplexity Pro charges $20 per month and locks you into their ecosystem, STORM is free, MIT licensed, and gives you total control over every LLM and search API in the pipeline. If you need heavily cited, academic-grade research, this is the tool to install.

3 alternatives worth checking out

GPT Researcher (github.com/assafelovic/gpt-researcher): The most popular direct competitor to STORM. GPT Researcher also spawns multiple autonomous agents to scrape the web and write detailed reports. It is generally easier to install, has a better out-of-the-box web UI, and supports a wider variety of export formats like PDF and Word natively, though STORM's academic perspective-gathering is slightly more rigorous.
Perplexity Pro (perplexity.ai): If you do not want to mess around with Python environments or API keys, Perplexity Pro is the commercial standard. Its Pro Search and Deep Research features perform similar multi-step web scraping and citation generation inside a flawless, consumer-friendly web application. You trade control and cost for convenience.
OpenPerplex (github.com/YassineFadali/OpenPerplex): A fast, open source alternative to Perplexity. While it does not generate massive multi-page Wikipedia articles like STORM, it is an excellent tool for quick, fully cited answers to complex questions, combining Groq's lightning-fast inference with local search retrieval.

Found this guide useful? Check out more AI tools and open source projects on Sudo Scout.