Show how Redis Iris — specifically Redis Context Retriever — makes an AI underwriting agent schema-driven instead of code-driven. The agent calls four auto-generated MCP tools (get_credit_profile, get_income_signals, get_fraud_risk, get_policy_eligibility) and reaches an in-session approval decision in under 15 milliseconds. This is the Iris native lending story — different from the Loan Approval Process demo which shows Redis assembling context passively.
Lenders already have bureau APIs, income verification systems, and fraud platforms. The problem is the AI underwriting agent can't reach them without custom SQL queries, bespoke API integrations, or batch pipelines that take days. What I'm going to show you is what happens when the agent just calls a governed MCP tool instead — and the decision lands in the session before the applicant closes the browser.
At the top are the systems Apex Lending already has — credit bureau APIs, the loan origination system, income verification, fraud and KYC platforms, the policy engine, and a Kafka event stream. None of these go away. In the ingest layer, RDI keeps bureau data and income signals always fresh in Redis. Redis FeatureForm serves the online features. In the Unified Context Layer — this is the important part — Redis Context Retriever sits as the schema layer between the raw data and the AI agent. It reads the applicant schema at startup and generates four MCP tools: get_credit_profile, get_income_signals, get_fraud_risk, and get_policy_eligibility. The AI underwriting agent doesn't know those systems exist individually. It just calls the tools. That's the Iris story here.
Let me show you the specific applicant moment that triggers this.
Sofia Reyes is 28 years old, applying for a $45,000 personal loan at a 60-month term on the Apex Lending digital portal. She's a first-time applicant — not an existing customer. She has stated income of $72,400 a year, three years at her current employer, and she has just authorized a tri-merge bureau pull. She is on the confirmation screen right now, waiting. The AI underwriting agent has under 15 milliseconds to call the Context Retriever MCP tools and return a decision before that screen renders.
Let's look at how the data stays always fresh before the first MCP tool call.
The ingest layer keeps the data always fresh. RDI synchronizes bureau data, LOS state, and income verification results into Redis continuously — always-fresh context with no custom pipeline code. Redis FeatureForm keeps the online features current with train-serve parity. And critically — Context Retriever has already compiled the MCP tools from the applicant schema. They are ready before the first agent call arrives.
This is the heart of the Iris architecture. Watch what the agent actually does.
This is where the Iris architecture earns its keep. Watch what the AI underwriting agent actually does. It doesn't open a database connection. It doesn't fan out to four bureau APIs. It calls get_credit_profile — returns Sofia's score, tradelines, and inquiry history in one governed response. It calls get_income_signals — returns her verified income, employment tenure, and stability classification. It calls get_fraud_risk — returns identity confidence at 0.94, device confirmed, zero fraud flags. It calls get_policy_eligibility — returns DTI at 28.4%, within the 43% ceiling, product eligible. Four calls. Four governed responses. No custom SQL. No bespoke API integrations. That's what Context Retriever does — it turns a schema definition into a set of structured MCP tools the agent can call directly.
Now let's see the features that hydrate while the MCP tools are running.
These are the 94 features Redis FeatureForm serves in 2.3 milliseconds. Credit quality at 0.74, income stability at 0.88, fraud risk at 0.06 — that is very low. DTI capacity at 0.71 means she has meaningful room within the policy ceiling. Approval rate predictor at 0.82. The train-serve parity is 100% — the features the model was trained on are exactly the features served at inference time, no drift.
Here's the decision the agent reaches from all of that context.
The AI agent has four MCP tool results, 94 features, and three action paths to evaluate. APPROVE wins at 87% confidence. $45,000 at 8.9% APR, 60-month term. The math is clean — credit score 718, income verified, fraud risk near zero, DTI well within policy. The decision is straight-through. No manual review. The counter-path of requesting income documents is not triggered because the MCP tool already returned payroll-confirmed income. The agent has everything it needs.
Let's look at what this means for the business.
The business case is conversion and accuracy. Sofia is on a confirmation screen. The average industry underwriting time is two to five days and the decision comes via email — at which point the applicant has moved on or accepted a competitor offer. The decision delivered here is in session, under 15 milliseconds. The other number worth noting is the four MCP tool calls versus zero custom integrations. Every other lending stack that tries to do this builds bespoke API connections to each data source. Context Retriever generates those interfaces from a schema. That's not a marginal improvement — it's a different architecture.
Here's the before and after — same applicant, completely different experience.
Left side: Sofia submits her application and it goes into a manual underwriting queue. Decision arrives in two to five days via email. She's probably applied somewhere else by then. Right side: the AI underwriting agent calls four Context Retriever MCP tools, assembles the Applicant 360, and the decision appears on the confirmation screen before she closes the browser. Same applicant, same data sources, completely different outcome because the agent has governed, structured access to the context it needs.
Let me bring the architecture back up to close the loop.
The systems stay. Apex Lending still has bureau APIs, an LOS, income verification, and a fraud platform. What changes is how the AI agent accesses them. Redis Context Retriever sits between those systems and the agent as a schema-driven MCP layer. The agent calls four structured interfaces instead of writing four custom integrations. Redis Iris makes the AI agent schema-driven, not code-driven. That is the architectural shift.