A borrower opens their mortgage statement and the payment has gone up. They call the servicer, and the answer they need is specific to them: their escrow analysis, their shortage amount, their new impound balance.

No help center page can produce it, and no rep can answer it without pulling up the loan. That interaction, repeated at volume, is where an honest conversation about AI in loan servicing has to start.

The promise is real, and it is also frequently oversold, applied to the wrong problem first, or scoped without acknowledging where automation breaks down.

The actual workload

Loan servicers handle a narrow set of interaction types at high volume. Payment inquiries are the dominant category: when is my payment due, did my payment post, why is my balance different than I expected. Escrow inquiries spike seasonally, particularly after annual escrow analyses hit mailboxes and borrowers see unexpected payment changes.

Payoff requests come in regularly. Borrowers who are refinancing, selling, or paying off early need an accurate quote quickly, and every one of those requests is also a customer telling the servicer they are leaving.

Most servicers treat the payoff quote as a fulfillment task. That is the wrong frame: it is the last conversation before a refinance completes, which makes it the highest-leverage retention moment in the book.

Loss mitigation is lower volume and far more complex. Borrowers facing hardship need to work through forbearance, repayment plans, loan modifications, and in some cases short sales or deeds-in-lieu. That conversation is where the relationship gets decided, which makes it as much a retention moment as the payoff quote.

Disputes - billing errors, insurance force-placement complaints, credit reporting issues - require documentation review and often regulatory awareness. And then there's delinquency outreach: proactive or reactive contact with borrowers who have missed payments, which lives somewhere between collections and customer service.

Each of these categories has a different automation profile. Treating them as a single "servicing CX" bucket is where most automation projects go wrong.

Full automation today

Interactions AI can handle without a human today share three traits: high volume, structured data, and an answer that exists somewhere in a system of record. Payment inquiries fit all three. An AI can query a loan management system in real time, confirm a payment posted, explain a balance change, or tell a borrower their next due date.

Basic payoff quotes fall into the same category, with a caveat: the AI needs accurate per-diem calculations and clear rules about good-through dates. Servicers with clean data infrastructure can automate this completely, and those with fragmented systems need to solve the data problem first.

Escrow explanations are also automatable, and they're a good example of where AI adds real value over static FAQ content. A borrower asking why their payment went up by $140 per month needs an answer built from their own escrow analysis, down to the shortage amount and the new impound balance.

Proactive delinquency outreach works well too. The interactions are structured, the goal is consistent, and the volume makes human-only outreach impractical to staff.

A borrower who gets an SMS about a missed payment and replies by calling two days later should not have to start over, and the AI concierge that picks up the call should know what was already offered over text.

Payment arrangements for borrowers who need to catch up on a missed payment are also fully automatable, within pre-defined servicer parameters. If the AI knows what arrangements it can offer without approval, it can complete the conversation end-to-end.

Where determinism does the work

There is a difference between work AI should not decide and work AI should not touch, and most servicing conversations collapse the two.

Lorikeet calls the pattern that separates them Pockets of Determinism: agentic orchestration wrapping deterministic operations. The conversation around a task can stay flexible while the operation inside it does not move.

Take a hardship application. The AI runs the intake, pulls the account history, checks the document set against the servicer's required list, and assembles the packet.

The qualification test then runs as a fixed rule set, and the approval sits with a named human queue. The AI does most of the work and none of the deciding.

Dispute resolution works the same way. The AI logs the dispute, pulls the account history, handles the acknowledgment, and resolves the straightforward cases end to end. What it can offer is bounded by fee and adjustment limits set in the workflow, so a resolution outside those limits is not something the model can talk itself into.

Force-placed insurance, credit reporting corrections, and fee disputes with regulatory implications carry a documented review step, and the packet the AI assembles is what the reviewer opens.

Loan modifications carry the strictest standards. Servicers operating under GSE guidelines, FHA/VA rules, or consent order requirements have specific documentation and decision standards, and those standards belong in a hard rule set the workflow enforces on every file.

