Drift

Inspiration

Most of the apps I use already have recommendation systems.

Spotify learns what music I listen to. Video platforms such as Amazon TV learn what I watch. Podcast apps learn which shows I follow. Reading and audiobook platforms such as Kindle learn what books I am interested in.

The problem is that each platform only sees one part of me.

My music profile might contain signals that would help recommend a podcast. The podcasts I follow might reveal interests that could lead to a great book. A video platform might know that I recently became interested in a topic that none of my other media apps know about.

Those profiles usually exist in separate ecosystems.

That inspired Drift: a personal AI media agent designed to build a broader understanding of a user's interests by learning from media preferences across different platforms and media types.

Instead of having separate recommendation systems confined to separate apps, Drift is intended to become a shared intelligence layer across them.

Music profile ───────┐
Podcast profile ─────┤
Book profile ────────┤
Video profile ───────┼──> Drift ──> Cross-media recommendations
Audiobook profile ───┘

The long-term idea is that a user's media taste should not have to start over every time they move from one platform or media format to another.

What Drift Does

Drift creates personalized media recommendations using a unified understanding of the user rather than treating each media category independently.

A user's interests might appear in several different forms:

• Artists and genres they listen to
• Podcasts they follow
• Books or audiobooks they enjoy
• Topics they watch videos about
• Subjects they explicitly say they are interested in
• Things they no longer want recommended

Drift can use those signals together when generating recommendations.

For example, someone might listen to technology podcasts, watch videos about artificial intelligence, and read cybersecurity material. Instead of treating those as three unrelated histories, Drift can recognize the broader pattern and use it when recommending a podcast, book, video, or other type of media.

This is where using an AI agent becomes important.

A traditional recommendation algorithm often focuses on signals such as similarity, engagement, or the behavior of similar users. Drift can instead reason over several kinds of user context and explain why a recommendation fits.

The goal is not to replace every recommendation algorithm inside existing media apps. The goal is to create a personal layer above them that understands more of the user's overall media identity.

How I Built It

Drift is built in Python using the Strands Agents SDK and deployed through Amazon Bedrock AgentCore Runtime.

For the current prototype, I use a sample media profile representing information that could eventually come from multiple external platforms.

That profile contains signals such as favorite artists, followed podcasts, and broader interests. In a future version, those signals could instead come from real services and APIs.

I also integrated Amazon Bedrock AgentCore Memory so Drift can maintain information beyond a single conversation.

The current architecture separates user context into three areas:

1. Baseline media profile Represents existing media information imported into Drift. In the prototype, this comes from a sample profile. In a future implementation, this could come from services such as music, podcast, reading, or video platforms.

2. Current user preferences Stored through AgentCore USER_PREFERENCE memory. These are preferences Drift learns directly from interactions with the user, including new interests and explicit dislikes.

3. Background facts Stored through AgentCore SEMANTIC memory and retrieved when they are useful for personalization.

Conceptually, the architecture looks like this:

For a recommendation request, Drift can combine baseline profile information, current preferences, and relevant remembered facts before generating its response.

The prototype is deployed using AgentCore Runtime rather than existing only as a local Python application.

I also tested Drift across separate sessions to verify that remembered information could affect later interactions instead of simply remaining inside one conversation window.

Why Memory Matters

Persistent memory is important to Drift because imported media profiles are only part of the user's identity.

A Spotify profile, for example, might show years of listening history, but the user may have recently become interested in something completely different. A user may also explicitly tell Drift something that cannot be inferred reliably from historical activity.

That means Drift needs to combine imported history with information it learns itself.

The rule I eventually adopted was:

Baseline data tells Drift where the user started. Current preferences tell Drift what the user wants now.

This allows imported media profiles to provide useful context without permanently defining the user.

Challenges I Faced

The most difficult part of building Drift was making persistent memory behave correctly.

During development, I discovered that my initial architecture was blurring the distinction between imported media-profile data and preferences the user had explicitly expressed to Drift.

