Show how Redis Iris — specifically Context Retriever and Agent Memory — turns a fee complaint from a high-value customer into a retention moment. The decision is not whether to waive the fee. The decision is how to handle this customer in a way that deepens the relationship. Redis Agent Memory is what makes the difference: the agent knows what happened last time before the customer finishes saying hello.
Your agents already have access to CRM, billing history, and interaction records. The problem is none of that assembles before the first response — so the agent either asks the customer to repeat themselves or falls back to a generic script. What I’m going to show you is what happens when the agent already knows who Marcus is, what happened last time he called, and what the right action is — before he finishes his first sentence.
At the top are the systems ClearPath Financial already has — CRM, billing, interaction history, product catalog, and event streams. None of them go away. RDI and Redis FeatureForm make those systems usable in the runtime path. Redis RAM handles the hot session state, live churn triggers, and active offer eligibility. Redis Flex carries the warm interaction history, product holdings, and customer embeddings.
In the Unified Context Layer, you’ll see two components that are unique to this demo. Redis Context Retriever assembles the Customer 360 as governed MCP tools — the AI agent does not write a query, it calls a structured schema-defined interface. And Redis Agent Memory is new to the Redis Iris stack. It stores session-scoped working memory for the current interaction and long-term memory of what happened in prior sessions — what was said, what was resolved, what was promised. That is what makes the agent smarter over time, not just faster.
This is the first demo in this library to show both Context Retriever and Agent Memory operating together. That distinction matters, and we will come back to it on every stage.
Now let me show you the specific customer moment that triggers this decision.
Marcus Chen is a five-year Preferred-tier customer. He’s never missed a payment until this month — forty-seven consecutive on-time payments, and now one miss. He’s calling about a $35 late fee. And sixty-one days ago, he called about a similar fee. That interaction ended with a waiver — he mentioned a job transition, the agent extended empathy, the fee was waived.
That outcome is stored in Redis Agent Memory. Before Marcus finishes his first sentence, the agent already knows all of this. The payment history, the prior fee dispute, the job transition, the positive resolution. The $35 fee is not the story. The story is whether the agent can use that context to handle this interaction in a way that makes Marcus more loyal when he hangs up than when he called.
Notice the data row on the left: 61 days since last contact, prior call was a fee dispute, resolved with a waiver granted. That is Redis Agent Memory surfacing prior session context. Without it, the agent sees a first-time caller with a fee complaint. With it, the agent sees a five-year relationship that deserves better than a script.
Let’s look at how the data stays fresh enough to power this decision in real time.
RDI synchronizes the account state, payment records, and interaction history always current in Redis. Every time Marcus’s billing record changes, every time a payment posts or a fee is assessed, RDI keeps the working set fresh without the AI agent waiting on cross-system joins at call time.
Redis FeatureForm serves the online features — customer LTV, churn risk, intent signals — fast enough to act on during the live conversation. These are not recalculated at call time. They are served from Redis, which is why the latency stays under two milliseconds per feature.
But the key point here is what is at the bottom of the pipeline status panel: Agent Memory is active and the prior session is already loaded. That is not a CRM lookup. That is Redis Agent Memory surfacing the context of what actually happened in the conversation 61 days ago — what Marcus said, how he felt, what was resolved. That is a different thing from a CRM note, and it is what makes the next stage the narrative center of this demo.
This is where the Iris stack does something no other combination of systems can. Let me show you.
This is the stage where Redis Iris earns its keep. On the left, Context Retriever has assembled Marcus’s Customer 360 — account standing, product holdings, payment history, churn risk. Payment health score of 0.98. One miss in five years. Moderate churn signal given the fee complaint pattern. That is the live state.
On the right, Agent Memory has surfaced what happened sixty-one days ago: fee dispute, waiver granted, job transition mentioned, positive resolution. The customer expressed relief and thanked the agent. And there was a commitment — Marcus would set up autopay. He has not. That context is right here, available before the first response.
The blue callout at the bottom is the key message: Context Retriever assembles the Customer 360 via governed MCP tools from the CRM schema. Agent Memory surfaces the prior session context — the job transition, the waiver, and the autopay commitment. The agent does not ask Marcus to repeat himself. The agent already knows.
Slow down here. This is where the audience should feel the gap between a CRM-aware agent and a Redis Iris-powered agent. The CRM knows Marcus has a checking account and has been a customer for five years. Agent Memory knows he was stressed about a job transition, that the waiver relieved him, and that he said he would set up autopay but did not. Those are different things.
Now let’s look at what features hydrate in the milliseconds before the agent responds.
These are the features Redis FeatureForm serves at the moment Marcus’s call arrives. Customer LTV at 0.87 — he is in the top tier for his segment, top 20% by annual revenue. Churn risk at 0.41 — moderate, elevated by the fee complaint pattern but not in the danger zone. Payment health at 0.91 — one miss in five years barely moves the needle on that score.
The two features worth calling out are empathy response score at 0.88 and retention propensity at 0.83. Empathy response is not just a model output — it is informed by what Agent Memory knows about Marcus. He responded well to proactive empathy the last time. That is a signal. Retention propensity at 0.83 says that given appropriate action, this customer is highly likely to stay.
All 64 features hydrate at P99 under two milliseconds. These are not batch scores pulled from a data warehouse. They are online features served from Redis, available inline in the session before the agent opens the conversation.
Here’s the ranked action that comes out of this context.
The NBA ranker evaluates three available actions and WAIVE + RETAIN wins at 91% confidence. The math is straightforward: waiving a $35 fee to protect $4,200 in annual revenue from a customer who has a five-year relationship and responds well to proactive empathy is not a hard call. What makes it possible is the context.
Without Agent Memory, the agent does not know about the prior waiver, the job transition, or the autopay commitment. It would apply standard policy and hope for the best. With Agent Memory, the action is obvious: waive the fee before Marcus asks, offer autopay enrollment to fulfill the commitment from 61 days ago, and check whether he qualifies for a Preferred upgrade while you have him on the line.
The suppressed action — standard response, apply the fee with standard messaging — is the action a generic IVR or scripted agent would take. It scores at 0.03 because it ignores the relationship context entirely. It violates the implicit commitment from 60 days ago and increases churn risk. That is the cost of running an AI agent without Redis Agent Memory.
Let’s look at what this decision actually means for the business.
The operational case is simple. The waiver costs $35. The customer is worth $4,200 a year. That math runs in every banking boardroom. What is harder to quantify — and what Redis Iris makes possible — is the compounding value.
But the more interesting number is the churn risk delta — 0.41 before this interaction, 0.18 after. That reduction is not just this call. Agent Memory records the outcome of this session, and every future interaction with Marcus starts from a better position. The next time he calls, the agent knows the fee was waived twice, autopay was enrolled, and he responded positively to proactive empathy both times. That is the compounding value of the Iris stack: the agent gets smarter about this customer over time, not just faster at accessing static records.
The rev-compare on the right tells the short version: complaint unresolved becomes retained plus deepened. That is the before and after of adding Redis Agent Memory to an AI customer service agent.
Here’s the before and after — same customer, same fee, completely different outcome.
On the left, a generic agent sees a fee complaint with no prior context. It applies standard policy. Marcus either escalates or hangs up frustrated. The relationship takes a hit. The churn risk stays elevated. And the interaction gets logged as unresolved. That is what happens when the agent does not have access to what happened last time.
On the right, the Redis Iris-powered agent opens with Marcus’s full context already assembled — including what happened last time. The fee gets waived before Marcus has to ask. Autopay gets offered, which fulfills a commitment from 61 days ago. The interaction ends with a stronger relationship than it started with. Agent Memory records the outcome so the next interaction starts from an even better position.
Same customer. Same $35 fee. Completely different outcome. The only thing that changed is Redis Iris — specifically the combination of Context Retriever assembling the live Customer 360 and Agent Memory surfacing what actually happened before.
Let me bring the architecture back up to close the loop.
The systems stay. CRM, billing, interaction history — none of that moves. Redis Iris becomes the context engine that sits between those systems and the AI agent. That is the additive nature of this architecture: you do not rip and replace anything.
Context Retriever provides governed, schema-defined access to the customer data through MCP tools. The AI agent does not write ad-hoc queries — it calls a structured interface with row-level security and a defined data model. That is the difference between an agent that happens to have database access and an AI agent that has governed, production-ready access to customer context.
Agent Memory provides what no other system in the stack captures — the context of what actually happened in prior conversations. Not just that a call occurred and a fee was waived, but what the customer said, how they felt, what was resolved, what was promised. Together, they make an AI agent that gets smarter with every interaction, not just faster at accessing static records. That is the Redis Iris value proposition, and this demo is the clearest way to show it.