AgentCore Memory’s Philosophy: Teaching Agents to Forget and Remember What Matters

Memory Philosophy

Most AI memory discussions focus on storing more, but the real problem is deciding what to keep, what to forget, and how to resolve conflicts when new and old information clash.

Two‑Layer Architecture

AgentCore Memory separates raw interactions (short‑term memory) from extracted insights (long‑term memory). Short‑term memory stores immutable events with timestamps, actorId and sessionId. Long‑term memory asynchronously extracts, consolidates and reflects on these events within 20‑40 seconds, returning results in roughly 200 ms via semantic search.

Strategy Levels

Built‑in : Fully automatic processing.

Built‑in with Overrides : Custom prompt and model on top of the built‑in flow.

Self‑managed : Complete control of the processing pipeline, allowing any model or external system integration.

Memory Types

Semantic (Facts) : Stores extracted factual information such as names, places, numbers.

User‑Preference : Captures user style and preferences, producing context, preference, and categories fields.

Summary : Real‑time compression of a single session without a separate extraction step.

Episodic (Reflection) : Identifies complete interaction episodes, consolidates them, and reflects across episodes to discover patterns.

Configuration Example (Python)

from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager
from strands import Agent

MEMORY_ID = 'memory_agentcore_demo_202602-NQQx1d71IZ'
AWS_REGION = 'us-east-1'

memory_config = AgentCoreMemoryConfig(
    memory_id=MEMORY_ID,
    session_id=session_id,
    actor_id=actor_id
)

session_manager = AgentCoreMemorySessionManager(
    agentcore_memory_config=memory_config,
    region_name=AWS_REGION
)

Integrating the AgentCoreMemorySessionManager into an Agent causes each user message to be written to short‑term memory and triggers a semantic search of long‑term memory for the current query.

Retrieval Settings

top_k limits the maximum number of returned records (e.g., 10 for facts). relevance_score sets the similarity threshold (0.3 is permissive, 0.7 is strict). namespace selects the memory partition, enabling selective retrieval of specific strategies.

Demo Scenarios

Scenario 1 – Cross‑session memory : A user says “budget $500” on day 1, “budget $800” on day 30, and “I love Python” on day 60. The system consolidates the budget change, keeping the latest value, and stores the user’s preference without redundancy.

Scenario 2 – Semantic deduplication : Three different sessions express the same intent with varied wording. The semantic memory stores a single fact, preventing duplicate records.

Scenario 3 – Episodic reflection : Three multi‑turn conversations (travel planning, gift recommendation, fitness plan) generate episodes. After a few minutes the reflection step produces three high‑level patterns that the agent can reuse without the user repeating context.

Namespace and Access Control

Namespaces are hierarchical paths such as

/strategy/{memoryStrategyId}/actor/{actorId}/session/{sessionId}

. They support fine‑grained multi‑tenant isolation when combined with IAM policies.

Failure Handling and Data Management

Long‑term extraction failures are automatically retried. Persistent failures can be inspected via ListMemoryExtractionJobs and manually retried with StartMemoryExtractionJob. BatchDeleteMemoryRecords supports up to 100‑item deletions for compliance scenarios (e.g., GDPR).

Conclusion

AgentCore Memory provides a path from a stateless tool to a memory‑aware partner, keeping memory concise through smart integration, supporting customizable strategies, and allowing developers to focus on business logic while the system maintains and refines its knowledge.