AWS Launches Agentic Retrieval for Bedrock Knowledge Bases, Priced at $4 per 1,000 Calls

What's New

Amazon Web Services has released agentic retrieval for Amazon Bedrock Managed Knowledge Bases, a new retrieval mode accessed through the AgenticRetrieveStream API. Instead of a single similarity search, the system runs a foundation-model-driven planning loop that decomposes a user's question into sub-queries, retrieves evidence for each, judges whether it has enough information, and iterates as needed — generating a grounded response with citations in the same API call.

The Problem It Addresses

Standard single-shot retrieval in Bedrock Knowledge Bases returns top-k chunks based on one query embedding. According to AWS, this breaks down on multi-part, comparative, or exploratory questions — for example, "Compare our 2020 and 2023 strategy. What changed?" A single embedding can't represent multiple competing sub-intents, so results either scatter across loosely related chunks or cluster around the strongest signal, missing the comparative structure the user actually asked for.

AWS says teams have historically built custom agent frameworks on top of the existing Retrieve API to work around this — prompting a model to loop, generate sub-queries, deduplicate results, and decide when to stop — but this requires custom engineering with its own latency, cost, and reliability tradeoffs in every application.

How It Works

The AgenticRetrieveStream API streams a sequence of trace events:

• SpeculativeRetrieval: An initial search that runs before planning begins, using the raw query for single-KB requests or a probe search to route sub-queries across multiple KBs. It does not count toward the iteration limit.
• Planning: The foundation model analyzes the query, reviews prior results, and generates sub-queries. It also judges whether evidence is sufficient or another iteration is needed.
• Retrieval / FullDocumentExpansion: Each sub-query executes as its own event; the system can pull a full document rather than a passage if it determines context is insufficient.
• Result: The final event, containing deduplicated source chunks (deduplication applies only here, not to intermediate trace events) and, by default, a generated response with citations. Setting generateResponse=False returns retrieval results without generation.

Two parameters control behavior: maxAgentIteration (AWS recommends 3 for a single knowledge base, 4–5 for multi-KB or comparative queries) and foundationModelType, which selects either the service-managed model or a custom model specified via foundationModelConfiguration.

Pricing

AWS confirms agentic retrieval is priced per call:

• Managed model: $4 per 1,000 agentic retrieval calls, plus $1 per 1,000 underlying Retrieve API calls.
• Custom Bedrock model: standard pass-through Bedrock pricing for the chosen model, plus the same $1 per 1,000 underlying Retrieve calls.

No context window, benchmark scores, or training cutoff date were disclosed, as this is a retrieval infrastructure feature rather than a new foundation model.

What This Means

This is AWS packaging a pattern developers were already hand-rolling — iterative, agentic RAG loops — into a managed API with metered pricing. The core value proposition is reduced engineering overhead: teams building comparative or multi-hop question-answering on top of Bedrock no longer need to write custom orchestration, deduplication, and stopping-criteria logic themselves.

The economics matter here. At $4 per 1,000 calls plus $1 per 1,000 retrievals, cost scales with iteration count in ways that weren't previously itemized this cleanly — a query requiring five planning iterations will generate five retrieval calls, each billed separately. Teams should benchmark whether the managed model's iteration decisions are efficient before assuming this is cheaper than a custom-built loop running on a smaller or self-hosted model.

This also signals a broader trend: retrieval-augmented generation is moving from static single-shot lookup toward agentic, multi-step search as a standard product feature rather than a bespoke integration pattern, following similar moves toward tool-calling and iterative reasoning across the industry.