Who hyperresearch is for#
Analysts doing sustained research on a recurring topic
The persistent vault means each session builds on prior fetches. A competitive intelligence analyst returning to the same domain weekly accumulates a deduplicated corpus across sessions, with source quality scores and retraction checks that carry forward. The source independence audit prevents syndicated content from inflating apparent consensus.
Skip if:
You need a one-off answer in seconds and have no interest in accumulating a knowledge base. Perplexity Pro or ChatGPT Pro return faster results for single-session queries with no local setup.
Researchers who need auditable citations before publishing
The cite-checker verifies citation-sentence bindings and the ship gate blocks a report if a cited source has been retracted. For anyone writing a document that will be reviewed or published, the adversarial review pipeline and per-citation verification reduce hallucinated or outdated citations more than a standard LLM response can.
Skip if:
You need a quick summary with no citable output. The full pipeline takes 1.5-2.5 hours; for casual queries, that cost is not justified.
Developers building systems that need a research knowledge base
Installing with `pip install hyperresearch[mcp]` adds an MCP server with 13 tools including `search_notes`, `fetch_url`, and `create_note`, so any MCP-compatible host (Claude Desktop, Cursor) can work the same vault. `hyperresearch serve --open` starts a local web UI on port 8080 with note browsing, tag pages, and an interactive link graph, with no JavaScript build step.
Skip if:
You need a managed cloud research API with no local setup or server to maintain. Hyperresearch runs locally and requires your own Claude API credits and Python environment.
Writers producing long-form reports or chaptered documents
The dissertation tier writes 25K-80K word chaptered documents across 4-10 chapters and 300-450 sources, with the pipeline looping per chapter. The readability audit and polish auditor pass run at the end. Run resume means a multi-hour run survives a crash and continues from the exact step where it stopped, preserving all fetched vault sources.
Skip if:
Your output target is under 5,000 words or your timeline is under an hour. The light tier covers bounded queries in 30-40 minutes; the dissertation tier is sized for projects that genuinely need that scope.
The problem it solves#
Most deep research tools are one-shot: query in, report out, everything discarded. If you run research sessions repeatedly on the same topic, each one re-fetches sources the previous runs already read, re-spends API budget on the same domains, and produces a report with no connection to prior work. There is no corpus that builds over time.
The second problem is verification. Paid tools surface citations, but they do not verify that each cited sentence is actually supported by its source, track whether a cited paper has been retracted, or audit whether five articles reporting the same claim are independent sources or reprints of one press release. You get answers quickly, but you cannot audit the reasoning behind them.
How it solves it#
16-step pipeline with automatic tier routing
The pipeline decomposes your query, runs parallel source sweeps, builds a contradiction graph, investigates prioritized loci, and reconciles findings before producing three parallel drafts and a synthesized final report. Step 1 auto-classifies the query as `light` (5-step fast path, ~30-40 min) or `full` (all 16 steps with adversarial review, ~1.5-2.5 hours). Dissertation tier is opt-in: 25K-80K words across 300-450 sources.
Persistent SQLite vault that compounds across sessions
Every fetched source lands as a markdown note with YAML frontmatter in `research/notes/`, indexed in SQLite. Future sessions search the vault before fetching, so the corpus accumulates rather than resets. The vault is plain text: open it in any editor, version it in git, and rebuild the SQLite index from scratch with `hyperresearch sync` if needed. Export every note as structured JSON with one command, or import an existing markdown collection.
Adversarial review with four parallel Opus critics
After synthesis, four Opus-model critics attack the draft in parallel: one flags counter-evidence the draft missed, one finds shallow spots interim notes could fill, one identifies topical corners the corpus supports but the draft ignores, and one checks structural mismatches against the original query's atomic items. A tool-locked patcher applies findings as surgical edit hunks and physically cannot rewrite the draft wholesale.
Citation verification and retraction tracking
The cite-checker verifies that each cited sentence is actually supported by its source, running a skeptical LLM spot-check on sampled citation-sentence bindings. The source scorer enriches DOI-bearing notes with citation counts, venue metadata, and retraction flags from OpenAlex and Semantic Scholar. A ship-time retraction sweep re-checks every cited DOI fresh before the report is delivered, catching retractions published after the initial fetch.
Scholarly source integration across eight databases
`hpr scholar search` queries OpenAlex, Crossref, CORE, DOAB, ClinicalTrials.gov, SEC EDGAR, and FRED through one client and returns results deduplicated by DOI and title, tagged by source type. For paywalled papers, the pipeline requests a legal open-access copy from Unpaywall, Europe PMC, and CORE instead of storing only the 1,500-character abstract, with every substitution disclosed in the note's frontmatter.
Budget caps and resumable runs
`run init --budget 50` caps estimated API-equivalent spend; crossing the cap blocks the run rather than letting it quietly balloon. Each run keeps a manifest in `research/runs/<vault_tag>/`; `run resume` picks up at the exact step where a crashed run stopped. Concurrent runs never collide because each owns an isolated workspace. `run status -j` shows step-by-step progress, current spend, and the escalation queue depth.
Strengths and trade-offs#
Strengths
- Vault that compounds across sessionsUnlike Perplexity Pro and ChatGPT Pro, which start fresh each session, Hyperresearch searches its SQLite vault before fetching anything new. Over repeated research sessions on the same topic, the corpus accumulates, source re-fetching drops, and each run starts with more prior context. This reduces both API spend and latency on recurring topics.
- Source independence audit prevents false consensusFive reprints of one press release count as one source, not five. The independence audit clusters derivative copies by content similarity, so a finding backed by widely syndicated content is flagged as one-source support rather than consensus. This is a structural check not documented in Perplexity Pro or ChatGPT Pro's research modes.
- MIT license with local executionMIT license means no per-query billing, no account beyond your Anthropic API credentials, and no data leaving your infrastructure. The vault lives in your project directory and can be versioned in git. You can export every note as structured JSON and import an existing markdown collection, so research data is not locked to the tool.
- Configurable model allocation per agent roleThe subagent roster assigns Sonnet to fetchers and analysts, Opus to drafters, critics, patcher, and polish auditor. Any model can be overridden in `.hyperresearch/config.toml` under `[profile.<name>]`, so you can swap the fetcher fleet to Haiku to reduce cost without changing the synthesis quality. Gear profiles persist per project and survive reinstalls.
Trade-offs
- -Requires Claude Code and ongoing API creditsThe core `/hyperresearch` command is a Claude Code skill, not a standalone app. You need a working Claude Code installation and sufficient Anthropic API credits for multi-step Opus and Sonnet subagents. A `full` tier run spawns 16+ subagents and takes 1.5-2.5 hours; a `premier` gear `full` run targeting 100-130 sources can run 3-5 hours. Budget caps help, but this is not a lightweight or zero-cost tool.
- -Python 3.11-3.13 onlyPython 3.14 is not yet supported. If your environment uses 3.14, you need pyenv or uv to install a supported Python version before installing the package. The README suggests `pyenv install 3.13` or `uv venv -p 3.13` as the workaround paths.
- -Benchmark claims are internally sourced and pending validationThe README states the tool leads the DeepResearch-Bench RACE leaderboard but qualifies this as a forward-looking projection from a stratified pilot, with third-party validation pending. The benchmark result should not be treated as independently verified until external validation is published.
hyperresearch vs alternatives#
Hyperresearch vs Perplexity Pro
Both tools run multi-source research from a single prompt, but they are built for different priorities. Perplexity Pro returns an answer in seconds to minutes; Hyperresearch runs a 16-step pipeline that takes 1.5-2.5 hours for a full run. The output difference reflects that gap.
| Feature | Hyperresearch | Perplexity Pro |
|---|---|---|
| License | MIT | Proprietary |
| Self-hosting | Yes (local, your API credits) | No |
| Citation verification | Per-citation binding audit | Source links displayed |
| Source independence audit | Yes, clusters derivative copies | Not documented |
| Retraction tracking | Ship-time DOI re-check | Not documented |
| Persistent vault | SQLite + markdown, reused across sessions | Session only |
| Scholarly databases | OpenAlex, Crossref, CORE, ClinicalTrials, SEC EDGAR, FRED | Not documented |
| Speed | 30 min (light) to 8 hours (dissertation) | Seconds to minutes |
Hyperresearch is the better choice when you need a citable, verified report and can allocate 1.5-2.5 hours to produce it. The vault compounds across sessions, so sustained research on a recurring topic reduces re-fetching and API spend over time. Perplexity Pro is the better fit for quick one-off queries where you need an answer now and do not need to verify citation bindings or retain sources.
Hyperresearch vs ChatGPT Pro
ChatGPT Pro includes a deep research mode that generates reports from web searches. It does not run adversarial critic passes, does not verify citation-sentence bindings per citation, and does not maintain a persistent source vault across sessions.
| Feature | Hyperresearch | ChatGPT Pro |
|---|---|---|
| License | MIT | Proprietary |
| Self-hosting | Yes | No |
| Adversarial review | 4 parallel Opus critics | Not documented |
| Citation binding audit | Yes (skeptical LLM spot-check) | Not documented |
| Persistent vault | Yes (SQLite + markdown) | No |
| Dissertation mode | 25K-80K words, 300-450 sources | Not documented |
| Cost model | Your API credits, no per-query fee | Subscription |
ChatGPT Pro's managed interface requires no local setup and works well for users who want a research answer without running local software. Hyperresearch is the better fit when you need the audit trail, the persistent vault, configurable model allocation, or the dissertation-scale output that ChatGPT Pro does not offer.
Quick start#
Install the pip package and run the setup command from your project directory.
```bash
pip install hyperresearch && hyperresearch install
```What it's built on#
- Languages
- Python
FAQ#
Does Hyperresearch require a separate account or subscription?
No separate account is required beyond your existing Anthropic API access. Hyperresearch runs as a Claude Code skill using your own Anthropic API credentials. You install it with pip, run it inside Claude Code, and pay for Claude API usage through your normal Anthropic billing. There is no per-query fee or separate subscription.
How does Hyperresearch differ from Perplexity Pro for deep research?
Perplexity Pro returns answers with citations in seconds to minutes but discards the sources afterward and does not verify that each cited sentence is actually supported by its source. Hyperresearch runs a 16-step pipeline that verifies citation bindings, audits source independence, checks for retractions, and stores every source in a persistent vault that future sessions can reuse. The tradeoff is time: a full run takes 1.5-2.5 hours versus seconds for Perplexity Pro.
Can I use the vault outside of Claude Code?
Yes. pip install hyperresearch[mcp] adds an MCP server with 13 tools that any MCP-compatible client (Claude Desktop, Cursor) can use to search and read vault notes. hyperresearch serve --open starts a local web UI on port 8080 with note browsing, tag pages, and an interactive link graph. The vault itself is plain markdown files, so any text editor or version control system can read it directly.
What happens if a research run crashes partway through?
Each run keeps a manifest in research/runs/<vault_tag>/. Running hyperresearch run resume picks up at the exact step where the run stopped. Concurrent runs never collide because each owns an isolated workspace. Sources already fetched and stored in the vault are not re-fetched on resume, so no work is lost.
What does the source independence audit actually check?
The independence audit clusters articles by content similarity to identify derivative copies. Five reprints of one press release count as one source, not five, so a finding backed by widely syndicated content is not inflated to look like broad consensus. The ship gate also re-checks every cited DOI against retraction databases at the time of delivery, catching papers retracted after the initial fetch.
Similar open-source tools#
open-science
Open-source AI workbench for reproducible scientific research
FckSignups
Open-source tools that work instantly, no signup required
CocoIndex
Incremental data framework for AI agents.
OpenResearch
Local-first workspace for parallel research agents and experiments.
magic-compact
Lossless context compression for Claude Code and OpenCode
teamai-cli
Git-backed AI config sync for engineering teams