Key details

  1. AgentCore Memory fine-grained access control launched August 28, 2026.
  2. The control uses AgentCore Gateway with OAuth/JWT authentication and Cedar authorization policies.
  3. Policies can enforce per-user and per-tenant actor access, namespace restrictions and operation-level permissions.
  4. The managed Memory connector exposes 12 Memory operations as Cedar actions.
  5. Flexible namespace variables also launched August 28.
  6. A Memory resource can define up to five custom namespace keys, such as organization, tenant, team or environment.
  7. Runtime values can be substituted into long-term-memory namespace templates and reused across multiple strategies.
  8. AWS says flexible namespace variables are available in all AgentCore Memory GA regions at no additional cost.

What builders should take away

  1. For multi-tenant agents, move Memory authorization from ad-hoc actor-ID checks toward a gateway policy tied to authenticated user claims.
  2. Design token claims and namespace templates together so the tenant boundary comes from a trusted identity source instead of arbitrary request input.
  3. Write Cedar policies that constrain both the caller’s allowed operations and the actor/namespace they may address.
  4. Test cross-tenant negative cases deliberately: attempt retrieval, writes and deletes using another tenant’s actor and namespace values.
  5. Keep IAM controls for service-to-service/AWS-principal boundaries; OAuth FGAC addresses a different end-user identity problem.
  6. Do not treat Memory FGAC as whole-agent authorization — secure tools, databases and other data planes independently.

What changed

AWS shipped two complementary Amazon Bedrock AgentCore Memory controls on August 28, 2026. Fine-grained access control lets a Memory resource sit behind AgentCore Gateway with OAuth/JWT authentication and Cedar policies that authorize Memory operations based on the authenticated caller. Policies can enforce per-user or per-tenant actor access, restrict records to namespaces derived from token claims, and allow or deny individual Memory actions. Separately, flexible namespace variables let developers define up to five application-specific keys on a Memory resource — such as organization, tenant, team or environment — and substitute runtime values into long-term-memory namespace templates. AWS says the namespace feature is available in every region where AgentCore Memory is generally available with no additional charge.

Why it matters

Persistent agent memory is a data-isolation problem as much as a retrieval feature. Without a trustworthy boundary, one user or tenant can potentially retrieve another tenant’s remembered context through an application bug or overly broad server credential. AgentCore’s new controls let builders bind memory access to the caller’s cryptographically verified OAuth identity and express the boundary in infrastructure policy, rather than trusting every application path to manually filter actor IDs. Flexible namespace variables then make that policy usable for real multi-tenant hierarchies instead of forcing everything into built-in actor/session dimensions.

OAuth identity can now drive Memory authorization

AgentCore Gateway can authenticate callers with OAuth/JWT and expose the identity to Cedar policy. AWS says the Memory connector maps 12 Memory operations to Cedar actions and makes request attributes available for policy conditions. A policy can therefore require that an authenticated user only reaches their own actor data or only a namespace derived from claims in their token.

This closes a gap left by IAM-only controls

AgentCore Memory already supported IAM policies for actions, resources, actors, sessions and namespaces. AWS’s documentation notes that IAM evaluates an AWS principal, not the end user represented by an OAuth token. The new gateway path is intended for applications where users authenticate through an OpenID Connect provider and memory authorization needs to follow that end-user identity.

Namespaces can follow real tenant hierarchies

Flexible namespace variables let an application define as many as five keys on a Memory resource and reuse them across strategies. A developer can model dimensions such as organization, tenant, team or environment, supply their values at event-ingestion time and have AgentCore substitute them into the namespace used for extracted long-term memories.

Policy and namespace design now reinforce each other

The useful pattern is to derive namespace values from trusted application identity and then enforce access to those namespaces in policy. That gives retrieval and consolidation a stable partition while making unauthorized cross-tenant access fail at the gateway rather than only in application code. It does not remove the need to design actor, session and namespace semantics carefully.

The feature does not make an entire agent application tenant-safe by itself

These controls apply to AgentCore Memory access. Builders still need separate authorization for tools, databases, files, external APIs and any application paths that bypass the Memory gateway. JWT claims, Cedar policies and namespace templates also need testing because a permissive policy or incorrectly mapped claim can recreate the boundary problem at a different layer.

What to watch next

  • Whether AWS adds higher-level policy templates or managed defaults for common SaaS multi-tenancy patterns.
  • How AgentCore Memory pricing and latency change when traffic is routed through Gateway at scale.
  • Whether flexible namespace keys expand beyond five or gain stronger schema/claim-binding helpers.
  • Independent security testing of claim mapping and Cedar policy patterns for agent-memory isolation.
  • Integration examples for common identity providers and multi-account AgentCore deployments.

Still unclear

  • AWS documents the policy mechanics but does not provide an independent measurement of the latency or operational overhead added by Gateway authorization.
  • Correct isolation still depends on the application issuing trustworthy identity claims and on policies/templates being written correctly.
  • The no-additional-charge statement applies to the flexible namespace feature itself; normal AgentCore Memory, Gateway and related AWS usage charges can still apply.

Sources

Direct reading behind this dossier.

3 sources
Fine-grained access control for Memory
Amazon Bedrock AgentCore Developer Guide primary documentation

Technical documentation distinguishing OAuth end-user FGAC from IAM-principal controls and describing the gateway policy model.

Discussion

Discussion is reader-contributed. Comments are not part of the BTN dossier or its editorial evidence.

0 visible comments

Join the discussion

Keep comments useful and relevant. Reader contributions may be moderated and are not BTN editorial evidence.

Sign in to comment