💬 NLP

Search, Inspect, Fetch: Exploiting Boolean Retrieval for Deep-Research Agents

The paper introduces SIEVE, a deep-research agent interface that leverages fielded Boolean retrieval to filter, rank, and fetch only relevant document sections, thereby achieving higher accuracy with significantly fewer tokens compared to traditional search-visit workflows.

Original authors: Shuai Wang, Haodong Chen, Yu Yin, Shengyao Zhuang, Bevan Koopman, Guido Zuccon

Published 2026-08-05

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Shuai Wang, Haodong Chen, Yu Yin, Shengyao Zhuang, Bevan Koopman, Guido Zuccon

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a detective trying to solve a mystery, but instead of a dusty library, you have the entire internet at your fingertips. In the world of artificial intelligence, "deep-research agents" are like these detectives: they are computer programs designed to answer tricky questions by searching the web, reading what they find, and piecing together the answer. To do this, they usually follow a simple routine: they type in a search query, look at a list of short summaries (snippets) of web pages, pick the most promising one, and then read the entire page from start to finish. This is called a "Search–Visit" workflow. It's a bit like trying to find a specific sentence in a book by reading every single page of the library, even if you only need one paragraph from the middle of one book. The problem is that web pages are actually organized with titles, headings, and sections, but most of these AI detectives ignore that structure. They treat every page like a giant, unorganized blob of text, which wastes time and confuses the computer.

This paper introduces a smarter way to do detective work called SIEVE. The researchers built a system that treats web pages like well-organized filing cabinets instead of messy piles of paper. Instead of just reading whole pages, SIEVE uses a special "Boolean Query Language" (think of it as a super-precise search filter) to ask very specific questions, like "Show me only the sections with the heading 'History' that mention '1995'." It then inspects the list of results to see the headings and short snippets, picks the exact section it needs, and fetches only that tiny piece of information. This approach, called "search–inspect–fetch," lets the agent ignore irrelevant parts of a document entirely. The authors tested this on three different sets of difficult questions and found that SIEVE was not only more accurate at finding the right answers but also used 20.7–50.6% fewer "tokens" (the basic units of text the computer processes) than the best traditional methods. In short, by respecting the structure of the web, the AI detective can solve mysteries faster, cheaper, and with fewer mistakes.

The Detective's New Toolkit: SIEVE

Imagine you are looking for a specific recipe in a massive cookbook that has thousands of pages. The old way (the "Search–Visit" method) is to ask a librarian, "Do you have a recipe for chocolate cake?" The librarian hands you a list of ten books that might have it. You pick one, walk over, and read the entire book from the first page to the last, hoping you find the chocolate cake recipe somewhere in the middle. If you don't find it, you go back, pick another book, and read that whole thing too. It's exhausting, slow, and you end up with a brain full of information about bread and soup that you didn't need.

The authors of this paper argue that this is a terrible way to use the internet. Web pages aren't just blobs of text; they are structured with titles, headings, dates, and sections, just like a book has chapters. The problem is that current AI agents often ignore these "chapters." They read the whole page even when the answer is just in one small section.

To fix this, the team created SIEVE, a search–inspect–fetch strategy. Think of SIEVE as a detective who doesn't just read the whole book but knows exactly how to use the table of contents.

Step 1: The Super-Filter (Search)
Instead of just typing a vague question, SIEVE uses a special language called Boolean Query Language (BQL). This is like giving the librarian a very strict set of rules. Instead of saying "Find me cake," the agent says, "Find me documents where the Title says 'Chocolate' AND the Section is 'Recipes' AND the Date is after 2020." This filters out thousands of irrelevant pages immediately. It's like having a magic sieve that only lets the right kind of sand through, leaving the rocks behind.

