When building and testing multiple AI agent frameworks with Amazon Bedrock AgentCore, I realized I needed a tool to visualize and explore what my agents were actually remembering. AgentCore Memory provides powerful capabilities for managing both short-term conversation context and long-term knowledge extraction, but debugging memory patterns meant diving into AWS CLI commands or writing custom scripts just to see what was stored. I needed a way to quickly browse, search, and understand the memory patterns my agents were creating.
That's why I built AgentCore Memory Browser: a web interface that makes it simple to explore and interact with Amazon Bedrock AgentCore Memory resources. Whether you're debugging an agent's memory extraction or simply curious about what your agents are learning over time, this tool provides the visibility you need.
In this post, I'll walk you through the AgentCore Memory Browser's capabilities, show you how to set it up in minutes, and demonstrate how it can accelerate your agent development workflow. This tool complements the multi-framework journey I've been documenting in my main AgentCore blog series, providing essential visibility for any agent implementation.
Why Build a Memory Browser?
Working with AI agents in production requires understanding not just what they say, but what they remember. Amazon Bedrock AgentCore Memory provides sophisticated memory management with multiple strategies for extracting and storing different types of information. AgentCore Memory can capture user preferences and settings, store factual information extracted from conversations, create condensed summaries of sessions, and maintain the raw conversation history for context.
When an agent isn't behaving as expected, or when you want to understand its memory patterns, you need visibility into these memory stores. The AWS CLI provides the raw capability, but switching between terminal commands while developing breaks your flow. I needed something more intuitive—a tool that could show me at a glance what each memory strategy was storing, let me search through records, and help me understand how my agents were using memory across different sessions and actors.
Key Features That Accelerate Development
The AgentCore Memory Browser provides real-time exploration of all your AgentCore Memory resources with live data pulled directly from both control plane and data plane APIs. You can see memory status, configurations, and strategies at a glance.
Each memory strategy gets its own dedicated interface with operations tailored to its purpose. Whether you're working with user preferences, semantic facts, or session summaries, the browser adapts to show relevant operations and namespace patterns. AgentCore Memory uses namespace templates with placeholders, and when a strategy defines a namespace that contains a {memoryStrategyId}, the browser automatically fills in the strategy ID portion while keeping the field editable so that you can substitute the actor and session values. This makes it easy to explore specific user or session data without having to type the full namespace path each time.
The browser provides three core operations for each strategy. You can list events to view the sequence of events for specific sessions and actors, helping you understand the temporal flow of your agent's interactions. You can browse all memory records in a namespace with pagination support for large datasets. And you can retrieve memory using natural language queries, taking advantage of AgentCore's semantic search capabilities.
The developer-friendly UI includes quick copy buttons for Memory IDs, ARNs, and namespace values, saving you from manual selection and copying. The auto-expanding JSON viewer with syntax highlighting makes it easy to inspect complex memory structures. The browser remembers your namespace edits during a session, so you don't have to re-enter actor and session IDs repeatedly. And all user content is HTML-escaped to prevent injection attacks, ensuring security even when browsing untrusted memory content.
Installation in Under a Minute
To get started quickly, I've packaged the AgentCore Memory Browser as a Python tool that can be installed globally using uv, the fast Python package manager.
Before installation, ensure you have Python 3.13 or higher and AWS CLI configured with appropriate credentials. You'll need AWS IAM permissions for bedrock-agentcore-control:ListMemories and GetMemory operations, as well as bedrock-agentcore:ListEvents, ListMemoryRecords, and RetrieveMemoryRecords.
You can install directly from GitHub with a single command:
uv tool install git+https://github.com/danilop/agentcore-memory-browser.git
Then run it from anywhere:
agentcore-memory-browser
The application automatically opens in your default browser at http://localhost:8000 (you can pass a different port on the command line).
If you want to modify the tool or contribute to development, you can clone the repository, install dependencies with uv sync, and run the application with uv run agentcore-memory-browser.
Architecture: Clean Separation of Concerns
The AgentCore Memory Browser follows a clean, modular architecture. The backend is built with FastAPI, providing a modern, async-capable web framework. It uses two AWS service clients: the AgentCore control plane to list and describe memory resources, and the data plane to perform operations like listing events, browsing records, and executing semantic searches.
The frontend uses Bootstrap for responsive design and vanilla JavaScript for interactivity—no complex build process required. The interface is organized with a sidebar for memory selection with metadata preview, main content with a tabbed interface for each memory strategy, operation panels with dedicated forms for each memory operation, and a results display with a JSON tree viewer with syntax highlighting.
Real-World Usage Patterns
After using the Memory Browser while developing agents, certain patterns have proven most valuable in my workflow to debug memory extraction as events are processed by strategies, understand how an agent's knowledge evolves over time, and optimizing semantic emory searches.
Best Practices
After extensive use, certain practices have emerged as particularly helpful. First, configure your AWS environment properly by setting your default AWS Region and verifying credentials with aws sts get-caller-identity. This ensures the browser can connect to your AgentCore Memory resources without issues.
Also, making good use of the copy buttons saves time when you need to reference memory IDs or ARNs in your code.
What makes AgentCore Memory particularly useful is how it simplifies handling both short-term and long-term memory for AI agents. Short-term memory captures the immediate context of conversations, while long-term memory extracts and preserves important facts, preferences, and patterns that persist across sessions. The Memory Browser gives you a window into both, helping you understand how your agents build knowledge over time and how they use that knowledge to provide more personalized and contextually aware responses. This visibility helps building agents that can maintain coherent and efficient results while learning and adapting from their interactions.
Top comments (2)
Amazing!
This is really useful. I had considered building something similar to get better insight into the actual back and forth between agents and their memories