99.9% Accurate AI Isn’t Good Enough: Why AI Agents in Lending Need a Coworker
An AI agent that’s right 99.9% of the time gets about 1 in 50 lending workflows wrong. Why errors compound, and how to build agentic processes you can trust.
This article was originally published as Issue #2 of Unconditional, a newsletter by DigiFi co-founder Bradley Vanderstarren. Subscribe on LinkedIn to read future issues first.
The previous edition of this newsletter ended with suggestion: pilot AI agents on narrow tasks, and learn how they fail before you rely on them. This article is about what I’ve learned doing exactly that over the past year.
Here’s the short version. An AI agent that gets each step right 99.9% of the time sounds ready for production. But put it in a 20-step sequential lending task, and it will fail on about 2% of applications due to compounding errors. The fix is not a smarter model. It’s a better architecture around the agent: one that assumes mistakes will happen, catches them before they compound, and is tested until you can prove it works.
None of this is specific to one model or one use case. It applies to any lender, bank, or credit union putting agentic AI into a real workflow, whether you build it or buy it.
“Just Let the AI Verify the Income”
Agentic AI is easy to describe. Give an agent access to the applicant’s data and a goal, such as “verify income,” and let it work out the rest. No rules to write, no workflow to design. It sounds like the end of decades of manual underwriting work, and the end of needing to implement complex rules-based automation.
But consider what “verify income” actually involves. For example:
- Confirm the applicant has given permission to access their accounts.
- Pull bank transaction data.
- Identify recurring deposits.
- Separate payroll from transfers and other credits.
- Match payroll deposits to the stated employer.
- Read the pay stub: gross pay, pay period, year-to-date totals.
- Reconcile the pay stub with the deposits.
- Confirm employment status and tenure.
- Account for other income, such as bonuses, gig work, or benefits.
- Calculate monthly qualifying income.
- Compare it with the stated income and flag any variance beyond tolerance.
- Record the result and the evidence behind it.
That’s a simplified version. Add the exceptions every lender sees, and it is easily 20+ steps, with branching paths. Every step is a place where an agent can be slightly wrong, and every later step compounds the error.
Problem One: Similar Answers, Different Paths
The first surprise when implementing AI is that an agent doesn’t do the same work the same way each time. Ask it to verify income on the same application ten times, and you'll see ten different approaches. The agent might check the pay stub first one time and the deposits first the next. It might sometimes skip a step it judges unnecessary. It might add steps you didn’t expect.
The obvious response is more detailed instructions, and you do need them. However, while detailed instructions do narrow the variation, they'll never remove it. AI models are probabilistic by nature, meaning some randomness is built in. That's what makes them good at messy work, but it's also what makes them inconsistent. Traditional automation is rules-based and produces the same answer every time. AI is different.
Is probabilistic automation a problem? It depends on what you need to be consistent. Here's my view for lenders:
- The outcome must be consistent. Fair lending requires that similar applicants be treated similarly. Two near-identical files that get different results is a real problem, however each was reached.
- The path must be visible. A lender must be able to show an examiner, or a borrower, exactly what was checked and why the decision followed. Variation you can see and explain is manageable. Variation you cannot see is not.
- The path itself can vary, within those limits. People vary too. Two good underwriters rarely work a file in exactly the same order.
So inconsistency is manageable once you understand it. The harder problem is what happens when small errors meet a long workflow.
Problem Two: Compound Errors
This problem is less expected and more challenging. Errors in a multi-step workflow multiply. If the agent is correct 99.9% of the time at each step, a 20-step workflow is accurate only about 98% of the time. One in fifty applications (2%) has an error somewhere, which is far too high.
When an agent works in a straight line, saving as it goes, mistakes compound. A mistake in step four, such as a transfer counted as payroll, flows into the income calculation, the comparison with stated income, and the final record. The initial error compounded in all future steps, resulting in a completely wrong file.
At a lender processing thousands of applications a month, a 2% error rate is a lot of mistakes. It also explains a common disappointment: a vendor demonstrates an agent that is accurate in a demo, but the workflow still fails in production. The number that matters is not accuracy per step. It is success per workflow, measured end to end.
How Humans Avoid Compound Errors
To help address this issue, it's helpful to consider how humans work, because we're probabilistic too. A good underwriter makes mistakes, works a file in a different order from day to day, and has better and worse afternoons. At any single step, we can make errors.
What we're good at is preventing errors from piling up. We stop and look back. We take a break and notice something we missed. We ask a colleague. We realize step four was wrong, fix it, and redo the steps that depended on it. Our accuracy comes less from each step and more from the checks between them and our ability to course-correct.
Banking formalized this long ago with worker-reviewer controls, often called maker-checker: a second person reviews important work before it takes effect. No one assumes the worker is perfect. The process assumes mistakes will happen and is designed to catch them.
The lesson for agentic AI is direct: if we use a probabilistic system, we have to treat it as one. Accept some variation in the path, and build checks throughout the process so that the workflow is reliable even when individual steps are not.
Building Reliable Agentic AI Processes
Manufacturing and banking have spent decades learning how to get reliable results from imperfect steps. Three of their ideas translate almost directly to agentic AI.
1. Agentic worker-reviewer teams
Pair the agent doing the work, the Worker, with a second agent whose only job is to review it, the Reviewer. When the Reviewer finds a problem, it sends the work back with specific feedback, and the Worker tries again.
The math is encouraging. If the Worker’s 20-step workflow is right 98% of the time and the Reviewer catches 90% of errors, the combined process is right about 99.8% of the time. A second review cycle takes it to roughly 99.98%.
There is a catch. That math assumes the Reviewer catches errors independently. A Reviewer built from the same model with the same instructions tends to share the Worker’s blind spots and miss the same mistakes. The best reviewers are deliberately different: separate instructions, a narrower focus on known failure types, and where possible a different model.
Some people call systems like this a swarm. In lending, it needs to be a team: every agent with a defined role, and every handoff checked.
2. Mistake-proof what you can
The most reliable check is one that cannot be wrong. Deterministic rules-based checks, such as whether deposits reconcile with the pay stub, whether totals add up, and whether every required field is present, are cheap, consistent, and share none of the agent’s blind spots. Manufacturing calls this poka-yoke: designing the process so certain errors cannot happen at all.
Any step that can be a rule should be a rule, run by the decision engine or the workflow system. The agent never gets the chance to get those steps wrong.
AI can helps here too, though in a different role. Writing rules has always been the slow, hard part of automation, and it is exactly the work most teams hoped AI would spare them. Now a lending team can describe a check in plain language, have AI draft it as deterministic logic for implementation. From then on, it runs the same way every time.
In other words, use AI to write the process, not to be the process, wherever you can. Save the agent’s judgment for work that truly needs it, such as reading an unusual document or making sense of irregular income. Deterministic rules where you can, probabilistic AI where you must.
3. Escalate to a person
When the Worker and the Reviewer still disagree after a set number of attempts, the file goes to an underwriter, along with what each agent found and why they disagree. The person becomes the last safeguard, not the first reviewer, and spends their time on the files that truly need judgment.
Prove It: Evals and Automated Testing
The three principles describe how to build a reliable workflow. They do not tell you whether you have one. For that, you need evals: a structured, automated way to test an agentic process before it touches a real application, and every time it changes afterward.
Lenders already do a version of this. Credit models are validated before they go live and monitored after. Agentic workflows require the same discipline, with one difference: because they are probabilistic, a single passing run proves very little.
A working evaluation process has five parts:
- Build a test set. Gather a few hundred real, de-identified files with known correct outcomes. Include the hard cases on purpose: irregular income, mismatched documents, thin files, and suspected fraud. A test set of clean files only proves the agent can handle clean files.
- Define what “correct” means. For each case, write down the expected result (qualifying income within tolerance), the steps that must happen (deposits reconciled with the pay stub), and the actions that must never happen.
- Automate the runs. Run every case through the full workflow, not one step at a time. Run each case several times, because a probabilistic process can pass once and fail the next.
- Score it. Measure workflow success end to end, where the errors occur, how much results vary between runs, and how often files are escalated. An agent that escalates everything is safe and useless.
- Iterate, and run everything again. Adjust the instructions, add a deterministic check, sharpen the reviewer. Then re-run the entire test set, not just the cases you were fixing, because a fix in one place often breaks something elsewhere.
The work does not end at launch. Re-run the evals whenever the model, the instructions, or the credit policy changes. Sample production files for human review, and turn every error found in production into a new test case. Over time, the test set becomes one of the most valuable assets a lending team owns.
As Jeff Bezos likes to say, good intentions don’t work; mechanisms do. Evals are the mechanism that turns “the agent seems to work” into a number you can show your credit committee and your examiner.
Five Questions to Ask Before You Deploy an Agent
Whether you are building agents yourself or evaluating a vendor’s, these five questions separate a demonstration from a production system:
- What is the success rate for the whole workflow, measured end to end, and on what test set? Not accuracy per step, and not on a hand-picked set of clean files. Ask to see the evals.
- Which steps are deterministic, and which rely on AI judgment? If the answer is “the AI handles all of it,” every step is probabilistic, including the ones that did not need to be.
- What catches the agent’s mistakes, and is it independent of the agent? A deterministic check or a deliberately different reviewer, not the same model looking at its own work.
- When does the agent stop, and who does it hand the file to? An agent that never stops is an agent that builds on its errors.
- For any file, can you see exactly what the agent did and explain the outcome to an examiner? If you cannot, the variation in its path is a risk you cannot manage.
Approaching 100%
Manufacturers using Six Sigma aim for 3.4 defects per million opportunities, about 99.9997%. They do not get there with perfect machines. They get there with redundancy, checks at every stage, and constant improvement of the process itself.
Agentic AI in lending will get there the same way. The goal is not an agent that never makes a mistake. It is a workflow that catches mistakes before they reach a borrower, a decision, or an examiner. Reliability is a property of the process, not the model.
That is also why I am optimistic. Lenders already know how to do this. Maker-checker controls, exception queues, quality control sampling, and model validation are part of every well-run lending operation. The work ahead is applying the same discipline to a new kind of worker.
If this was useful, please subscribe to Unconditional and share it with someone on your team who is evaluating AI agents.