Amazon Bedrock Adds Memory and Spreadsheet Analysis | Zeniteq
Loading
Zeniteq is now available on mobile for iPhone, iPad and Apple Watch.Download nowLearn more
Amazon Bedrock Adds Memory and Spreadsheet Analysis
Two November 16 updates bring user-specific memory and calculations over spreadsheet files into Bedrock’s agentic retrieval workflow, with distinct requirements for identity, access control and latency.
AWS recently upgraded Amazon Bedrock Managed Knowledge Base with AgentCore Memory and tabular search, both integrated into the AgenticRetrieveStream API. Memory configuration allows applications to restore session history and retrieve durable user facts, improving context for complex queries. Simultaneously, tabular search enables the agent to execute code on original CSV, XLSX, or XLS files, overcoming the limitations of traditional passage-based retrieval. These updates require developers to carefully manage identity scoping and resource alignment, as memory and document access controls must be architected separately to ensure secure, accurate RAG performance.
AWS announced two related updates to Amazon Bedrock Managed Knowledge Base on November 16, 2026: integration with AgentCore Memory and tabular search over CSV, XLSX and XLS files. Both use AgenticRetrieveStream, the API that lets a model plan searches, retrieve information and stream an answer.
The memory update lets an application restore conversations and retrieve durable facts about a user. The tabular search update lets the agent run calculations over original spreadsheet files, then combine those results with information from related documents.
The architectural change is significant for retrieval-augmented generation, or RAG. A question can now draw on three different sources: the current conversation, remembered user context and organizational files. Those sources have different trust boundaries. Memory helps interpret a question; document access controls determine what the user may read; spreadsheet code computes an answer from the files retrieval finds.
One Retrieval API, Two Different Extensions
Agentic retrieval already breaks complex questions into sub-queries, searches configured sources and checks whether the results are sufficient. According to the Bedrock user guide, it supports fully managed knowledge bases and requires model access and the necessary IAM permissions.
The new capabilities extend different parts of that process:
Capability
How it enters the workflow
What it contributes
Important boundary
AgentCore Memory
An optional memoryConfiguration in the request
Session history and relevant long-term facts
Memory must be active, in the same AWS account and correctly scoped
Tabular search
Automatically used when retrieved table files and the question call for it
Lookups and calculations over original files
Retrieval still has to find the right file
Document retrieval
Knowledge base retrievers, with optional userContext for access filtering
Document ACLs remain separate from memory isolation
Memory integration is opt-in and backward compatible. Tabular search has no separate switch: AWS says it is part of agentic retrieval when a question needs supported table data. The ordinary Retrieve API continues to return passages without running code.
That distinction matters during migration. Adding memory requires request configuration and identity design. Using tabular search requires the agentic API and suitable files, but no separate table-analysis API call.
Memory Configuration Separates Session History From Durable Facts
memoryConfiguration supports two related functions.
Short-term memory restores the history of a particular conversation. A sessionBinding identifies the actor and session whose previous exchanges should become context for the current request.
Long-term memory supplies facts extracted from earlier conversations. The request’s retrievalConfigs configure long-term memory retrieval, allowing the planner to use remembered information when forming searches. An application can configure session continuity, long-term retrieval or both.
AWS describes AgentCore Memory as a retrieval source alongside the knowledge base. The service can retrieve configured long-term facts through speculative retrieval or searches selected by the planner. After generating an answer, it can save the exchange back to memory. With a session binding and persistenceMode set to DEFAULT, Bedrock persists the question and generated answer. These behaviors are documented in the user guide.
Consider an employee asking about an internal policy. A remembered fact about their role or location could help the planner compose a more specific knowledge base query, even if the employee mentioned that fact in an earlier session. The policy document still provides the grounding for the answer.
My view is that this separation is the useful part of the update. Replaying a conversation and retrieving a durable fact solve different problems. Builders should decide whether a feature needs immediate conversational continuity, cross-session personalization or both before configuring memory.
Same-Account Memory and Actor Scoping Shape the Design
AWS requires the AgentCore Memory resource to be active and in the same AWS account as the knowledge base. Session restoration also needs actor and session identifiers. Those prerequisites affect deployment topology and user isolation, not merely request validation.
For a multi-user application, the practical requirements are:
Check resource readiness. The memory resource must be active before the application uses it.
Keep the account boundary aligned. This integration cannot directly pair a knowledge base with a memory resource in another AWS account.
Use a stable actor identity. The actor identifies whose memory is being accessed, including across sessions.
Use a session identity for each conversation. This selects the short-term history to restore.
Scope long-term retrieval. Memory namespaces and retrieval configuration should select the intended user’s records.
Enforce document permissions separately.userContext supplies the identity used for knowledge base access filtering.
AWS’s sample application shares one knowledge base and one memory resource among employees. It validates a Cognito token, uses the token’s sub claim for the memory actor and uses the verified email for userContext.userId, matching the document ACL identity.
The following JSON fragment illustrates that identity pairing. It is not a complete API request: it omits the required query, retriever and planning configuration, as well as retrievalConfigs for long-term memory searches.
The placeholders represent values supplied by the authenticated application. Email is the ACL identity in AWS’s example, not a universal requirement for every application.
The sample also assumes an IAM role with a userId=<sub> session tag and uses IAM to enforce per-user memory isolation. That is an important additional boundary: an actor ID in application code should not be treated as the entire security design.
I’d keep identity construction on the server, as AWS’s example does. Letting a client choose its own actor or document-access identity would undermine the separation these fields are meant to provide.
A conventional RAG search returns a limited set of matching passages. That works well for locating prose, but an aggregate over a spreadsheet may require rows that never appear in those passages.
Long tables span many passages, so retrieval may return only a small subset of rows.
Wide tables can exceed passage or search-model limits, making later columns harder to match and producing passages that overlap many unrelated questions.
Tabular search separates finding a file from calculating over it. Retrieval needs to locate a passage from the relevant table file; code then reads the original file.
Retrieve: Fetch passages, including passages from table files.
Plan: Decide whether the question requires code over one or more tables.
Stage: Copy the original file into an isolated sandbox with no network access.
Compute: Run model-written code over the whole table or sheet.
Return: Give the agent the code’s printed output, such as totals or matching rows.
Answer: Combine those results with retrieved passages to produce a cited response.
Supported file types are CSV, XLSX and XLS. AWS says the feature works across connectors that bring those files into the knowledge base, including Amazon S3, Microsoft SharePoint and Atlassian Confluence.
Whole-File Computation Still Depends on Finding the Right File
AWS’s finance example asks which departments must write variance commentary. The answer requires a policy threshold, revised budgets from a quarter-close memo and calculations over a profit-and-loss workbook.
Requirement
Passage retrieval alone
Agentic retrieval with tabular search
Find the commentary rule
Retrieve the relevant policy passage
Retrieve the relevant policy passage
Find budget revisions
Retrieve the close memo
Retrieve the close memo
Calculate revised variances
Retrieved passages may omit necessary rows; the result may not exist in any file
Code calculates over the original workbook
Explain the answer
Return supporting passages
Combine computed results with documentary evidence
This is AWS’s published example, not an independent comparison test.
The consequential limit is upstream of the sandbox: the agent still has to retrieve the correct workbook. AWS explicitly notes that draft and final workbooks can look similar to search and recommends naming the file in the question.
Whole-file computation can address incomplete row coverage after retrieval. It cannot automatically correct a file-selection mistake. For a builder, that makes file naming, version clarity and query specificity practical parts of answer quality.
The evidence trail also has two layers. In AWS’s example, answer citations identify the policy and memo, while the trace names the workbook read by the code. An application evaluating an analytical answer should inspect both the supporting documents and the computation trace.
Combining Memory and Tables Changes the RAG Pipeline
Both updates sit within AgenticRetrieveStream, so an application can configure memory while asking a question that triggers tabular analysis.
A plausible workflow, derived from the documented capabilities, looks like this:
The application validates the user and supplies document-access context and scoped memory configuration.
Bedrock restores the current session’s history.
The planner uses relevant remembered facts to make the question more specific.
Knowledge base retrieval finds permitted policy documents and spreadsheet files.
Tabular search computes the required values from the retrieved original files.
Bedrock streams the answer and trace events, then persists the exchange when configured.
This consolidates orchestration that an application might otherwise implement through separate history storage, memory lookup and spreadsheet-analysis steps. The application still owns authentication and correct identity mapping.
I’d treat remembered facts as context for choosing a search, while keeping document permissions tied to verified identity. A remembered role and an authorized role are different things. AWS’s separate memory and userContext fields give builders the structure to preserve that distinction.
Extra Agent Turns and Reporting Controls Remain Trade-Offs
Tabular analysis adds at least one agent turn compared with text-only retrieval, according to AWS. Staging a file, executing code and returning results therefore make these answers slower than answers that use only text retrieval.
AWS provides no independent production benchmarks for accuracy, latency or cost across representative workloads. There is no supported millisecond estimate or per-question cost comparison here; the defensible expectation is additional work and latency, with the size dependent on the workload.
The sandbox’s lack of network access constrains execution, but it does not validate the model’s calculation logic. Similarly, citations and traces help inspect an answer without turning it into a governed financial report.
AWS explicitly reserves governed metrics, recurring dashboards, warehouse-scale joins and reporting controls for business intelligence tools. I’d follow that boundary: tabular search fits an ad hoc question spanning a workbook and nearby policy documents. A recurring metric with a formal definition belongs in a controlled reporting system.
Frequently Asked Questions
4 questions
1
Which Spreadsheet Formats Are Supported?
AWS lists CSV, XLSX and XLS. Tabular analysis runs through AgenticRetrieveStream; the ordinary Retrieve API returns passages without executing code.
2
What Does AgentCore Memory Require?
The memory resource must be active and in the same AWS account as the knowledge base. Session continuity needs actor and session identifiers, while long-term memory searches use retrievalConfigs.
3
Does Memory Replace Document Access Controls?
No. Memory scoping isolates remembered context. Knowledge base document permissions use userContext and ACL filtering, while IAM can provide an additional memory-isolation boundary.
4
Should Tabular Search Replace BI Reporting?
AWS recommends BI tools for governed metrics, recurring dashboards, warehouse-scale joins and reporting controls. Tabular search is aimed at calculations and lookups over table files retrieved alongside documents.