The AI collects the documents, checks completeness against that checklist, and generates the workout options the guidelines allow. The approval itself sits inside the workflow that executes it, and that workflow tests the file against the standard before anything happens. If the file does not meet it, the approval does not run and the concierge goes back to finish the work.

The execution boundary

The safety of a servicing agent does not come from a list of things it has been told not to do. Instructions are advice, and an agent in a live conversation can reach for any tool it has at any moment.

Lorikeet cofounder Jamie Hall puts it plainly: "An AI agent can trigger any tool at any time. That's what makes it conversational. But we can make the tools themselves foolproof, so even if the agent triggers them incorrectly, nothing bad happens."

Think of a banking app. A child can tap "Close Account."

The button is always there, but the app checks for remaining balances before executing.

The interface is permissive, the operation is strict. Servicing works the same way: foreclosure referral, denying a loss mitigation option with no appeal path, and initiating legal action are all reachable by the concierge, and none of them execute on the concierge's say-so.

The tool that carries out the action tests its own preconditions first: has a reviewer signed off, is the file complete, does the account state match the standard. If the answer is no, the tool returns unmet conditions and nothing happens. Breach letters, demand notices, and anything that starts a legal clock are generated and reviewed by people.

That is what holds whether or not the model remembers the instruction. Even if the concierge convinces itself the conditions are met, the tool knows they are not. Guardrails add a second layer that runs outside the concierge's reasoning loop, evaluating every message and response in real time as the conversation happens.

Novel situations still go to a person: the borrower whose circumstances fit no defined workflow, the edge case that falls between categories. The concierge escalates when a confidence or scope check fires, and that trigger is measurable and behaves the same way every time.

Capability matrix

The right sequencing starts with high-volume, structured, data-dependent interactions, which generate the most immediate capacity relief at the lowest risk. Once those are running reliably, servicers can extend automation into more complex workflows, handling everything in them that does not require judgment.

The mistake most servicers make is starting with something complex. Loss mitigation automation sounds impressive, but if the AI breaks down on a payoff inquiry, borrowers notice immediately. The foundational layer comes first.

Realistic scope

Lorikeet's architecture is built for this kind of sequencing. How much of an interaction runs agentically is configured per operation, based on what happens if it goes wrong: a knowledge lookup can run fully agentically, a refund needs a conversational wrapper with deterministic execution inside, and a compliance-critical flow can be almost entirely structured.

The high-volume interactions run first, and the parts where correctness is not optional run as defined workflows that execute the same way on every file. Calculations, policy parameters, and document checklists are written down once and enforced inside the workflows that carry them out.

Guardrails evaluate every message and response. The actions the concierge is not permitted to take stay reachable, because the tools behind them will not run until their conditions are met.

Carmoola is the closest published example. It is a UK consumer credit lender rather than a mortgage servicer, but the regulatory shape is the same: it operates under Financial Conduct Authority rules, and an answer about affordability or a missed repayment is a decision. Lorikeet resolves 60% of Carmoola's inbound conversations end to end, and 90% of its outbound conversations, across WhatsApp, chat, and email.

The escalation path is a defined handoff with the packet already assembled, so the person who picks it up gets work that is ready to decide.

Payment inquiries and escrow explanations are the two highest-volume interactions in most servicing operations. Automating them accurately and compliantly frees real capacity, and it does it in the part of the book where the answer already exists in a system of record.

Once that foundation is in place, the question is how far into the complex workflows automation can responsibly reach. The answer depends less on the model and more on how much of the servicer's policy has been written down as something a system can execute.

See also:

• Guardrails: Runtime Protection for Your AI Agent - runtime controls for production AI agents

• Defence in Depth: How to Actually Manage AI Accuracy in Production - layered accuracy controls for production AI

• AI Agents for Fintech Customer Service - first-call resolution in financial services

• For Insurers, the Problem Isn't Hallucination - It's Liability - why regulated industries need different guardrails

• How to Deploy AI Support Without Redesigning Your Entire Operation

• Human-in-the-Loop (HITL) - glossary definition

• Lorikeet for Financial Services

• How Carmoola Resolves 60% of Support End-to-End with Lorikeet - FCA-regulated consumer credit lending