AI transformation is on the top of everyone's mind right now, but no one has the roadmap.

Outside-in Customer Intent is where it all starts. The customer resolution loop is what you're solving for - where Agentic AI has serious impact.

Every banking transformation leader understands its importance, and most are wrestling with the same fundamental question: how to actually move AI out of pilot into production.

We're all figuring this out as we go.

That's exactly why I'm launching this newsletter.

We work with 120+ leading banks every day, and we spend our days in the "hows" - actively deploying agents, navigating regulatory friction, and putting AI into real operational work. We work with live production systems running inside regulated banks. Everything we build at Backbase is designed to solve this problem, and I want to share what we're learning while we build it.

I don't have all the answers, but I have something genuinely useful: what we see working right now, from the inside.

Each week I'll share one practical insight from the field.

---

Where most banks are starting with AI - and why it's backwards

Most banks deploying AI agents right now are starting in the back office - automating internal workflows and adding intelligence to what's already there.

That logic makes sense on paper. The back office is where the cost base lives. It's measurable, contained, and far from the regulatory spotlight of the customer relationship. So it feels like a safe place to start.

But here's what it misses: Customer intent is where almost everything in the bank starts. Someone wants a loan. Someone needs a payment investigated. Someone's KYC needs updating or a fraud case needs to be handled urgently. That intent enters through a digital channel - mobile banking, usually - what happened next was simple: a human picked it up and started navigating systems.

In simple terms, growth meant hiring more humans to bridge the gap between where the intent landed and where the resolution lived.

Now there's a third actor joining the frontline: AI agents. They change the resolution loop entirely.

Instead of deploying agents into the back office first, the banks I find most interesting right now are placing agents right at the start of the resolution loop - where customer intent lands - and designing everything from there outward.

This is the AI-native approach, built into the frontline from the first moment intent arrives - and that's the shift that matters.

Getting practical: Start with a map

It's easy to say "deploy AI and scale operations," and most executives are sick of hearing it, because they know they have to. What's harder is knowing where to start and what to build first.

Here’s where I believe you should start: Before you deploy a single agent, map a specific customer journey end to end. Count every step, every system, every handoff. Measure how long each stage takes, and be honest about where the time really goes.

Once you have that map in front of you, something becomes visible that you couldn't see clearly before:

• Where value leaks
• Where things slow down
• Where whitespace complications stack up and the human coordination load becomes the real cost structure of the operation.

Those specific moments - the handoffs, the queues, the manual assembly work - are where you design agents. The map determines the role, the function, and what agents are supposed to and allowed to do.

Without this map, there’s really no way you can reliably even think about agents in the workflow.

Let's unpack a real journey: personal loan origination via mobile.

Take a personal loan application that starts on a mobile banking app. It's one of the most common, highest-volume origination flows in retail banking, and also one of the most broken.

Around 68% of online loan applications are abandoned, usually because of poor customer interactions when things get complicated, and it's not coming from a marketing problem or a bad app. It's an operating model problem.

Here's what that journey typically looks like when you map it carefully.

Stage 1: Intent capture.

The customer opens the mobile app, navigates to lending, and starts an application - name, income, purpose, loan amount. Some banks pre-fill this from account data and it feels smooth. Most still ask the customer to type everything in.

If the credit decision is clean - existing customer, strong score, low DTI, product within pre-approved range - the bank approves straight through and it's done in minutes. That's the best case, and it's also the minority of cases.

Stage 2: The first handoff.

Something doesn't pass the automated decision engine. Maybe the income looks unusual. Maybe the debt-to-income ratio is borderline. Maybe the customer is relatively new and data is thin.

The application drops into a queue, and in most banks, that queue is an inbox somewhere inside a lending operations team. Nobody assembled the context before it landed there. The operations employee opens the case cold and starts pulling information from four or five separate systems - core banking for account history, the LMS for existing loan data, the credit bureau for the score breakdown, the CRM for relationship context, sometimes a fraud or risk system on top of that.

Each one requires a separate login, a separate lookup, a separate mental reconstruction of who exactly this customer is. They're building the picture manually, from scratch, every single time.

Stage 3: Document collection.

The system sends the customer an automated request for documents - pay stubs, tax return, bank statements, proof of employment. The customer gets an email, maybe sees it the same day, maybe sees it three days later. Maybe they upload the right thing, maybe they upload the wrong document, maybe the portal throws an error and they give up.

