Amazon OpenSearch Memory Stores What an Agent Learned and Hands It Back
"Amazon OpenSearch Memory became generally available on 18 November 2026. It keeps agent events verbatim, derives memories with a Bedrock model, and published a LongMemEval comparison that t
TL;DR
- Amazon OpenSearch Memory is a managed service that stores the conversations and data an AI agent works with, extracts the facts, preferences and summaries worth keeping, and returns them as searchable memories across sessions.
- AWS announced general availability on 18 November 2026, built on Amazon OpenSearch Serverless, in US East (N. Virginia), US West (Oregon), Europe (Frankfurt) and Asia Pacific (Tokyo).
- A space holds the events an application writes and the memories derived from them; an actor names the end user the data belongs to, and the
osm:actorIdIAM condition key can confine an agent to named actors. - Events are stored verbatim and become searchable within seconds, while extraction runs in the background with a Bedrock model that defaults to Claude Haiku 5.5 and can be changed per space.
- On LongMemEval-S the configured workflow answered 93.0% of questions with about 13,500 input tokens, against 95.2% with about 167,000 tokens for the full conversation history and 88.6% for keyword search over raw turns.
- The published comparison comes from one run per configuration with a 95% confidence range of two to three points, so the 2.2-point gap to full history sits inside the reported band.
- A space keeps events for 1 to 365 days and memories from 1 day to never, supports up to 10 extraction strategies, encrypts with a KMS key you can supply, and logs API calls to CloudTrail.

Passing an entire conversation to a model works until the conversation outgrows the context window or the bill. AWS's answer, generally available since 18 November 2026, is to make memory a service with an API: the application writes each turn, the service decides what deserves to persist, and the next session retrieves a short list of what mattered. The interesting part for a team building a support agent is what the service commits to keeping, and what remains its own responsibility.

A space holds events and the memories derived from them
The resource is a space, and it plays the role a database plays for an application: one store with its own endpoint, its own strategies and its own retention. Your code calls CreateEvent after each turn, the payload carries the messages, and the call returns once the event is stored. The event is kept verbatim, indexed for keyword, semantic and hybrid search, and readable immediately.
Extraction happens afterwards. The strategies configured on the space read the stored events in the background and derive memories from them: facts, preferences and session summaries in the shipped strategy set, with up to 10 strategies per space, each reading the same event stream. Consolidation is the step that keeps a memory store from turning into a pile of contradictions, and the service handles it by comparing each new memory against the existing ones and adding, updating or skipping it.
What the LongMemEval comparison measured
AWS evaluated the whole workflow, which is the right unit for a buying decision. The benchmark is LongMemEval-S: 500 questions about information spread across roughly 50 chat sessions for one user, drawn from published work by Wu and co-authors at ICLR 2025. Conversations went in as events, the space's default fact and summary strategies derived memories, and each question retrieved the top 30 memories and events from hybrid search.

Claude Opus 5.5 answered every question and graded each answer in a separate call against the reference, with Claude Haiku 5.5 extracting memories and Amazon Titan Text Embeddings producing the vectors. The result table compares three ways of filling the prompt: managed memory at 93.0% accuracy with about 13,500 input tokens per question, BM25 over raw conversation turns at 88.6% with about 22,700, and the full conversation history at 95.2% with about 167,000.
Read it as a trade with a known price. Managed memory gave up 2.2 points of accuracy against the full history and used about one twelfth of the input tokens, and it beat keyword retrieval over raw turns by 4.4 points at roughly 60% of the tokens. For a long-running assistant, that is a strong exchange; for a task where the exact earlier turn carries the answer, the full history still wins.

Where the confidence range sits
The post states one run per configuration and a 95% confidence range of two to three points either way, and it says plainly that the results reflect the tested setup with its strategies, models and retrieval settings. Applied honestly, that band covers the entire gap between managed memory and full history.
The useful signal therefore sits in the token count, which is measured, and in the comparison to keyword retrieval, which is a 4.4-point margin. The tiebreaker argument for managed memory is cost and context headroom, and the accuracy case for it against full history is weaker than a headline number suggests.
Retention, keys and the actor boundary
Retention is configured per space: events live between 1 and 365 days, memories from 1 day to never expiring, and the write-up shows a worked example with 90 days for events and 365 for memories. Data is encrypted with AWS KMS, and a customer managed key can be supplied, with one documented constraint that the key is set at space creation.
The actor is the more consequential field. Every request names the end user the data belongs to, an optional session ID groups the events of one conversation, and reads and searches can be limited to a single session. The osm:actorId condition key on the agent's IAM role limits which actors that role may act for, so the isolation between two customers rests on a policy.

Four Regions and an extraction model you inherit
The service runs in four Regions: US East (N. Virginia), US West (Oregon), Europe (Frankfurt) and Asia Pacific (Tokyo). Frankfurt covers a European deployment; a requirement to keep everything inside France has no answer here today, which is a real constraint for public-sector and regulated work.
The extraction model is the second commitment. Each space runs one, defaulting to Claude Haiku 5.5 and configurable through extractionModelId, and extraction and embedding costs are included in the service price. Memory quality therefore inherits a model choice that a large language model makes about your transcripts, and changing it later re-derives from the same event log.
What to test before a support agent remembers anyone
Start with a retention and deletion decision, because the 1-to-365-day window on events and the memory expiry are the two dials that determine whether a customer's data disappears when a case closes. Map actors to your own user identifiers before the first write, since a wrong mapping followed by a KMS-protected store is a data-removal conversation nobody enjoys.

Then measure on your own transcripts. The LongMemEval setup is public and reproducible, and the same protocol against a sample of real cases answers the only question that matters: does retrieval from memories answer your users as well as the last three turns of a transcript.
A team that already runs a private AI assistant for your documents over its own corpus will recognise the second half of this work, which is deciding what deserves to persist and who may read it. OpenSearch Memory moves the machinery into a managed service and leaves that editorial question exactly where it was.
Sources
- Introducing Amazon OpenSearch Memory: Persistent memory for AI agents — AWS Big Data Blog, 18 November 2026
- Amazon OpenSearch Memory is now generally available — AWS What's New, 18 November 2026
- What is Amazon OpenSearch Memory? — Amazon OpenSearch Service Developer Guide
Source: "Introducing Amazon OpenSearch Memory: Persistent memory for AI agents" — aws.amazon.com/blogs/big-data, 2026-11-18, https://aws.amazon.com/blogs/big-data/introducing-amazon-opensearch-memory-persistent-memory-for-ai-agents/, with the AWS What's New entry at https://aws.amazon.com/about-aws/whats-new/2026/11/amazon-opensearch-memory-generally-available/ and the OpenSearch Service Developer Guide page at https://docs.aws.amazon.com/opensearch-service/latest/developerguide/memory.html; all fetched and saved on 2026-11-19 under sources/2026-11-20/amazon-opensearch-memory-persistent-agent-memory/.