Making AI Agents Remember: Amazon Bedrock Agent Core Memory

AO Labs Editorial Note: Members of the AO Labs team attended AWS re:Invent this year and spent time in breakout sessions and vendor conversations focused on agentic systems and long-lived AI applications. We’re sharing this summary of a breakout session on Amazon Bedrock Agent Core Memory. This session stood out because it reflects a pattern we’ve been seeing: as AI agents start handling more complex use cases and interactions, persistent memory and context matter more than they have in the past. Bedrock Agent Core Memory offers a low-lift solution for the “bot with a memory” use case.

We’ve all experienced that awkward party moment—having a great conversation with someone, only to forget their name moments later. Now imagine if your AI agents did the same thing to your users. That’s exactly the problem Amazon is solving with Bedrock Agent Core Memory, as demonstrated in a recent presentation by Mani Kanuja (AWS Principal Solutions Architect) and Jay Lopez-braus (Product Manager), with insights from Imran Shah of Experian.

The Memory Gap in AI Agents

Most AI agents today suffer from a critical limitation: they lack meaningful memory. As the slide above illustrates, agents have access to system prompts, documents, tools, instructions, and message history – but memory is often the overlooked component. Without it, agents miss opportunities for learning and personalization.

While agents can access tools, APIs, and knowledge bases, they constantly forget user preferences, past interactions, and learned behaviors. This forces users to repeat instructions with every session—hardly the seamless experience customers expect.

The presentation illustrated this perfectly with a slide deck creation agent. The basic version required detailed instructions every time: use this color scheme, include AI ethics considerations, apply this particular font. With memory enabled, the agent simply remembered these preferences after the first few interactions.

How Agent Core Memory Works

Amazon designed the system to mirror human memory:

Short-term memory retains raw conversation history (7 days to 1 year), allowing agents to maintain context within sessions. It even supports “branching” for parallel tasks—imagine asking an agent to simultaneously create three different presentation variations.

Long-term memory extracts and persists key insights across sessions using three built-in strategies:

• Summary: Condenses interactions into digestible highlights
• User preferences: Captures individual likes, dislikes, and patterns
• Semantic: Stores factual information for meaning-based retrieval

The architecture diagram above shows how this works in practice. The demo implementation uses three layers:

1. User Interface Layer: Flask web app for interactive UI and a CLI interface for command-line demos
2. Agent Layer: Both a basic agent (no memory) and a memory-enabled agent built with the Strands Framework
3. Memory System: Includes Memory Hooks for retrieving and saving preferences, a Memory Session Manager for user-specific sessions, and Memory Config for customizing the extraction strategy

The system handles the heavy lifting automatically—consolidating duplicate preferences, managing storage, and providing enterprise-grade security. The workflow follows four key steps: retrieve search preferences, inject them into the prompt, let the agent process them, and save new preferences for future sessions.

Real-World Impact: Experian’s Journey

Imran Shah shared how Experian evolved from fragmented, product-specific memory implementations to a unified architecture using Agent Core Memory. Their previous approach—mixing managed services like OpenAI’s thread-level memory with custom frameworks—created user frustration and didn’t scale.

The results after adopting Agent Core Memory:

• Simplified architecture: Eliminated custom ETL pipelines and multiple storage systems
• Faster time to value: Engineers focus on agents, not infrastructure
• Enhanced compliance: Built-in memory governance for GDPR and CCPA requirements
• Cross-product continuity: Memories persist across different agents and products

Practical Applications Beyond Presentations

While the demo focused on content creation, the implications extend much further:

Coding assistants could remember your preferred languages, coding style, and that crucial instruction: “make changes using minimal lines of code, don’t create unnecessary files.”

Customer support agents could recall past issues, understand recurring problems, and provide personalized help based on customer history—showing you actually care about the user experience.

Personal assistants could learn dietary preferences, working habits, and communication styles over time without constant reminders.

The Bottom Line

Building a robust memory system from scratch—managing dual storage systems, implementing consolidation logic, ensuring security, and adding observability—represents significant engineering overhead. Amazon Bedrock Agent Core Memory eliminates this burden, allowing teams to integrate sophisticated memory capabilities with just a few API calls.

As Mani emphasized: this isn’t just about accuracy and relevance (though those are essential). It’s about creating AI experiences that feel genuinely personalized and intelligent—agents that remember you, understand you, and improve with every interaction.

The code from the demo is available in AWS’s agent-core-samples GitHub repository. For those building agentic applications, the message is clear: memory isn’t optional anymore—it’s the difference between a tool that works and an experience that delights.