Amazon Bedrock’s Agentic Retrieve Adds Memory to Managed Knowledge Bases
AWS says AgenticRetrieveStream can now restore sessions, let the planner query AgentCore memory, persist turns, and keep document ACLs intact. Here is what changes for multi-user support and document-chat agents.

Amazon Bedrock Managed Knowledge Base is absorbing one of the messiest parts of production document agents: the conversation store. In a Nov. 16 AWS Machine Learning Blog post, AWS says developers can add a memoryConfiguration to AgenticRetrieveStream so the same call restores the session, lets the planner decide when a user-specific memory would help, retrieves that memory through AgentCore memory, returns ACL-filtered documents with citations, and saves the turn back to memory. The integration is described as opt-in and backward compatible; the application still authenticates the user and passes identity claims, while the service takes over session restore, memory search, persistence, ingestion, ACL filtering, indexing, ranking, planning, retrieval, and generation. Source: AWS primary post.
That matters because the failure mode is familiar. A user asks, “How do I set up the VPN?” and mentions a Mac in Frankfurt; weeks later they ask about PTO, and the correct answer depends on the office they never restated. AWS’s example has Maya ask about VPN setup, then ask a follow-up where “it” means the VPN, then start a new conversation and ask about PTO. The trace shows speculative retrieval finding a prior conversation summary, and the planner turning that into a Frankfurt-specific PTO answer. A different user, Liam, gets the generic office table and a request for his location. Same handler, same memory resource, different token claims; the difference is identity and isolation, not model cleverness.
The API shape is the important part. With sessionBinding, messages carries only the current question. The service restores short-term memory for the actor and session, retrieves from the knowledge base using userContext, can retrieve configured long-term memory through speculative retrieval or planner-selected memory searches, streams the answer and trace, and persists the question and generated answer when persistenceMode is DEFAULT. A minimal request now looks conceptually like this:
{
"messages": [{"role": "user", "content": {"text": "How many PTO days do I get?"}}],
"retrievers": [{"configuration": {"knowledgeBase": {"knowledgeBaseId": "KB_ID"}}}],
"userContext": {"userId": "maya@example.com"},
"generateResponse": true,
"memoryConfiguration": {
"memoryId": "MEMORY_ID",
"sessionBinding": {"actorId": "cognito-sub", "sessionId": "conv-..."},
"persistenceMode": "DEFAULT",
"retrievalConfigs": [{"namespacePath": "/anycompany/cognito-sub"}]
}
}
AWS is explicit that identity must come from the verified ID token, not the client body. The knowledge base uses the verified email for document ACLs because that is what sources such as S3 ACL files, SharePoint, Google Drive, or Confluence connectors record. Memory uses the Cognito sub as actorId, because an email can be reassigned after someone leaves and must not inherit another person’s memory. The sample then assumes an IAM role per user with a userId session tag and conditions ListEvents, CreateEvent, ListSessions, RetrieveMemoryRecords, and ListMemoryRecords on that actor or namespace path. The post’s security point is blunt: ACL-aware retrieval is filtering, not authorization; if the email is mutable or unverified, document access can move with the address. That distinction is the difference between a helpful assistant and a quiet permission bug.
There are practical limits. The walkthrough uses a managed knowledge base and an AgentCore memory resource in us-west-2, requires the memory resource to be in the same AWS account and ACTIVE, and lists Python 3.10+ and Boto3 1.43.72+. Long-term extraction is asynchronous; AWS observed the first record appearing about 81 seconds after one turn, but says timing is not a commitment. Memory calls are best-effort: if memory is denied or unavailable, the trace records a FAILED memory event and the request continues from the knowledge base. Session restore adds roughly 200 ms, and AWS observed full turns at 4–10 seconds with one knowledge base, ACLs, and memory, driven by planning iterations rather than memory. Agentic retrieval is priced per call plus underlying retrievals, and memory operations during the call are billed as AgentCore memory usage.
The broader context explains why this is more than a convenience feature. In a separate AWS post on multi-agent design patterns, AWS frames agent reliability as a distributed-systems problem: ten steps that are each 95% reliable produce only 59.9% end-to-end reliability in its illustrative sequential model, and 20 steps produce 35.8%. The recommended default is to keep control flow deterministic until runtime flexibility is genuinely needed. Managed memory fits that same bias: stop hand-rolling state plumbing where the platform can enforce boundaries, and keep the application responsible for authentication, UI, and identity claims. Source: AWS multi-agent taxonomy.
Production evidence points the same way. Duco, a financial-data automation vendor, says it processes 20 billion transactions monthly for more than 200 clients, including seven of the top 20 banks and ten of the top 20 asset managers, on Amazon Bedrock and Bedrock AgentCore. Its post is not about memory retrieval, but it is about the adjacent constraint: per-tenant Cognito pools, dedicated AgentCore runtimes and gateways, identity passed through tool calls, and an MCP skills architecture that cut a 200,000-token tool-description context down to roughly 20,000 tokens. If unbounded or poorly isolated context breaks agents at that scale, a managed memory path that keeps citations, ACLs, and namespaces consistent is operationally meaningful. Source: Duco on AWS.
The audience is any team building shared support assistants, internal policy chat, SaaS document chat, or regulated knowledge workflows where users expect continuity but must not see each other’s documents. The change removes the conversation table, history replay, and extraction pipeline from the application, but it does not remove responsibility: use a stable immutable actorId, keep email verified and immutable for ACL mapping, resolve namespace paths fully, surface degraded memory state if the UI needs it, attach guardrails because memory is customer-owned input, and plan deletion with DeleteEvent and DeleteMemoryRecord. For operators already comparing managed Bedrock lanes, see our earlier coverage of AWS Bedrock coding-agent fleet routing.
Bottom line: this is not a new model and not a reason to multi-agent everything. It is a managed-state boundary. AWS is saying the retrieval stack can own memory too, provided the application treats identity as the security perimeter and designs for asynchronous, best-effort memory rather than pretending recall is instant.
Sources
- Build memory-aware AI agents with Agentic Retrieve on Amazon Bedrock Managed Knowledge Base | Artificial Intelligence
- Taxonomy of multi-agent design patterns, anti-patterns, and lessons from manufacturing | Artificial Intelligence
- How Duco transforms financial data automation with Amazon Bedrock AgentCore | Artificial Intelligence