Step 2: The Quick Glance (Inspect)
Once the filter has done its job, the agent doesn't read the full pages yet. Instead, it looks at "result cards." These are like index cards that show the title, the list of chapter headings, and a tiny 25-word snippet of the text. The agent can see, "Oh, this book has a chapter called 'Desserts' and another called 'Breakfast'." It can inspect these headings to see which one actually looks promising without reading a single sentence of the full text.

Step 3: The Surgical Grab (Fetch)
This is the game-changer. Once the agent sees that the "Desserts" chapter is the one it needs, it doesn't open the whole book. It asks the system to "fetch" only the "Desserts" section. It gets just that specific slice of information. It ignores the chapters on bread, soup, and history.

Why This Matters: Speed and Smarts

The researchers tested this new method against the old "read the whole page" method using three different collections of difficult questions (HotpotQA, MuSiQue, and BROWSECOMP-PLUS). These are like different levels of a trivia game, ranging from standard Wikipedia questions to very deep, complex research tasks.

The results were impressive. SIEVE didn't just save time; it actually got better answers.

Accuracy: On all three collections, SIEVE was more accurate than the best traditional method.
Efficiency: It used 20.7% to 50.6% fewer tokens to get those answers. To put that in perspective, if a traditional agent had to read 100 pages to find an answer, SIEVE might only need to read the equivalent of 50 pages (or even less) by skipping the irrelevant parts.
Robustness: The team tried this with different "brains" (AI models) and different search engines, and SIEVE kept winning. It worked whether the agent was using a simple search tool or a complex one.

