Tech Insights
Amazon OpenSearch Memory Goes GA: What Persistent Agent Memory Changes
An AI agent that forgets every conversation is easy to build and frustrating to use. An agent that remembers everything can be just as awkward: it may retrieve stale preferences, mix two people’s data,…
An AI agent that forgets every conversation is easy to build and frustrating to use. An agent that remembers everything can be just as awkward: it may retrieve stale preferences, mix two people’s data, or carry irrelevant history into a sensitive request. AWS is now turning that tension into a managed cloud capability. On 18 November 2026, AWS announced the general availability of Amazon OpenSearch Memory, a serverless feature for giving AI agents persistent memory across sessions.
According to the AWS announcement, the service stores agent interactions as searchable events, derives structured memories, and retrieves relevant context later. It manages extraction, embedding, indexing, consolidation, and retrieval without requiring a team to assemble and operate each piece separately. The important story is not simply that an agent can “remember”; it is that memory becomes a managed data path with identity, retention, and access boundaries.
Why memory is harder than saving a transcript
A typical agent loop therefore has two paths. After a conversation turn, the application writes an event. Before the next answer, it searches for relevant memories and recent events, then adds the selected context to the model prompt. In between, a background process extracts facts and summaries, creates embeddings, and reconciles new memories with existing ones.
OpenSearch Memory packages that workflow as a service. The AWS technical documentation describes spaces as the memory stores, events as original interactions, and memories as derived facts, preferences, or summaries. That separation is useful because an operator may want to retain the source event for one period while retaining a derived memory for another.
A concrete example: support without replaying every ticket
Imagine a customer-support agent that handles a long-running device issue. In the first session, the customer explains the model, firmware version, network constraint, and a previous troubleshooting step. In a later session, the customer returns after a replacement part arrives. A transcript-only design has two poor choices: send the entire history to the model, or ask the customer to repeat the details.
With a memory workflow, the application can write each support turn as an event. A semantic strategy may extract the device facts and a summary strategy may preserve the progress of the case. When the customer returns, the application searches by the customer’s actor identity and retrieves the relevant memories and selected events. The model receives the context it needs without receiving every unrelated sentence from every prior interaction.
This does not make the support agent automatically correct. The extracted memory can be incomplete, the customer can change devices, and a summary can omit a qualification that matters. The application still needs to show provenance where appropriate and decide when fresh confirmation is required. Memory should reduce repetition, not silently replace the source of truth.
What “persistent” changes for agent architecture
Persistence changes the lifecycle of an agent. A stateless chatbot can treat each request as disposable. A persistent agent becomes a data system that accumulates information over time. That introduces useful capabilities but also creates design decisions around ownership, deletion, scope, and freshness.
AWS says OpenSearch Memory scopes events and memories by actor and session. IAM condition keys can limit which actors a role can access, and searches can be restricted to a session. The service also supports retention periods for events and memories. AWS’s documentation says events can be retained from one to 365 days, while memories can be retained from one day to ten years or indefinitely.
Those controls are more than administrative details. A personal assistant, a customer-support workflow, and a coding agent have different definitions of “remember this.” A preference may be useful for months. A temporary access token should not become a durable memory. A deployment decision may be useful to future operations but should remain tied to the correct project or repository. The memory model should be designed around the actor and the task, not around the maximum amount of data the service can store.
Search is deliberately hybrid
OpenSearch Memory supports keyword, semantic, and hybrid search. Keyword search is useful when an exact order number, error code, or repository name matters. Semantic search helps when the next request uses different wording from the original conversation. Hybrid search combines those strengths, but it also means retrieval quality depends on query construction, ranking, and the memory strategies configured for the space.
For example, a coding agent might need both an exact branch name and a semantic memory about the project’s preferred error-handling pattern. A pure vector search could miss the branch name; a pure keyword search could miss the design convention. A hybrid query can retrieve both, but the application should still set limits and inspect the resulting context rather than dumping every match into the prompt.
AWS’s benchmark shows the trade-off clearly
In the launch blog, AWS reports an evaluation using LongMemEval. Its configured OpenSearch Memory workflow supplied about 13,500 input tokens per question and achieved 93.0% answer accuracy. Supplying the full conversation history used about 167,000 tokens and achieved 95.2% accuracy. In the reported setup, memory reduced the context substantially while losing some accuracy. AWS also reported 88.6% accuracy for a BM25 raw-turn retrieval baseline.
Those figures are an illustration, not a universal performance promise. They come from one configured workflow and benchmark run. Production teams should measure retrieval precision, stale-memory rate, prompt size, latency, and how often users correct the agent.
Where the managed approach fits—and where it does not
OpenSearch Memory fits teams that want persistent agent context without operating a separate extraction and retrieval pipeline. AWS says the feature is serverless, with capacity scaling automatically, and that access is controlled through IAM. The service is available in US East (N. Virginia and Ohio), US West (Oregon), Europe (Frankfurt), and Asia Pacific (Tokyo), according to the announcement.
The trade-off is platform coupling. Applications adopting the service are choosing AWS APIs, IAM semantics, regional availability, and the service’s memory strategies. A team with an existing data platform, strict portability requirements, or highly specialized memory logic may prefer to keep more of the pipeline under its own control. A managed service can remove infrastructure work, but it does not remove the need for evaluation, data modeling, or lifecycle governance.
The best first use case is narrow and observable: one actor type, one workflow, a small set of memory strategies, and clear retention rules. Start by measuring whether the agent asks fewer repeated questions and retrieves more relevant context. Then test corrections, deletions, handoffs, and cross-session boundaries. Persistent memory becomes valuable when it makes an agent more useful without making its behavior less explainable.
Amazon OpenSearch Memory makes long-term agent context easier to assemble, but the hard design question remains human: what should an agent remember, for whom, for how long, and with what evidence? The teams that answer those questions first will get more from the service than teams that simply turn memory on and hope retrieval solves the rest.
This article is a general information summary based on the cited public sources. It is not legal, cybersecurity, or compliance advice.