My sample profile was originally exposed to the agent through a normal Strands tool call. Because that tool output became part of the conversation history processed by AgentCore Memory, information from the imported profile could later be learned as preference memory. This made historical profile data appear more like a current user preference than I intended.

That caused a subtle problem.

Suppose the imported profile indicated that the user liked history. Later, the user explicitly said:

"Do not recommend history anymore."

Both pieces of information could end up influencing future recommendations.

In testing, the negative preference (a topic or type of content the user explicitly does not want recommended) existed in memory, but unfiltered semantic retrieval did not always return it strongly enough for a recommendation request. That meant the agent could still rely on older data even though the user had explicitly changed their preference.

At first, this looked like a retrieval-tuning problem.

It was actually an architecture problem.

Increasing retrieval limits or adjusting similarity thresholds would not guarantee that explicit current preferences overrode older profile data.

I changed the design so baseline media information is loaded as baseline context rather than being written into conversational memory as information explicitly provided by the user.

Actual preference changes continue flowing into AgentCore's USER_PREFERENCE memory.

This gives Drift a clearer distinction between:

Imported historical profile
        vs.
What the user explicitly wants now

That challenge became one of the most useful parts of the project because it forced me to think beyond simply asking whether an agent could remember something. Reading the Strands and AgentCore Memory documentation also helped me develop a better understanding of how agents, memory strategies, retrieval, and persistent context work together.

I had to consider what each memory represents, where it originated, and how much influence it should have.

What I Learned

Before building Drift, I thought of AI memory mostly as a way to save information between conversations.

Building the project showed me that persistent memory involves several separate problems.

The system has to decide:

• What information should become long-term memory?
• What should remain baseline or external data?
• Which memories should be retrieved for a particular request?
• What happens when two pieces of information conflict?
• Should something imported from an external profile have the same authority as something the user explicitly said?
• How should newer preferences affect older behavioral data?
• How do you verify that personalization still works across completely separate sessions?

One of the biggest lessons I learned is that:

Remembering information is not the same thing as using memory correctly.

A memory system can successfully store everything and still make poor decisions if the application does not understand the difference between types of information.

I also gained practical experience with:

• Strands Agents
• Amazon Bedrock AgentCore Runtime
• AgentCore Memory
• USER_PREFERENCE and SEMANTIC memory strategies
• Persistent sessions
• AWS IAM permissions
• Bedrock model access
• Memory namespaces
• Semantic retrieval
• Preference extraction
• Agent deployment and debugging

The project also changed how I think about recommendation systems.

Instead of only asking, "What does this user like?", I started thinking about a broader question:

How can an agent build a coherent understanding of a person when that person's data is spread across many different systems?

What's Next

The current submission of Drift focuses on demonstrating the agent, memory, and personalization architecture.

The next major step would be replacing the sample profile with real integrations.

For example, Drift could eventually connect to services that expose information such as:

• Music listening history
• Followed podcasts
• Saved books and audiobooks
• Video interests
• Watchlists
• Ratings
• Likes and dislikes

Those sources could be normalized into a shared user profile that Drift can reason over.

Another important addition would be live media discovery. Instead of recommending only from the model's existing knowledge, Drift could use external APIs or search tools to find current podcasts, books, music, videos, and other media.

I would also like users to have direct control over the unified profile Drift builds, including the ability to inspect, correct, or remove preferences.

Long term, I imagine Drift as something that sits between the user and their media ecosystems:

Spotify ──────────┐
YouTube ──────────┤
Podcast Apps ─────┤
Reading Apps ─────┼──> Drift ──> One evolving media identity
Audiobook Apps ───┤
Other Services ───┘

Instead of every platform learning a separate version of the same person, Drift could give the user one personal AI agent capable of understanding the bigger picture.

A user's media interests will be able to travel with them.

Built With

• amazon-web-services
• aws-bedrock
• aws-strand
• python