Lending in the time of AI agents

Everyone's talking about AI and AI agents. It's either a menace that will wipe out all jobs, or a miracle that will fix everything. I wanted to write about what's actually going on, from the inside of a financial institution.

I'm Matteo, Chief Risk Officer at Defacto. Here's what we've built.

Defacto is a European fintech that finances SMEs through API, embedded in the platforms they already use. We've worked with AI for a while, went hard on Claude Code for engineering in Q4 2025, and went fully agentic in Q2 2026: agents now take real decisions across the company, from underwriting, collections and internal control to customer success and accounting reconciliation.

In a year, the number of businesses entering our funnel doubled. We launched new products and started work on a European banking licence (we're currently a French "Société de Financement"). But our headcount only went from 27 to 30. Here's how, and what we learned building, managing and monitoring our agents along the way.

Why

Rules hit a ceiling

At Defacto, AI agents now take real decisions across our credit chain: in underwriting, in collections, internal controls and inside the tools our teams use every day. They approve, decline or escalate, but always within a delegation of authority we wrote, the same one you'd give a more junior analyst.

We got here because rules plateau in SME lending. European SMEs file wildly different financial statements, many have thin credit histories, data is fragmented across countries (in France, there's no private credit bureau at all), and our partners expect an answer through an API in seconds. A rulebook can say no fast. It struggles to say yes well. Every new rule fixed one edge case and created two false declines.

Three kinds of AI in a lender

AI generally shows up in three places at a lender:

• AI for humans: agents that take or prepare decisions inside a framework. That's what this article is about.
• AI inside tools: models called by API that categorise bank transactions, extract data from financial statements and invoices, extract counterparties or block suspicious behaviour. They live in the technical chain rather than the decision framework: sometimes replacing deterministic rules, sometimes adding to them, often just turning raw data into KPIs.
• AI in products: tools your clients use on your platform. We've explored it, but that's a story for another day.

Think of a client's life with a lender in three stages:

• Onboarding: checking who they are and whether we can work with them.
• Loan: deciding how much to lend, then watching how it goes.
• Collections (if needed): getting repaid when a payment is late.

Every stage involves a risk decision, and that's where our agents sit.

Today our agents span 11 departments:

• In risk: document review, underwriting, portfolio monitoring, client & transaction monitoring, internal control and compliance, debt recovery, post-mortem reviews, and (of course!) an agent that QAs the others' decisions. Our eight risk agents all have their own policy, which is itself typically already past its tenth version.
• Elsewhere: sales, onboarding and accounting reconciliation.
• And everyone's own: the agents each employee builds for themselves, little chiefs of staff you could say.

How

Agents have CAP

Every agent we build rests on three things. You could call it CAP: Context, Actions, Policy.

• Context. What the agent knows: the borrower's financials, bank data, Banque de France data, our products and their covenants, what we're trying to achieve. An agent without context is nothing. Pure vomit at times.
• Actions. What it can do: the APIs and tools it's allowed to call. Read a document, query a database, approve or decline a loan, prepare a new repayment plan, send formal notices of default ahead of court proceedings, once a human approves, send an email, refer to a human.
• Policy. How it decides. A closed set of outcomes (for loan underwriting: approve, decline, escalate), exposure bands beyond which a human always decides, and limit rules it cannot bend. What it may do, and just as importantly, what it must never do. In practice, every agent has a live job description: mission, objectives, scope, permissions, limits, escalation.

"Agentic" doesn't mean the model does whatever it thinks best. It means it acts within a delegation of authority we wrote, versioned and can audit. Get one of the three wrong and the whole thing wobbles.

Some decisions are easy, others aren't. Reviewing an admin document has two dimensions: is it the legitimate template, and is it up to date? Assessing whether someone will pay you back, and why, is another level: so much context, so much open-finance data, and every lender's own products, covenants and profitability rules. Checking a document is ticking boxes. Deciding who gets credit is judgement. And before an agent can use your judgement, you have to write it down.

Three layers, like a hospital

Our decision chain works like a hospital. Rules and scoped tools are the triage nurse, the agent is the attending doctor, and a senior credit officer is the specialist called in for the hard cases.

• Rules and tools (triage): eligibility, KYB, fraud checks, transaction categorisation, …
• Agent (attending): reads financials and context, sets a limit, writes a reasoned decision memo, scans the press, …
• Human (specialist): escalations and every exposure above the agent's band.

The order matters. Rules and narrowly scoped AI tools run first: cheap, auditable, with little room to hallucinate. The agent only sees files that passed triage, and humans only see what the agent couldn't settle.

Debt recovery follows the same logic later in the loan's life: an agent triages late cases before they reach a certain lateness, and people handle the conversations that need a human. The agent also reads behaviour, not just balances:

• A borrower who keeps a promise gets patience.
• One who breaks a promise to pay, or reverses a direct debit they authorised themselves, shows what many would call bad faith, and gets fast-tracked up the escalation ladder.

Some actions carry legal weight. Our collections agent sends formal notices of default, but only when the case has reached the legal stage, no payment is paid or scheduled, and the escalation has run its course, including an explicit warning with a missed deadline. Every notice cites its evidence, passes a second AI reviewer that checks it against the policy, and waits for a human's approval before it leaves.

Building one agent takes about six weeks

Technically, our system lets us spin up an agent in under a minute. A useful one that performs is another story: a production-ready, fully grown agent takes us around 4 to 6 weeks. You can always compress it, but if you want to cover most cases and trust its autonomy, that's the timeline I've found works in our heavily regulated industry. It's obviously specific to everyone's environment: automating email replies is easier (and feels very 2025), while automating decisions in open heart surgery will probably take you longer.

1. Weeks 1 to 2: scope. What we want the agent to do, and not do (very important). Draft the policy, make sure the APIs are ready.
2. Weeks 3 to 4: test. It's live-ish and you throw more cases at it. You realise LLMs are no silver bullet, and it'll be a while before they take over. But you also hit a few wow moments, and you beef up the policy.
3. Weeks 5 to 6: iterate. It works reasonably well and acts like a decent employee: you spot things to improve and iterate on the policy. Then you ask what can be fully delegated, because by then you keep seeing similar situations where the agent is right almost every time, and your policy covers them well enough. Past that point the build is done and you're managing the agent day to day.

Drafting the policy is the humbling part. How do you put your daily decision making on paper? So much of it is in your head: implicit, second nature. Writing it down makes you challenge everything you thought you knew.

How you test depends on what you're building. A user-facing tool, like a new dashboard feature, is easy to test live with feedback, but you can't backtest it. An internal tool, like an LLM reviewing documents customers send us, can be backtested on past manual work, but testing it live needs real volume.

Before an agent acts on anything real, it runs in shadow mode: it decides, a human decides, we compare. Every new policy version is tested against a set of cases where we already know the right answer. And there's always a kill switch back to manual.

Build for models that change

Models come and go. A provider goes down, or ships a worse version overnight. So we never depend on one: our agents run on a platform where models are interchangeable, with automatic fallback from one provider to another, open-source included. Our data sits with a hosting provider that keeps us GDPR-compliant. And every agent is tested against its policy, so a model swap shows up in the monitoring before it shows up in the portfolio.

Managing a team of juniors who never get tired

Agent management is a lot of work. Just like managing people, minus the emotions and having to repeat yourself. It feels like running a team of juniors, except they're never tired. Strictly speaking they don't learn between runs: your policy does. Write a rule once, and it's applied on every file, every time, until you change it.

But they clearly need scoping.

• Avoid the Frankenstein effect. Every edge case you patch adds a limb. Months later your policy is a monster made of spare parts: it still walks, but nobody knows which way. Agents start doing nonsense, because the policy is nonsense. The cure: be super explicit. Only let them do what's explicitly allowed, and never do what's explicitly prohibited.
• No Swiss Army knife. One agent doing everything is a challenge to build and a nightmare to control. Small, specialised agents with a narrow mission are far easier to scope, test and trust.
• Leniency scales with the stakes. On a small scope you can leave room. Document review going beyond its brief? Fine. What's the worst that could happen, they don't like the header?
• Big tasks need a frame. Hand over four years of bank statements with no scope and you'll get vomit. Asset-based lending, overdrafts, cards, term loans: tagging transactions and reading patterns depends entirely on your use case. Give them a frame, or they won't analyse the situation the way you need.

You're harnessing a generalist. The harness is your job.

Every agent reports to a team, like any employee. Ours report to the risk team, and its head takes responsibility for every decision they make, exactly as for a human analyst.

How do you monitor an agent?

Risk teams already know how to govern a scorecard: validate it, track it, challenge it. European supervisors have long set out what they expect, from the ECB's guide to internal models to the EBA's loan origination guidelines.

Agents deserve the same discipline, with four questions I keep coming back to:

1. How much have I fully delegated? The share of decisions that no longer need a systematic four-eyes review. That's the real measure of autonomy.
2. How many situations does my policy cover? Can the agent categorise what it's doing? If yes, every situation has a clear action and expectation. If not, beware the weird behaviour: "I didn't know what to do because it wasn't specified, so I went YOLO on you."
3. Is it behaving consistently over time? I compare the agents' end actions across policy versions. Did I unknowingly introduce a change that doubled declines? Is it now sending emails when it should refer to a human? The same check applies when the underlying model is upgraded: new model, same policy, different behaviour.
4. How much do I agree with it? Probably the most important one. Set up a structured feedback loop at go-live, even on a POC. Every review logged at the click of a button: is the agent thinking and acting the way I expected? Track the late rate of agent-decided loans against human-decided ones, from day one.

That's where the UI becomes, surprisingly, a key piece of the puzzle. Nothing fancy needed. Plug it into your existing back office. Have the agent email you and reply Yes or No with feedback. Build it into Slack, Teams, Word, wherever. MCP gives you that freedom; enjoy it.

So what?

The real gain is standardisation

The time saving is real, but it sits in low-value, repetitive tasks. Building agents for day-to-day decisioning is still a lot of work, so much of your time simply shifts to reviewing what they do. The visible gains come first: time freed up, shorter lead times, faster reactions. But the bigger prize is elsewhere.

• Standardised decisions. The same policy applied the same way on every file. No more "it depends who picked it up".
• Four eyes on everything. Every action is checked, by a second agent or a human. Banks call it the four-eyes principle: no action counts until a second reviewer has checked it. For us, that second pair of eyes is either another agent or a human. During an agent's first weeks, it's humans on everything.
• Less operational risk. No tired employee on a Friday afternoon making an avoidable mistake. Agents miss far less in a 200-page file than we do, and never skip a step because they're exhausted. And no key-person risk: when someone central to collections left, recovery held up, because the process lived in the policy, not in one person's head.
• Perfect traceability. Every decision comes with its evidence and reasoning, reconstructable months later. We need explainability to trace decisions, and this is where regulators will find a lot to like. You can extrapolate this to every decision being made in your org. From approving a document to changing your credit policy.

One warning. If your process is bad from the start, agents just scale your mistakes. They're not the answer to everything, and they won't take you from 0 to 100 overnight.

The real prize is execution

When we reviewed our late loans, the uncomfortable finding wasn't missing rules. In 10 to 25% of cases, a rule we already had simply wasn't applied: a document approved that shouldn't have been, a check overridden without a real reason.

Agents do two jobs:

• First, they deliver: they close the gap between the policy you decided and what actually happens on each loan. We estimate that this gap alone is worth a few points of cost of risk, which in lending is the difference between a book that loses money and one that doesn't.
• Second, they do what rules never could: read a borrower's behaviour, spot a broken promise, weigh a messy file. That's a new lever, not just better execution.

It cuts both ways. The danger is a wrong policy applied perfectly to every loan.

What it costs, and what it replaces

Take one team: our operational risk desk (collections excluded) handling the day-to-day decisions around existing and new clients:

• Well over a thousand operations a month (every one of them runs through our governance framework so it's tracked, no matter how minor).
• Around 90% of these are fully automated.

Done by hand, each of those decisions takes an experienced operator around 15 minutes. That's roughly 300 hours a month, the work of two full-time experienced people. Today one person runs the team. Without agents, we'd be three. Each of those two extra hires would cost tens of thousands a year; our token bill is less than 3% of that.

And the job itself is better. Instead of grinding through validations, that one person handles the edge cases, QAs the agents and improves the policies.

That much automation makes QA non-negotiable, and that's where the freed time goes. In the first months of run-state, aim to QA a quarter to a fifth of all automated decisions. The rate can drop over time, as decisions start repeating each other and new policy versions get published and stabilise.

Agents crunch, you conclude

Like any decent employee who isn't C-level, an agent won't write your board report for you. It crunches data in minutes that would have taken days in the old world, the years BC: Before Claude. But it won't get the subtleties of your business, or read between the lines. When analysis becomes a commodity, your value add is choosing the three to five things that actually move the needle. Give it those conclusions (Context), a good tool (Actions) and a clear brief (Policy), and it'll prep the slides in five minutes.

Same for the portfolio. Running millions across products and geographies, how do you sleep at night? Brief the agent on what you manage and what to look for, and it'll review the book without needing a coffee at 3pm. It won't take you from burning VC money to strong EBITDA on its own. But it is a remarkable sounding board: it asks the questions you skipped, spots the pattern you missed and pushes back on your first conclusion. You still decide; you just decide better. Your LLM is a very good top-80% thinker; the last 20% that beats your competitor is still yours.

What next?

Your turn

First, let's demystify it. I've spent over ten years in tech and I'm not an engineer (sadly). So take this as the perspective of someone very close to (and interested by) the plumbing, but definitely not the one doing it. And honestly? It's impressive, but it's nowhere near impossible. Under the hood, an agent is a handful of fairly ordinary pieces:

• A model, called through an API. You don't train anything.
• Some tools, which are mostly the APIs you already have, wrapped so the model can call them.
• A policy, which is essentially… a text document. Yes, really. Your judgement, written down prosaically.
• A log, every decision with its reasoning, stored like any other bit of your data.
• A way to review it, an email, a Slack message, a button in your back office.

That's it. Think of it like onboarding a new hire: a job description (the policy), a laptop with the right access (the tools), the onboarding docs (the context) and a manager who checks their work (the review loop). Nobody calls that rocket science.

The hard part isn't the code. It's getting clean access to your data, and having the discipline to write down how you actually decide, and to iterate with focus. One engineer and our CTO made it look easy. It isn't trivial, but it's well within reach.

Fintech or agile lender? Honestly, what are you waiting for? You've got the APIs. You've got clean-ish data (let's be honest with each other). Your decision chain is three people and a Slack channel. Pick one boring, repetitive decision with real volume. Write the policy. Run it in shadow mode. Two weeks later you'll know if it roughly works. And every month you wait, someone else's cost per decision goes down while yours doesn't.

Bank? That's another story. And no, "AI" isn't the problem.

• Your IT is. Plugging an agent into a modern API takes days. Plugging it into a core system from the 90s that only talks in overnight batch files? Good luck. Reading data is doable. Letting an agent actually do something in there means security reviews, change committees, vendor-risk forms… you know the drill.
• Your org chart is too. Ten committees, one decision. So, who owns the policy? If nobody does, nobody can get it off the ground and nobody's accountable when the agent gets it wrong. And it will, at some point.

Now the good news: banks are closer than they think. Model validation, documented policies, first and second line of defence: you've been doing this for years. That's exactly the discipline agents need. Start read-only, start small, treat every policy like a scorecard, and you're already halfway there.

Fintechs are speedboats, banks are tankers (heading for the Strait of Hormuz). A speedboat turns this afternoon. A tanker needs to start turning now, because it takes miles to change course.

Whoever you are, don't start with credit decisions. Start where it's high volume and low stakes: document reviews, data requests, KYC refreshes. Get your wow moments there, earn the trust, then move up the chain.

Beyond lending

And it goes way beyond banks. Anywhere there's a pile of files, clear rules and people drowning in admin, the same pattern works:

• Social benefits: checking a housing or family allowance file is complete and eligible, and fast-tracking the simple ones.
• Public administration: building permits, business registrations, grant applications. Triage first, humans on the tricky ones.
• Health insurance: reimbursements and prior approvals, where most files are routine.
• Insurance claims: small, standard claims paid in hours, not weeks.
• Courts: sorting small claims and checking files are complete before a judge ever sees them.

But careful. In the Netherlands, an algorithm used to flag childcare benefit fraud wrongly labelled thousands of families as fraudsters and forced them to repay. The government resigned over it in 2021. A wrong policy, applied perfectly.

So for public services, here's a suggestion: let agents fast-track the yeses, and keep every no with a human.

Who trains tomorrow's experts?

Here's the question that keeps me up more than token bills: if agents do the groundwork, who's the junior climbing the ladder?

Aviation faced this decades ago. Autopilots got so good that pilots who rarely hand-flew lost the skill, and airlines answered with mandatory manual flying hours. Our version: almost everyone at Defacto drafts policies and reviews agent decisions when a manual review is warranted, and we rotate. Juniors still review documents, just the interesting ones the agents escalate. And they get to debate them with a new kind of colleague.

Agents are better than us at the maths and the crunching. That frees people for what matters: the reasoning behind the decision. The juniors of today aren't losing their apprenticeship. They're starting it higher up.

Neither miracle nor menace

So, menace or miracle? Neither. It's simply a new generation of technical progress.

In a year, the businesses entering our funnel almost doubled, we launched new products and started work on a banking licence, and we hired three people. Without agents, we'd have needed around ten more: about five engineers (our engineering output is up by roughly a third at almost constant headcount), around three in customer success and two on the risk desk. We'd be around 40, not 30. Not all of that is down to agents; product, partners and process played their part. But a big part of it is.

And nobody's job was written off. It changed. When cars replaced horses, the coachman became a driver and the farrier became a mechanic; stables turned into garages. The people were still needed, the investment simply went somewhere else. Same here: fewer validations, more judgement. Less typing, more reviewing. The money goes into tokens and tooling rather than headcount (by a much lower margin), and the people we have get to do more interesting work.

Trust doesn't rule out control

Good managers and leaders are only as good as the people they surround themselves with. Nothing changes with agents. Together, you make an A team. Alone, without context and guidance, it's a recipe for disaster: burning your company's life savings in tokens and running in circles, convinced you've missed the technology train once again.

There's no need to reinvent the wheel. LLMs are just another kind of employee: weirdly exceptional, sometimes idiotic. For now. God knows where we'll be in a year. Actually, make that six months.