This prompt is a tactical planning tool for an agentic retrieval loop. Its sole job is to analyze a complex user question alongside the currently retrieved context, identify the specific evidence that is still missing, and generate a single, targeted search query to fill that gap. The ideal user is a RAG system operator or AI engineer who has already decomposed a complex question or started a reasoning chain and has received an initial batch of incomplete results. You should use this prompt when your system needs to decide what to retrieve next, not when you need to rewrite a user's initial query for better recall. It assumes you are inside a planning step, after an initial retrieval and before the next retrieval call is executed.
Prompt
Sequential Retrieval Query Planning Prompt

When to Use This Prompt
Defines the precise job, ideal user, and required context for the sequential retrieval query planning prompt, and clarifies when not to use it.
To use this prompt effectively, you must provide it with the original user question and the full text of the currently retrieved context. The prompt's value is in its precision: it forces the model to articulate the evidence gap before generating a query, making the agent's next action auditable. The output is not a final answer, a sub-question for a human, or a general topic suggestion. It is a concrete, self-contained search query designed to be passed directly to your vector, keyword, or hybrid search engine. A well-formed output will often include specific entities, technical terms, or temporal constraints that were absent from the initial retrieval.
Do not use this prompt as a standalone question-answering system or as a replacement for an initial query rewriter. It is not designed to handle the first retrieval step, where the goal is broad recall. It is also not a substitute for a full task decomposition prompt; it assumes a decomposition or reasoning plan is already in progress and only needs the next tactical move. If your system lacks a mechanism to track what has already been retrieved and what remains unknown, this prompt will produce queries that are redundant or misaligned with the overall plan. Use it as one component in a stateful agent loop, where the output query is executed, the new results are added to the context, and the cycle repeats until an evidence sufficiency check passes.
Use Case Fit
Where the Sequential Retrieval Query Planning Prompt works well and where it introduces risk. Use these cards to decide if this prompt fits your architecture before wiring it into an agentic loop.
Good Fit: Agentic RAG Loops
Use when: you have an orchestrator that can execute the generated query, retrieve results, and feed them back into the reasoning loop. The prompt shines inside a while-loop that iteratively fills evidence gaps. Avoid when: you need a single-turn answer from a static context window with no retrieval tool available.
Good Fit: Complex Multi-Document Questions
Use when: the user question requires information that is unlikely to exist in a single document or passage. The prompt plans the next hop across disparate sources. Avoid when: the question is a simple factoid lookup where a single vector search would suffice; the planning overhead adds latency without benefit.
Bad Fit: Ambiguous or Unanswerable Questions
Risk: the model may generate a plausible-sounding query for a question that has no answer in the knowledge base, wasting retrieval calls and delaying a necessary abstention. Guardrail: pre-check the question for answerability and set a maximum hop budget. If the gap persists after N retrievals, force the system to respond with 'insufficient evidence' rather than planning another query.
Required Inputs: Rich Initial Context
Risk: without initial retrieved context, the planner has no signal about what is already known and what is missing. The generated query may be too broad or redundant. Guardrail: always seed the prompt with at least one retrieval result. If no initial context exists, run a broad retrieval first or use a separate query-generation prompt before entering the planning loop.
Operational Risk: Query Drift
Risk: across multiple hops, each generated query may drift further from the original user intent, chasing tangential information. Guardrail: include the original user question in every planning prompt instance and validate each generated query against it using a similarity or intent-preservation check before execution.
Operational Risk: Infinite Retrieval Loops
Risk: the planner may keep generating queries indefinitely if it fails to recognize that sufficient evidence has been gathered. Guardrail: enforce a hard limit on the number of sequential retrieval steps (e.g., 5 hops). Combine with a termination condition that checks if the accumulated evidence is adequate to answer before planning another query.
Copy-Ready Prompt Template
A reusable prompt template for generating the next targeted retrieval query to fill an evidence gap in a sequential, multi-hop RAG loop.
This prompt is designed to be the planning step in an agentic retrieval loop. Given a complex user question and the evidence gathered so far, its sole job is to identify the most critical missing piece of information and formulate a precise, self-contained search query to retrieve it. The template uses square-bracket placeholders for all dynamic inputs, making it straightforward to integrate into a Python or TypeScript harness where these variables are populated at runtime from the application state.
textYou are a query planning specialist for a research assistant. Your task is to analyze a complex user question and the context that has already been retrieved. Identify the single most critical piece of missing information required to answer the question, and formulate a specific, self-contained search query to find it. USER QUESTION: [USER_QUESTION] CURRENT RETRIEVED CONTEXT: [RETRIEVED_CONTEXT] PLANNING CONSTRAINTS: - Do not re-ask the original question. - Do not ask for information already present in the current context. - The query must be a standalone search string, not a conversational turn. - If the context is sufficient to answer the question, respond with "SUFFICIENT". - If the question is unanswerable even with more information, respond with "UNANSWERABLE: [reason]". OUTPUT FORMAT: Return a JSON object with the following keys: { "status": "NEXT_QUERY" | "SUFFICIENT" | "UNANSWERABLE", "reasoning": "A brief explanation of the gap identified and why this query is the best next step.", "next_query": "The specific search query string, or null if status is not NEXT_QUERY." }
To adapt this template, replace the placeholders with your application's state. [USER_QUESTION] is the original, complex question from the user. [RETRIEVED_CONTEXT] is the concatenated text of all documents or chunks retrieved in previous steps. In your harness, you should parse the JSON response and use the status field to control the agent loop: if NEXT_QUERY, execute the search and feed the new results back into the context for the next iteration; if SUFFICIENT, proceed to answer generation; if UNANSWERABLE, surface the reason to the user or a human reviewer. For high-stakes domains, log the reasoning field alongside every step to create an auditable trail of the system's research path.
Prompt Variables
Required inputs for the Sequential Retrieval Query Planning Prompt. Each variable must be populated before the prompt is assembled and sent to the model. Validation notes describe how to programmatically verify the input before execution.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[COMPLEX_QUESTION] | The original user question that could not be fully answered from the initial retrieval context | What were the revenue impacts of the 2023 supply chain disruption across our European and APAC divisions, and which product lines recovered fastest? | Must be a non-empty string. Check that the question contains multiple clauses, entities, or conditions that would require evidence from more than one document. Reject single-hop factual lookups. |
[INITIAL_CONTEXT] | The set of retrieved passages or documents returned from the first retrieval step that partially address the question | Passage 1: 'Q3 2023 European revenue declined 12% due to component shortages...' Passage 2: 'APAC recovery began in Q4 with semiconductor inventory normalization...' | Must contain at least one passage. Validate that the context is a list or concatenated string of retrieved chunks, not empty or null. Each passage should have a source identifier if available. |
[PREVIOUS_QUERIES] | A list of retrieval queries already executed in this reasoning chain, used to prevent redundant or circular searches | ['supply chain disruption revenue impact Europe 2023', 'APAC division recovery timeline product lines'] | Can be an empty list on the first iteration. Validate that it is a list of strings. Check for duplicate queries before appending. If the list exceeds a configurable max (e.g., 10), halt the loop and escalate. |
[EVIDENCE_GAPS] | A structured description of what information is still missing after reviewing the initial context | Missing: (1) Revenue figures for APAC division in Q3-Q4 2023, (2) Product-line-level recovery timelines, (3) Comparison data between European and APAC recovery rates | Must be a non-empty string or structured list. Validate that the gaps are specific and actionable, not vague statements like 'more data needed.' If no gaps are detected, the planning loop should terminate and proceed to answer synthesis. |
[RETRIEVAL_SOURCE_DESCRIPTION] | A description of the available retrieval corpus, including document types, date ranges, and any domain constraints | Internal financial reports (Q1 2022-Q4 2024), supply chain incident logs, product-line P&L statements, regional sales dashboards | Must be a non-empty string. Validate that it provides enough detail for the model to formulate a targeted query. If the corpus has known blind spots (e.g., no pre-2022 data), include that constraint here. |
[MAX_QUERY_LENGTH] | The maximum allowed length for the generated retrieval query, enforced to match the retrieval system's token or character limits | 256 characters | Must be a positive integer. Validate that the generated query does not exceed this limit before sending to retrieval. If the model produces an over-length query, truncate or trigger a retry with a length constraint reminder. |
[OUTPUT_SCHEMA] | The expected JSON structure for the generated query plan, including fields for the query string, rationale, and expected evidence type | { 'search_query': string, 'rationale': string, 'expected_evidence_type': string, 'gap_addressed': string } | Must be a valid JSON schema definition. Validate that the model output parses as JSON and contains all required fields. If parsing fails, trigger the output repair harness before proceeding to retrieval. |
Implementation Harness Notes
How to wire the Sequential Retrieval Query Planning Prompt into an agentic RAG application with validation, retries, and state management.
This prompt is designed as the reasoning step inside an agentic retrieval loop. It should not be used in isolation or as a one-shot call. The application harness must manage the loop state, track the evidence chain, and decide when to stop querying and synthesize a final answer. The prompt's job is narrow: given the current state of knowledge and a specific evidence gap, produce the next retrieval query. The harness owns the broader workflow—initial decomposition, gap detection, query execution, result ingestion, and termination logic.
Wire the prompt into a loop controller that maintains a structured evidence log. Before each call, populate [ORIGINAL_QUESTION] with the user's initial query, [CURRENT_KNOWLEDGE_SUMMARY] with a concise synthesis of all evidence retrieved so far, and [IDENTIFIED_GAP] with a specific, actionable description of what's missing. The model returns a JSON object with a search_query field and a rationale field. Validate the output before executing the query: reject empty queries, queries that are verbatim copies of previous attempts, or queries that don't address the stated gap. Implement a maximum iteration limit (typically 3-5 hops) and a semantic deduplication check against prior queries to prevent loops. Log every query, the retrieved results, and the gap assessment for debugging and audit trails.
For model choice, use a capable instruction-following model with strong reasoning performance (e.g., Claude 3.5 Sonnet, GPT-4o). Set temperature to 0.1-0.2 to balance creativity in query formulation with consistency. If the application is high-stakes—legal, clinical, financial—add a human review gate after the loop completes but before the final answer is shown to users. The review interface should display the original question, the full chain of queries and retrieved evidence, and the planned final synthesis. Do not treat this prompt as a black box; its output quality depends directly on the accuracy of the gap description fed into it. Invest engineering effort in the gap detection step that precedes this prompt in the loop.
Expected Output Contract
Defines the fields, types, and validation rules for the structured output of the Sequential Retrieval Query Planning Prompt. Use this contract to parse and validate the model's response before executing the next retrieval step in an agentic loop.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
next_query | String | Must be a non-empty string. Validate that it is a specific, targeted search query, not a rephrasing of the original question. Check for keyword density and absence of conversational filler. | |
gap_addressed | String | Must be a non-empty string. Validate that it explicitly names the specific evidence gap from the input [EVIDENCE_GAP] that this query intends to fill. Perform a semantic similarity check against the input gap description. | |
expected_evidence_type | String | Must be a non-empty string. Validate that it describes a concrete type of information (e.g., 'date', 'statistic', 'definition', 'person name'). Check against a predefined list of valid evidence types or use a classifier. | |
rationale | String | Must be a non-empty string. Validate that it provides a clear, logical reason connecting the query to the gap. Check for a minimum character length (e.g., >20) to avoid trivial rationales. | |
confidence | Float | Must be a number between 0.0 and 1.0. Validate the range. If below a configurable threshold (e.g., 0.7), the system should log a warning or route for human review before executing the query. | |
stop_condition_met | Boolean | Must be true or false. If true, the system should halt the retrieval loop. Validate that if true, the next_query field is null or an empty string, and the rationale explains why no further retrieval is needed. | |
null | null | null |
Common Failure Modes
Sequential retrieval query planning fails in predictable ways when deployed in agentic loops. Here are the most common failure modes and how to guard against them before they reach production.
Query Drift Across Iterations
What to watch: Each retrieval step subtly shifts focus away from the original question. By the third or fourth hop, the system is retrieving documents irrelevant to the user's intent. This happens when the planner optimizes for gap-filling without anchoring to the root question. Guardrail: Include the original user question in every planning prompt and require the planner to explicitly state how the proposed query connects back to the root intent before execution.
Over-Specific Query Generation
What to watch: The planner generates queries that are too narrow, embedding assumptions about what the answer should look like. This causes retrieval to miss contradictory evidence or alternative explanations. Common when the planner overfits to partial evidence from earlier hops. Guardrail: Require the planner to generate at least one broad exploratory query alongside any targeted query, and validate that queries do not contain answer-presupposing language.
Hallucinated Evidence Gaps
What to watch: The planner identifies a gap that does not actually exist or invents a missing fact that was already present in retrieved context. This triggers unnecessary retrieval steps, wastes latency budget, and can introduce noise that derails the reasoning chain. Guardrail: Before generating a new query, require the planner to cite the specific sentence or passage from existing context that demonstrates the gap. If it cannot, skip retrieval and proceed with available evidence.
Infinite Retrieval Loops
What to watch: The planner keeps generating new queries without converging on an answer. Each retrieval returns partial information that suggests another gap, creating an unbounded chain. This exhausts token budgets and latency targets. Guardrail: Enforce a hard maximum on retrieval steps (typically 3-5) and require the planner to produce a best-effort answer with explicit uncertainty markers when the limit is reached.
Query-Context Mismatch
What to watch: The planner generates a syntactically valid query that retrieves documents from the wrong domain, time period, or entity scope. For example, querying for a product feature when the question is about a legal ruling with the same name. Guardrail: Include domain constraints and metadata filters in the planning prompt. Validate generated queries against expected entity types, date ranges, or document collections before execution.
Premature Answer Commitment
What to watch: The planner implicitly commits to an answer direction after the first retrieval and generates subsequent queries only to confirm that hypothesis. This confirmation-bias loop suppresses disconfirming evidence and produces overconfident, wrong answers. Guardrail: After every retrieval step, require the planner to list both supporting and contradicting evidence found so far. If no contradicting evidence exists after two hops, inject a deliberate disconfirming query.
Evaluation Rubric
Use this rubric to test the Sequential Retrieval Query Planning Prompt before deployment. Each criterion targets a specific failure mode common in agentic retrieval loops. Run these checks on a golden set of complex questions with known evidence gaps.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Gap Relevance | The generated query directly addresses the specific evidence gap identified in [IDENTIFIED_GAP]. | Query targets a tangential topic or re-asks the original question instead of filling the stated gap. | Human review or LLM-as-judge: Does the query semantically match the gap description? Score 1-5. |
Query Specificity | The query contains specific entities, relationships, or constraints from [COMPLEX_QUESTION] and [CURRENT_CONTEXT]. | Query is overly broad, generic, or missing key disambiguating terms present in the context. | Keyword overlap check: Verify query terms appear in the gap description or context. Flag if < 2 specific terms. |
Non-Redundancy | The query seeks information not already present in [CURRENT_CONTEXT]. | Query re-requests facts already retrieved, indicating the model failed to recognize existing evidence. | Semantic similarity check: Compute embedding similarity between query and context chunks. Fail if similarity > 0.9. |
Retrievability | The query is formulated as a search-friendly string, not a conversational question or command. | Query contains conversational filler ('Can you find...'), pronouns without referents, or multi-clause questions. | Regex check: Fail if query matches conversational patterns or exceeds 15 words without a clear entity focus. |
Dependency Awareness | The query respects the logical order of information needs; it does not skip prerequisite facts. | Query asks for a conclusion before establishing the premise, indicating flawed dependency reasoning. | Dependency graph check: Map query to required prior knowledge. Fail if prerequisite is absent from [CURRENT_CONTEXT]. |
Hallucination Avoidance | The query does not introduce entities, events, or assumptions not present in [COMPLEX_QUESTION] or [CURRENT_CONTEXT]. | Query invents a specific date, name, or fact not grounded in the input, leading retrieval astray. | Entity extraction diff: Extract entities from query. Fail if any entity is absent from both input fields. |
Gap Coverage Completeness | If multiple gaps exist, the query targets the most critical missing piece needed to advance the reasoning chain. | Query addresses a minor or peripheral gap while a major blocker remains, stalling the agent loop. | Priority alignment: Rank gaps by logical necessity. Fail if query does not target a top-priority gap. |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Adapt This Prompt
How to adapt
Use the base prompt with a single retrieval call and lighter validation. Remove the [RETRIEVAL_HISTORY] placeholder if you're testing the first hop. Simplify [OUTPUT_SCHEMA] to just {"next_query": "string", "rationale": "string"}. Accept free-text output and parse loosely.
Watch for
- The model generating a query that restates the original question instead of targeting the gap
- Missing schema checks causing downstream parsing failures
- Overly broad instructions that produce essay-length rationales instead of a focused query

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us