AWS Adds Single-Shot RAG and Retrieval-Only Mode to Bedrock

Amazon Web Services announced on November 9, 2026 that Amazon Bedrock Managed Knowledge Base now supports single-shot retrieval-augmented generation (RAG — a pattern that fetches source passages and feeds them to a model to ground its answer) and passage-only requests through the AgenticRetrieveStream API. An expanded 0–5 range for the maxAgentIteration parameter lets applications choose source retrieval only, a one-search answer, or the service's existing multi-step agentic retrieval.

The update matters because it consolidates three retrieval patterns into one streaming API. Until now, applications that needed a simple lookup either paid for the full agentic workflow — multiple model calls, query rewrites, iterative searches — or integrated a separate Retrieve API. That split forced engineering teams to maintain two code paths. One parameter now spans the full range.

What does the new parameter range do?

The values map cleanly onto three behaviors, according to AWS:

• 0 returns matching passages without generating an answer.
• 1 retrieves once and generates an answer when generateResponse=true is set.
• 2 through 5 preserve the existing agentic behavior, with iterative planning and retrieval.

Every mode supports multiple knowledge bases. AWS stresses that "single-shot" refers to one retrieval, not a restriction to one knowledge base.

Single-shot RAG uses one foundation-model call for generation. Retrieval-only requests use none. AWS says single-shot operation can reduce latency and model usage relative to agentic retrieval — but the announcement supplies no measured latency or cost comparison. Enterprises will need to benchmark on their own corpora.

How do iterations translate into model calls?

One iteration represents one foundation-model call. When generation is enabled, a limit of n reserves the final call for answer generation and allows as many as n minus 1 planning rounds. Each planning round pairs a query rewrite with a retrieval. The initial speculative retrieval runs before planning begins and never counts against the limit.

The boundaries are strict at the low end. At maxAgentIteration=0, response generation must be off. Enabling it produces a 4xx error, because generating an answer requires a model call and the retrieval-only mode makes none. At 1, the stream carries one retrieval and one grounded answer, with no planning trace events. Existing requests using 2 through 5 do not change.

AWS describes the mechanics of agentic retrieval in detail. For complex questions, the Amazon Bedrock User Guide lays out a workflow that decomposes queries into sub-queries, checks whether the retrieved evidence is sufficient, conducts additional searches, and can expand to a full document. Agentic retrieval supports only fully managed Bedrock knowledge bases and permits up to five retrievers per request.

There is a trade-off on the upper bound. Lowering the iteration ceiling can stop the agent sooner, which cuts model usage — and, AWS notes, can potentially reduce accuracy on complex queries. Depth costs money. Shallow retrieval risks incomplete answers.

What changes inside the streaming API?

The AgenticRetrieveStream API reference identifies three required request inputs: messages, retrievers, and agenticRetrieveConfiguration. The generateResponse flag is optional. Generated answer chunks appear in the stream only when generation is enabled. The final result can contain retrieved items, a synthesized answer, and citations that connect spans of the answer to supporting results.

Retrieval-only operation is functionally equivalent to calling the Retrieve API directly, with one format difference: passages appear in the stream's result event without score or location fields. Applications already using AgenticRetrieveStream can consequently obtain Retrieve-style behavior by changing a parameter instead of integrating a separate API. For teams with existing integrations, that is the practical payoff of this release.

How should teams pick a mode?

AWS illustrates the settings with a fictional bank's internal policy assistant — an example, not a customer deployment. Three scenarios show the intended fit:

• A sole-proprietor documentation question uses maxAgentIteration=1 — one retrieval, one generated answer.
• A comparison of sole-proprietor and LLC requirements that also checks rules for nonresident owners uses 4, permitting up to three planning rounds.
• A request to inspect policy language uses 0 and returns source passages without a summary.

The application must select the mode. maxAgentIteration does not automatically route requests based on question complexity. Teams building assistants will need their own routing logic — or settle on a single setting per workflow.

AWS is careful about scope in its example. The fictional assistant handles policy lookup and comparison, but it neither approves accounts nor replaces bank review and authorization. The company frames the tool as evidence retrieval, not decision-making.

For adoption, AWS recommends a structured evaluation. Teams should compare single-shot RAG with the existing agentic configuration on the same knowledge base, using representative questions and expected answers. The evaluation should measure latency and request cost, verify correctness and support in retrieved passages, and include multi-document and unanswerable questions. Those results can guide selection of the lowest iteration limit that satisfies each workflow's quality requirements.

The guidance is unambiguous on method: measure, then choose. Assume nothing about which mode wins on cost or accuracy.

Why does retrieval depth as a parameter matter?

The change makes retrieval depth an explicit per-request infrastructure decision. Direct lookups can avoid planning calls entirely, while complex queries retain iterative evidence gathering. That granularity aligns cost with query difficulty — a pattern familiar from other inference-cost optimizations, where routing simpler requests to cheaper paths cuts spend without touching model quality for hard cases.

For enterprises, AWS frames the central trade-off precisely: whether reduced model usage preserves complete, supported answers on their own documents. The announcement pushes back on the assumption that a higher iteration limit is always better. On a well-indexed corpus with focused questions, one retrieval may ground a full answer. On tangled, multi-document questions, cutting planning rounds may strip out evidence the answer needs.

What comes next depends on adoption data AWS has not published. The announcement offers no measured latency or cost comparisons, so the practical question for engineering teams is empirical: on their own knowledge bases, with their own question mix, where does the lowest iteration limit that still yields correct, cited answers actually land?