# Autoresearch **TL;DR:** Agents that run the research loop themselves, planning, searching, reading, synthesizing, and verifying until a question is actually answered Standard retrieval is one shot. A question comes in, the system runs a search, stuffs the top passages into a prompt, and produces an answer. That works when the answer sits in a document somebody already wrote. It fails on questions where the answer has to be assembled: what changed in this space over the last six months, which of our customers show this failure pattern, what would it take to migrate off this vendor. Autoresearch is what you build for those, an agent that plans a line of inquiry, runs many searches, reads sources, notices what's missing, and goes back for more until it has enough. The anatomy is fairly consistent across implementations. Decomposition turns a broad question into sub-questions that can actually be searched. A sweep runs those across multiple modalities, since web search, internal documents, code, and structured databases each surface things the others miss. A read-and-extract step pulls claims out of sources with citations attached rather than summarizing impressionistically. Gap analysis is the step that separates real autoresearch from a loop that runs a fixed number of times: the agent asks what it hasn't checked, what contradicts what, and which claim is currently resting on a single weak source. Then synthesis, and a stopping rule based on budget, convergence, or consecutive rounds that surface nothing new. Two flavors matter in practice, and they have different hard parts. External autoresearch works over public sources, where the challenge is source quality and the sheer volume of confidently wrong material on the open web. Internal autoresearch works over a company's own knowledge, where the corpus is smaller and more trustworthy but the agent needs to understand organizational context, who owns what, which document supersedes which, what the acronyms mean. The failure modes are specific enough to design against. Knowing when to stop is genuinely hard, and agents err toward premature confidence far more often than toward over-searching. Citation fidelity is a real problem, since agents cite plausibly rather than accurately, attaching a real URL to a claim that source doesn't quite make. Hallucination compounds across rounds when the agent reads its own earlier notes as though they were primary sources. And cost is not a rounding error: a deep run can consume a hundred times the tokens of a chat turn, so unbounded loops are a budget incident waiting to happen. Evaluating autoresearch requires different instincts than evaluating chat. The question is not whether the output reads well, because these systems produce fluent, well-organized prose almost by default. The questions are coverage, meaning did it find the sources a domain expert would consider mandatory; faithfulness, meaning does each claim survive checking against its cited source; and reproducibility, meaning does a second run reach compatible conclusions. Persistent memory is what turns autoresearch from an expensive one-off into something that compounds. Without it, every run starts from zero and re-derives what last week's run already established, paying the full cost each time. With a durable store, findings, sources, and dead ends accumulate, so the next run starts from what's known and spends its budget on what isn't. ## Why it matters Research is the bottleneck in a lot of knowledge work, and it's a bottleneck made of tasks that are laborious rather than difficult: reading widely, tracking sources, noticing gaps, keeping notes consistent. Autoresearch makes depth affordable enough to apply routinely instead of reserving it for decisions big enough to justify a week of someone's time. The catch is that unverified output produced at scale is a liability, not an asset, so the verification and memory layers are the parts that determine whether it's worth running at all. ## Example A product team needs a competitive analysis before a roadmap decision. A single-shot RAG query returns a summary of whatever three pages ranked highest, which is roughly a skim. An autoresearch run decomposes the question into pricing, positioning, integrations, and recent releases; sweeps public sources alongside internal sales-call notes; extracts claims with citations; flags that the pricing data for one competitor traces to a single 2024 blog post and needs confirming; and returns a sourced brief plus an explicit list of what it could not verify. The team spends its time on the flagged gaps rather than on the reading. ## Related terms - [AI Agent](https://www.maximem.ai/glossary/ai-agent) - [Multi-Agent Systems](https://www.maximem.ai/glossary/multi-agent-systems) - [Tool Use (Function Calling)](https://www.maximem.ai/glossary/tool-use) - [Orchestration](https://www.maximem.ai/glossary/orchestration) - [RAG (Retrieval-Augmented Generation)](https://www.maximem.ai/glossary/rag) - [Hallucination Mitigation via Retrieval](https://www.maximem.ai/glossary/hallucination-mitigation) - [Delegation](https://www.maximem.ai/glossary/delegation) - [Evals (Evaluation Systems)](https://www.maximem.ai/glossary/evals) --- Source: [https://www.maximem.ai/glossary/autoresearch](https://www.maximem.ai/glossary/autoresearch)