What the Paper Says (and Doesn't Say)

The authors are very clear about what they found and what they didn't. They didn't just guess; they ran controlled experiments where they compared SIEVE directly against the old methods using the exact same questions.

What they proved: They showed that ignoring the structure of web pages is a mistake. By using the structure (headings, sections) to filter and fetch only what is needed, agents can be both smarter and more efficient. They also proved that the "search–inspect–fetch" loop is better than just "Search–Visit."
What they ruled out: They showed that simply reading the whole page (even if you search many times) is wasteful. They also showed that just having a better "brain" (a more powerful AI model) isn't enough if the way it searches and reads is inefficient.
Where it might still struggle: The paper notes that SIEVE still relies on the agent being able to write good "Boolean" queries. If the agent asks the wrong question, the filter might block the right answer. However, they found that the system has a "safety net": if the strict filter finds nothing, it automatically relaxes the rules and tries again, so it doesn't get stuck.

The Big Picture

This paper suggests that the future of AI research isn't just about making the AI "smarter" in a general sense, but about teaching it to be more organized. Just as a human researcher wouldn't read a whole encyclopedia to find one fact, an AI shouldn't have to either. By respecting the way information is structured on the web, SIEVE shows that we can build agents that are faster, cheaper to run, and more accurate. It's a reminder that sometimes, the best way to find the truth is to stop reading everything and start reading the right things.

Technical Summary: SIEVE – Search, Inspect, Fetch

Problem Statement

Existing deep-research agents typically operate on a Search–Visit workflow: they formulate a subquery, inspect short result snippets, and then visit selected pages in their entirety. This approach ignores the inherent addressable structure of web sources (titles, headings, sections, metadata). Consequently, agents cannot constrain retrieval to specific document fields, nor can they avoid loading irrelevant sections into their context. This "page-level reading" is inefficient and often introduces noise, as the agent receives the complete document even when only a single section is relevant to the query.

Methodology: The SIEVE Strategy

The authors introduce SIEVE (Search–Inspect–Fetch), a strategy designed to preserve document structure throughout the research process. SIEVE is built around a Boolean Query Language (BQL) and operates in three distinct phases:

Search (Boolean Selection + Ranking):
- Instead of relying solely on semantic ranking, the agent first formulates a BQL expression to define an eligible set of documents.
- BQL allows for field restrictions (e.g., term[title]), Boolean operators (AND, OR, NOT), wildcards, phrases, and date ranges.
- This selection step acts as a filter: it determines which documents are acceptable based on exact constraints.
- An interchangeable ranker (e.g., BM25, dense retriever, or fusion) then orders this pre-filtered candidate set.
- Fallback Mechanism: If the Boolean filter returns zero results, the system automatically falls back to ranking the full collection using the query's positive terms, ensuring robustness against over-constrained queries.
Inspect (Structure-Rich Result Cards):
- The agent does not receive full document bodies immediately. Instead, it receives compact result cards.
- These cards expose the document's structure: titles, section headings, matched fields, and infobox keys.
- Crucially, they include a 25-token query-focused snippet derived from the section with the highest lexical overlap with the query's positive terms. This allows the agent to judge relevance without reading the full text.
Fetch (Selective Reading):
- Based on the inspection of headings and snippets, the agent requests a specific named section (or field) rather than the whole document.
- The tool returns only the selected section ( $x_{d,j}$ ), significantly reducing the token count entering the agent's context compared to fetching the concatenated page ( $x_d$ ).

Key Contributions

The paper makes three primary contributions:

Strategy Formulation: It identifies the mismatch between structured web sources and flat page-level workflows, proposing search–inspect–fetch as a method to preserve structure from retrieval through reading.
System Implementation (SIEVE): It introduces a system combining fielded Boolean candidate selection, modular ranking, structure-rich result inspection, and selective section fetching.
Empirical Validation: It demonstrates that SIEVE improves accuracy while using significantly fewer tokens than conventional Search–Visit configurations.

Evaluation and Results

The authors evaluated SIEVE on three QA collections: HotpotQA, MuSiQue, and BROWSECOMP-PLUS (BCP-S). To ensure a fair comparison, they created paired "flat" and "structured" variants of these datasets, where the structured variants explicitly expose sections and metadata as addressable fields.

Key Findings:

Accuracy vs. Efficiency: SIEVE achieved the highest accuracy on all three collections. Its default configuration (BQL-filtered BM25+Dense) improved accuracy by 1.6 to 3.1 percentage points over the strongest conventional Search–Visit baseline while using 20.7% to 50.6% fewer tokens.
BQL Impact: Adding BQL candidate selection improved accuracy across all tested rankers (BM25, dense, and fusion) and all collections. This confirms that the benefit comes from the ability to define an eligible set before ranking, not just from the ranking model itself.
Component Analysis:
- Query-focused snippets: Removing the 25-token snippets caused a significant drop in accuracy (2.9–6.8 points), proving that local evidence is necessary for agents to decide which sections to fetch.
- Retriever Robustness: The gains persisted across different dense encoder sizes and agent backbones (Tongyi-DeepResearch, Qwen-AgentWorld, OpenResearcher).
- Failure Modes: On Wikipedia-based datasets, errors were primarily due to synthesis (incorrectly answering after finding the right document). On the more complex BCP-S, errors were primarily retrieval-bound (failing to surface the gold document). SIEVE reduced selection failures (choosing the wrong document to inspect) across all datasets.

Significance and Claims

The paper claims that source structure is not merely a formatting artifact but a critical resource that, when exposed as searchable and fetchable fields, fundamentally shapes retrieval efficiency and answer quality.

Practicality of Boolean Retrieval: The authors argue that while formulating precise fielded queries has historically required specialist effort, language-model agents can now handle the formulation and revision of these constraints during the research loop. This makes professional search capabilities (long used in medical systematic reviews) practical for general deep-research systems.
Efficiency Frontier: The results suggest that retrieval systems should preserve and expose the organization of sources rather than reducing them to flat pages. This allows agents to search and read information at the granularity at which it was written, achieving a better trade-off between accuracy and context cost.

The authors remain modest regarding their claims, noting that their evaluation is limited to three collections and that the BCP-S section trees were model-generated. They also clarify that SIEVE is a "Boolean-capable workflow with designed zero-hit recovery," not a pure strict-Boolean implementation, and that the observed gains are attributed to the complete system rather than isolated components like Boolean operators alone.