Amazon Bedrock Adds Managed Retrieval Instructions for Multi-Tenant RAG
Summary:Amazon Web Services has added managed retrieval instructions to Amazon Bedrock Managed Knowledge Base, allowing each tenant to define a persona, answer format, retrieval guidance, and answer policy while sharing retrieval infrastructure. Instructions are asynchronously reviewed, versioned, and applied through `AgenticRetrieveStream`; Planning trace events expose the exact instruction version used. The control plane does not replace tenant isolation. Bedrock applies the filter supplied in a requ
What AWS Actually Added
Amazon Bedrock Managed Knowledge Base now exposes managed retrieval instructions as independent, reviewable, versioned AWS resources. Applications can move voice, output structure, retrieval priorities, and answer policies out of scattered prompt code. Before this feature, teams seeking a fixed tone or strict JSON often had to disable managed response generation, invoke a model separately, and maintain the prompt in every application.
The update does not introduce a new retrieval model. Instead, it adds a control plane around agentic retrieval. One instruction can apply to as many as five knowledge bases in a request, allowing a shared global corpus to be combined with tenant-specific sources.
The Four Instruction Fields
| Field | Purpose | Important boundary |
| --- | --- | --- |
| persona | Defines identity, tone, language, and audience | Participates in generation only when generateResponse=true |
| answerFormat | Defines answer structure, citations, dates, and monetary formats | Participates in generation only when generateResponse=true |
| retrievalGuidance | Guides query interpretation, source selection, and search priorities | Affects retrieval even when response generation is disabled |
| answerPolicy | Defines answer boundaries, policy wording, and out-of-scope handling | Participates in generation only when generateResponse=true |
These fields control behavior, not authorization. An instruction can ask the model not to disclose a restricted fact, but it cannot prove that the fact was never retrieved or prevent the model from mentioning its mechanism or identifier.
Creation, Review, and Version Pinning
A retrieval instruction belongs to an AWS account and Region rather than to an individual knowledge base. Its lifecycle starts with CreateRetrievalInstruction, which returns HTTP 202 while the fields are reviewed asynchronously. The backend polls GetRetrievalInstruction until the transition finishes, inspects lastTransitionStatusReasons on failure, and waits for the ACTIVE state.
The developer then calls CreateRetrievalInstructionVersion to create an immutable numbered version. An AgenticRetrieveStream request references the instruction ID and may pin a specific version; omitting the version uses DRAFT. The first Planning trace event exposes appliedInstruction, allowing the application to record the exact instruction ID and version that handled the request.
Production systems should pin immutable versions rather than relying on DRAFT. Updating an instruction replaces its complete content, so every retained field must be submitted again. While an update is under review, DRAFT continues serving the previous content, while another update or a version-creation attempt during the review can return HTTP 409. Bedrock does not route traffic automatically between versions, so canaries, promotion, and rollback remain application responsibilities.
Instructions, Filters, and IAM Are Separate Boundaries
A production multi-tenant system must answer three independent questions: how the response should be written, which documents may be retrieved, and who may apply or manage the instruction.
| Isolation model | Operational cost | Main benefit | Main risk | | --- | --- | --- | --- | | Shared knowledge base with metadata filters | Lowest; documents are synchronized once | Efficient for large tenant populations sharing common material | Missing metadata or incorrect filter construction can expose cross-tenant content | | One knowledge base per tenant | Highest; each tenant adds resources, synchronization, and charges | Clear isolation boundary and simpler operations | Cost and management overhead grow with tenant count | | Shared global corpus plus tenant-specific corpus | Moderate | Reuses public material while protecting private documents | More complex request routing and permission configuration |
Metadata filters must be constructed on the server from an authenticated tenant context. Bedrock applies the filter included in the request, so a filter supplied by an untrusted client cannot be treated as a security boundary. A request can reference only one retrieval instruction. Supporting users who belong to both a region and a team may therefore require combined instructions, pushing the configuration count toward N×M; the default limit is 50 retrieval instructions per account per Region.
IAM Tags Add a Second Check
If every tenant uses the same IAM role, IAM cannot distinguish tenants and the application is the only selector. When each tenant assumes a distinct role or receives a tenant session tag, attribute-based access control can constrain bedrock:GetRetrievalInstruction to instructions carrying the matching resource tag. Administrative bedrock:TagResource permissions should require both request-tag and resource-tag conditions, preventing an administrator from retagging another tenant's instruction into its own scope.
Tag conditions govern who may apply or manage instructions; they do not constrain which documents can be retrieved. bedrock:Retrieve must still be scoped to the knowledge bases available to each role. ListRetrievalInstructions cannot be filtered by tags, so instruction names should not expose customer names, contract terms, or other sensitive identifiers.
Engineering Trade-offs
First, answer policies are best-effort controls. If a restricted document is retrieved, a natural-language prohibition may still fail, and the model may reveal a mechanism or record identifier. Material that requires hard exclusion should be removed through a metadata filter or placed in an isolated knowledge base. A filter also cannot remove a field embedded inside a shared document that the tenant is otherwise entitled to read.
Second, an instruction does not select the tenant's facts. A short tenant line in the request can help the agent quote the appropriate return window, but it does not replace a filter and does not set language, date, or currency formats. Exact deadlines and monetary values should be calculated by business code whenever deterministic computation is required.
Third, structured output still requires validation. Even if answerFormat requests exactly one JSON object, the model may occasionally violate the schema. Downstream services should parse the payload, validate it against a schema, and implement a failure path rather than treating prompt instructions as a data-integrity guarantee.
Fourth, version pinning introduces release-management work but provides reproducibility and rollback. Each tenant should have a live version, an optional canary version, and a routing ratio. Promotion must depend on the application's own task set, factual accuracy, schema pass rate, and safety regressions. Trace events prove which version handled a request, not that the new version produced a better answer.
What the Example Proves—and Does Not Prove
The AWS example uses 32 fictitious smart-home policy documents and six tenants to demonstrate three sales regions and three internal teams over a shared knowledge base. With the appropriate instructions, the North, Central, and South examples return 40-day, 45-day, and 14-day return windows respectively. The Central response also switches to Spanish and adopts local date and currency conventions. When the purchase region is unspecified, the support-team example asks for confirmation instead of quoting a regional deadline.
These examples demonstrate functional control over voice, structure, and policy selection. They are not a controlled benchmark. AWS reports no retrieval recall, factual-accuracy score, time-to-first-token, throughput, per-request cost, or resource overhead across tenant scales. It also provides no same-condition comparison against application-level prompts, separate generation calls, or alternative orchestration stacks.
Production Deployment Checklist
- Maintain a deterministic mapping from each authenticated tenant to its instruction ID, pinned version, metadata filter, and knowledge-base set. Never accept security boundaries directly from the client.
- Standardize document metadata for region, audience, and sensitivity, then automatically verify the visible document set for every tenant.
- Wait for control-plane review to succeed before creating a version. Pin immutable versions in production and reserve
DRAFTfor testing. - Assemble the tenant context, filter, and instruction version on the server before calling
AgenticRetrieveStream. - Apply least privilege to knowledge-base retrieval, instruction reads, and tag management rather than sharing one tenant-blind role across the application.
- Record the tenant ID,
appliedInstruction, version, and result status. Enable CloudTrail data events when required, while avoiding unnecessary storage of sensitive response bodies. - Run canary releases, schema validation, and rollback with an application-owned evaluation suite. Compute exact business values from structured data instead of asking the model to reproduce them.
— END —Source: AWS Machine Learning Blog (2026-11-16)
Tags: #Amazon Bedrock #RAG #Multi-Tenant Isolation #Retrieval Instructions #IAM
Editorial & Fact-Checking Note: This article is compiled from primary research, official release documentation, and source papers by the ZICQ Newsroom pipeline with automated entity verification and human editorial review. If you notice any technical inaccuracy, please submit a correction via our corrections policy or email our editorial desk directly.
Community Comments