Amazon Bedrock Access Control Moves Beyond the Model
AWS published an Amazon Bedrock access control reference design on November 12, 2026, that keeps user identity outside an AI model’s discretion. The design connects a managed knowledge base to agents while preserving individual document permissions. Its central distinction is consequential: a system can filter documents correctly while trusting the wrong identity.
The architecture exposes search through Model Context Protocol (MCP), a standard that lets AI applications discover and invoke tools. Trusted infrastructure supplies the authenticated user, an independent policy checks that identity, and a resource restriction protects the underlying knowledge base.
This is defensive integration guidance, rather than a disclosed breach or a universal defense against prompt injection. The tension is between model-generated tool arguments and application-controlled authority. Developers building shared assistants must decide which arguments represent user intent and which arguments grant access.
Amazon Bedrock access control separates identity from intent
The reference design treats the search question as model-generated input while reserving identity for trusted application infrastructure.
AWS’s access control design combines verified identity injection, independent policy validation, document filtering, and restrictions on direct knowledge-base access. Its sample uses three synthetic documents and two users. That scope makes the security boundary understandable without establishing performance or effectiveness across every enterprise deployment.
The fictional scenario involves departmental business plans and a shared notice. Different employees ask the same assistant similar questions, but their answers should draw from different authorized material. A shared interface therefore needs a user-specific retrieval scope.
That scenario exposes a distinction buyers should recognize immediately. An assistant’s ability to find an answer says little about its right to retrieve the supporting documents. Search relevance and access permission answer different questions.
A model is useful for interpreting an employee’s request. It can turn an ambiguous question into search terms and decide whether another search would help. Those capabilities do not establish which employee is making the request.
This distinction becomes especially important when identity appears beside ordinary search parameters. A field describing the user can look like another argument for the model to complete. Yet changing that field changes whose permissions govern retrieval.
The architectural response is to remove that choice from the model’s authority. The model can propose a tool call, but trusted infrastructure determines the identity attached to it. That division preserves flexibility over the task without delegating the permission decision.
The timing matters because the integration joins agent-driven tool selection with access-controlled enterprise knowledge. A conventional application can construct every search request itself. An agent introduces a component that generates arguments dynamically, so the boundary requires explicit treatment.
The announcement should therefore be read as an integration pattern, rather than evidence that access control has become automatic. Its value lies in identifying where responsibility belongs. Organizations still need to implement and verify those responsibilities within their own identity and data environments.
For readers comparing personal and team knowledge, the distinction also clarifies the operational burden of shared assistants. Bringing documents together creates a separate obligation to preserve who can retrieve them.
A useful purchasing question follows from that burden. Ask whether the assistant merely accepts a user identifier or derives it from an authenticated session. Similar interfaces can conceal materially different answers.
Shared assistants put application owners under pressure
Application owners must connect the authenticated person to every retrieval request, rather than assume a shared agent preserves that connection.
Amazon Bedrock AgentCore Gateway acts as the intermediary that exposes backend capabilities as agent tools. Its managed knowledge-base connector offers Retrieve, a search operation, and AgenticRetrieveStream, an operation that plans and performs multiple retrieval steps.
AWS’s connector documentation distinguishes those retrieval paths and explains that administrators configure the target knowledge bases. This matters because tool selection and data selection need deliberate boundaries. An agent’s ability to choose a search operation should not imply authority to choose an unrestricted data source.
The pressure falls first on platform engineers integrating the agent. They must understand which values the gateway fixes, which values the model supplies, and which values trusted code replaces. A tool definition is therefore part of the access-control review.
Security teams face a related challenge. Reviewing the final answer is insufficient when the concern is unauthorized retrieval. They need evidence about the request that reached the backend and the identity used to scope it.
Product owners also inherit a difficult communication problem. Users experience one assistant and expect consistent permissions throughout a conversation. Internal implementation differences become relevant when those differences change which documents the assistant can access.
Consider an illustrative procurement assistant that answers questions about supplier contracts. An employee might legitimately ask for a comparison across vendors. The wording of that request does not grant access to restricted legal material.
An agent can interpret the comparison request correctly while selecting an inappropriate identity or scope. That would be an authorization failure even if its eventual summary were accurate. Product quality cannot compensate for an incorrect permission boundary.
Shared infrastructure adds another reason to separate these concerns. The application’s service credentials establish its ability to contact a backend. They do not, by themselves, establish every employee’s rights to every document.
AWS Identity and Access Management (IAM), the system governing AWS principals and permissions, handles that infrastructure authority. Document permissions address a different relationship between an end user and particular content. A deployment needs both relationships to remain coherent.
This is also where responsibility becomes organizational. Identity administrators maintain the user directory, data owners govern document permissions, and application engineers assemble retrieval requests. Each group can perform its local task correctly while the overall mapping remains wrong.
A practical review should therefore follow the full request rather than individual products. Who authenticated the employee? Which component selected the retrieval identity? Which permission record determined the returned documents?
Those questions create immediate work for teams moving a prototype into shared use. The short-term response is architectural verification. The longer-term response is assigning ownership for identity mapping, permission changes, and regression checks.
The commercial implication is similarly concrete. Buyers should evaluate permission behavior as part of assistant functionality, rather than treat it as a background infrastructure promise. The feature being purchased includes the ability to withhold relevant information from unauthorized users.
Trusted injection and policy checks do different jobs
Identity injection constructs the intended request; policy validation checks whether that construction stayed within the authenticated user’s authority.
A request interceptor is code that runs before the gateway invokes its target. AWS implements gateway interceptors with Lambda, its service for running functions. The request interceptor documentation describes request transformation, validation, and custom authorization as supported uses.
In this design, the interceptor overwrites userContext, the request field carrying the end user’s identity. Its input comes from a verified JSON Web Token (JWT), a signed token carrying authentication claims. A client-supplied identity therefore does not determine the final retrieval identity.
The difference between replacement and suggestion matters. A tool description can tell a model which identity to use, but that remains an instruction. Replacement makes the trusted component responsible for the actual value.
This approach also changes how developers should evaluate model behavior. A model might produce an inappropriate identity argument, yet the downstream request can still carry the correct authenticated identity. The decisive evidence is the enforced request, rather than the model’s stated intention.
Policy in AgentCore supplies a separate check. It evaluates tool interactions against configured rules outside the agent’s own reasoning. AWS documents tool access policies that can depend on user identity and tool inputs.
The reference design uses Cedar, an authorization policy language, to compare the injected user identity with the verified token claim. A mismatch should cause denial. That creates a check on the interceptor’s result rather than another instruction for the model.
These controls serve complementary purposes. Injection makes legitimate requests easier to construct consistently. Validation provides an opportunity to reject requests when construction fails or configuration changes.
Calling the validation independent requires care. It independently compares the request against authenticated identity, but it does not create an unrelated identity system. Both mechanisms still depend on the correctness of the upstream identity information.
That shared dependency limits the claim developers should make. Agreement between two components establishes consistency with their common identity source. It does not establish that the source’s user-to-identity mapping is correct.
This distinction suggests a useful engineering practice: test construction and validation separately. A valid request shows that the ordinary path works. A deliberately mismatched request shows whether the checking component rejects the condition it exists to catch.
Neither result alone answers the other question. An interceptor that always produces the expected value can hide a nonfunctioning policy check. A strict policy can reject malformed requests while leaving the legitimate path unusable.
There is an operational tradeoff as well. Moving identity handling into gateway infrastructure creates a reusable boundary, but that infrastructure becomes part of the application’s critical path. Its changes deserve the same review as other authorization changes.
Logging requires equal care. AWS warns that forwarded request headers can contain authentication tokens and credentials. Operational visibility should establish what happened without unnecessarily recording the secrets that enabled the request.
The broader lesson concerns authority-bearing arguments. User identity is one example, but developers should inspect other fields that select tenants, accounts, or restricted resources. A model’s ability to produce a value does not establish permission to act through it.
Resource restrictions close the route around the gateway
A protected gateway cannot govern retrieval requests that reach the knowledge base through another route.
A resource-based policy is a permission document attached directly to a resource. For managed knowledge bases, AWS supports policies covering Retrieve and GetDocumentContent, the operation that returns document content. An explicit denial can override permission granted through a caller’s identity policy.
The knowledge-base resource policies documentation also distinguishes managed knowledge bases from vector knowledge bases. These resource policies apply to the managed type. Teams should verify the actual resource type before assuming that similarly named products support identical controls.
In the reference architecture, a resource restriction limits retrieval to the intended gateway execution role. That role is the AWS identity under which the gateway contacts the backend. This addresses direct calls that would otherwise avoid the gateway’s identity handling.
The distinction changes the scope of security review. Inspecting the visible application path establishes only how that path behaves. Reviewing the backend’s accepted callers establishes whether the path is mandatory.
For an enterprise deployment, that review should include operational access. Administrative tools, diagnostic scripts, and other applications might have legitimate reasons to contact the same resource. Each exception needs an explicit purpose and an understood identity-handling model.
An exception is not necessarily a defect. It becomes a problem when the application’s security claim assumes exclusive gateway access while the resource accepts other callers. The claim and the configuration must describe the same system.
Resource restrictions also concentrate authority. If a particular role is trusted to retrieve documents, other workloads using that role need scrutiny. Restricting a role name does not establish that every process operating under it performs equivalent user checks.
This creates a governance question beyond retrieval itself. Who can change the resource policy? Who can modify the trusted gateway or its execution role? Control over those settings can alter the boundary that application teams rely on.
Microsoft provides a useful comparison without establishing a winner. Its document-level access control documentation distinguishes application-supplied security filters from identity-aware permission approaches. Several native approaches carry preview qualifications.
That comparison highlights a shared evaluation problem. A filter based on a supplied identity string differs from a permission check tied to authenticated identity. Product labels alone do not tell buyers which relationship a particular integration enforces.
The relevant comparison is therefore architectural. Determine where authentication occurs, how identity reaches retrieval, how document permissions are evaluated, and which callers can bypass the application. Feature availability and maturity also need evaluation within the chosen configuration.
Amazon Bedrock access control belongs in that broader assessment. The reference design explains a defensible arrangement of responsibilities. It does not remove the need to inspect deployment exceptions, administrative authority, or the exact backend being used.
The practical tradeoff is clear: shared retrieval remains convenient only when its trusted access path remains controlled. Additional gateways or service identities should trigger a renewed review of that assumption.
Permission freshness remains an operational limit
Correct identity handling cannot make outdated document permissions current.
An access control list (ACL) records which identities can access an item. For an ACL-enabled Amazon S3 data source, Bedrock uses customer-provided permission metadata to filter documents before retrieval. Amazon S3 is AWS’s object storage service.
AWS’s S3 document permissions documentation states that this configuration does not support real-time ACL verification. Permission changes require synchronization and relevant reindexing. That makes freshness a separate consideration from authenticated identity.
The same documentation says documents lacking associated ACL entries are not ingested when ACL awareness is enabled. It also warns that ACL problems can silently omit affected documents. A missing result therefore does not automatically indicate poor search relevance.
These behaviors create different operational risks. An outdated permission can preserve access longer than the data owner expects. An incorrect identity match can prevent an authorized employee from retrieving needed information.
Teams should avoid combining those problems into a generic search-quality metric. A relevance issue asks whether the system found the right information. A permission issue asks whether the system considered the right information eligible.
Consider an illustrative employee transfer between departments. Authentication can continue to work normally while the employee’s document access changes. The organization needs to know when the retrieval system reflects that change.
The timing question is practical rather than theoretical. Security teams need an understood interval between a permission change and its observable effect. Application owners need to communicate behavior during that interval.
Mixed-source deployments require additional care. The supplied source facts distinguish ACL-enabled sources from sources without ACL filtering. Teams should assess each source’s configuration rather than assume a knowledge-base-wide permission guarantee.
That distinction matters when a previously restricted assistant gains another content source. Existing identity checks do not automatically establish that the new source carries equivalent document permissions. Source onboarding is therefore also a security change.
Email-based identity matching introduces another maintenance question. A trusted token can carry a verified address while the organization’s document metadata refers to an outdated address. Authentication and permission matching can disagree without either service reporting an authentication failure.
The appropriate response is lifecycle testing. Address changes, user departures, departmental moves, and restored accounts should be evaluated as retrieval scenarios. Testing only newly created users leaves those transitions unexplored.
The scope of the reference design also limits broader security claims. Preventing an agent from selecting another user’s identity addresses a particular path to unauthorized retrieval. It does not establish protection against every malicious instruction embedded in retrieved content.
An employee might have legitimate access to a document containing misleading or hostile text. Identity enforcement determines whether retrieval is allowed. It does not determine whether the document’s instructions should influence later actions.
That is why Amazon Bedrock access control should remain distinct from overall agent safety. Permission enforcement, content handling, and downstream action controls answer related but separate questions. Success in one area should not substitute for evidence in another.
The skeptical conclusion is specific: the architecture supplies a useful boundary, but its effectiveness depends on identity accuracy, permission freshness, and controlled access paths. Those dependencies remain operational responsibilities.
The next evidence should come from failure tests
The most useful next signal is whether deployments preserve the boundary when individual assumptions stop holding.
Over the next several months, the first signal to watch is published verification of identity-mismatch handling. Relevant evidence would show the authenticated identity, the attempted conflicting value, and the resulting retrieval decision.
The strongest tests would distinguish the injection path from the policy check. If a deployment rejects mismatches even when injection is absent or faulty, that supports the defense-in-depth argument. Ordinary successful searches provide less information about that claim.
Testing should also distinguish a model’s refusal from infrastructure enforcement. If a model declines to generate the conflicting argument, the downstream control has not necessarily been exercised. A controlled request can test the boundary more directly.
The second signal is measured permission-change behavior. Organizations should look for evidence showing when a changed document permission becomes effective in retrieval. Results should identify the connector and configuration involved.
A documented, repeatable synchronization interval would help buyers judge whether the pattern fits their operational needs. Unexplained variation would weaken confidence in permission revocation expectations. Neither outcome should be generalized beyond the tested source.
Positive and negative results both matter. A user who loses permission should stop receiving the document. A user who gains permission should eventually receive eligible results, so protective filtering does not become an invisible availability problem.
The third signal is verification of alternate access paths. Evidence should cover direct backend requests and other services that can contact the knowledge base. A gateway-only test cannot establish that those routes are closed.
If alternate callers are denied as intended, the deployment supports its claim that retrieval must pass through the protected route. If exceptions exist, their controls should become part of the assessment. An exception with its own verified identity handling differs from an unrestricted bypass.
These are evaluation signals, rather than predictions about unannounced AWS releases. The November reference design supplies a concrete architecture to examine. It does not supply a timetable for independent enterprise validation.
For buyers, the resulting standard is more useful than a generic promise of secure enterprise search. Ask vendors to show how the user identity is established, which component can change it, and what rejects inconsistencies. Then ask how source permissions change over time.
For developers, the lesson extends to tool design. Separate task inputs from authority-bearing inputs before exposing backend operations to a model. Keep the reasoning component flexible where flexibility helps, and make permission boundaries explicit where mistakes disclose information.
Before adopting Amazon Bedrock access control for a shared assistant, choose a restricted document and an employee who cannot read it. Trace the attempted retrieval through authentication, identity injection, policy evaluation, and backend access. Repeat the exercise after changing permissions and through an alternate caller. Include an authorized user to verify that the same controls still permit legitimate work. Record what each test establishes and which assumptions remain outside its scope. Use those results to decide whether the deployment meets your organization’s access requirements. The useful next step is to examine the enforced request and returned evidence, then resolve every unexplained difference before expanding the assistant’s reach.