The ops team follows up. The customer eventually responds. The case sits waiting in the meantime, accumulating days.

Stage 4: Underwriting.

Once the documents land, an underwriter reviews the application alongside the documents, the credit picture, and the risk signals. In many banks, a meaningful chunk of that review is actually data transcription - copying figures from a PDF into a decisioning tool, cross-referencing stated income against bank statements line by line.

If there's an exception - missing info on the file, an unusual income source, a policy edge case - it escalates to another team, another queue, another wait.

Stage 5: Decision and fulfillment.

Eventually a decision is made. Approved, declined, or counter-offered. The customer signs electronically, the loan funds - usually next day, sometimes later.

End to end, depending on the lender and how cleanly the application flows, it can take anywhere from a single day to a week. When things don't go smoothly, it stretches further than that. And somewhere between Stage 2 and Stage 4, a meaningful percentage of customers went and found a faster answer somewhere else. The dashboard rarely captures that clearly enough.

Now redesign it - with agents in the loop.

Here's what changes when you redesign this resolution loop with agents built in from the start, outside-in.

Agents activate the moment intent arrives.

The customer starts the application and an agent is already at work, pulling account history, transaction behavior, existing relationship data, and risk signals - assembling the full picture before a human touches the case.

This isn't the agent making the credit decision. It's the agent doing the preparation work and gathering information from different systems that currently costs an operations employee 15-20 minutes of manual system navigation on every single case that comes through.

Straight through where possible, prepared handoff where not.

If the decision engine approves, it runs straight through - governed, auditable, done. If the application needs human review, the agent doesn't disappear. It hands the operations employee a complete case: assembled context, targeted document checklist, income verification summary, risk flag explanation, and a confidence-scored recommendation. The employee makes a judgment call on a prepared case, not a cold queue item dropped into an inbox.

Document collection gets specific.

Rather than sending a generic request and waiting to see what comes back, the agent knows exactly which documents are needed for this specific case based on the income type, loan size, and risk profile. It sends a targeted request, monitors for the upload, validates the document on receipt, and flags any issues immediately. No more waiting days for a document that turns out to be the wrong one.

Underwriting support built in.

The agent surfaces extracted figures directly into the underwriting workspace - income from the pay stubs, balances from bank statements, DTI calculated automatically. The underwriter reviews, challenges, and decides. No transcription, just judgment.

The loop closes back with the customer.

Status update through the app, decision communicated clearly, next steps surfaced automatically. The customer got the outcome. The bank resolved the case with a fraction of the manual work.

What the agent was - and wasn't.

The agent never made the credit decision. That stayed with the human, and rightly so. What the agent did was prepare the case, assemble the context, run the document validation, and surface everything the human needed to decide well and decide fast.

The agent's role, function, and authority were all determined by the map. Where straight-through processing was possible, it ran straight through. Where human judgment was required, the agent handed a complete picture across rather than a cold item in a queue. And every action the agent took ran under defined authority - what it could retrieve, what it could validate, what it could recommend, and what required human approval before executing.

The greatest barrier to scaling agentic AI isn't technology, it's trust. Governed authority is what makes agents deployable inside a regulated bank, and it's also what makes the regulator conversation manageable. Full stop.

The practical questions to take back.

Before you think about which model to deploy or which vendor to evaluate, answer these four questions about one high-volume lending journey in your operation:

• How many systems does one employee touch to process a single loan exception?
• How long does the average case sit in queue before anyone picks it up?
• What percentage of your abandonment happens in the document collection stage versus the actual decision stage?
• How much of your underwriting time is data transcription versus real judgment?

Those four questions will tell you more about where your agents need to go than any AI strategy document I've seen.

BCG estimates retail banks could unlock more than $370 billion annually in additional profits by 2030 through large-scale AI deployment, but the biggest gains only come when banks transform end-to-end workflows rather than deploying isolated tools into isolated problems.

Loan origination is one domain. It's also one pattern - and once you've built the coordinated version of one journey, you have the architecture, the agent framework, and the governed authority layer already in place. The next domain deploys faster. The one after that faster still.

That's just one practical place you can start having the conversation and mapping out the time and cost saving, while at the same time identifying the practical tasks the agent can and should take care of. A sequence of mapped journeys, redesigned resolution loops, and agents placed exactly where the map says they belong.

If you want to map a specific journey in your operation with our team, send me a message. No strings attached. We would happily share our insights and help you make a strong case for regulated AI transformation.

• Jouk