The loan book that learns

The first two parts built to a single question. The separation between lenders is not the cost of money; it is the intelligence applied to risk — the quality and freshness of the probability estimates behind every loan. Digitisation made lending faster but left those estimates static, set once and ageing from the moment they ship. So: can a loan book learn? Can the judgment improve on its own, faster than a risk team can ship one revision a quarter?

I think the answer is now yes, and I want to explain why I believe it — carefully, because “AI will fix lending” is exactly the kind of claim I distrust when other people make it.

Let me start with the one idea in this essay I have not seen anyone else put at the centre, because everything else is downstream of it.

A loan book’s decisions are causal to its own future data. A self-driving system perceives a world it does not change — the road is the road whether the car reads it well or badly. A loan book is not like that. When the book prices risk better and selects borrowers better, it brings in better borrowers, who generate better repayment data, which sharpens the next model, which selects and prices better still. The book improves the very reality it then learns from. That is a compounding loop, not mere pattern recognition. As far as I can tell it has never been possible before in the entire history of credit. It is the reason a loan book can now do something a grain store never could: get smarter the more it lends.

The rest of this part is what that takes — to build it, to point it at the borrower, and to keep it from learning the wrong thing fast.

Why now?

The clearest way I know to explain why now is the self-driving car.

Autonomous driving did not arrive on one breakthrough. It arrived on a convergence of three things that all matured at once: sensors good enough to perceive the road, compute cheap enough to process what they saw in real time, and models that could learn from the outcomes of millions of miles driven and update accordingly. No single one of those was the unlock. The convergence was.

But there is a detail in how those models improve that matters more for lending than the convergence itself. A self-driving system does not get better by watching more of the straight road on a sunny afternoon. There is infinite easy data and almost nothing to learn from it. It gets better by hunting the interesting cases: the heavy rain that smears the lane markings, the road that narrows to a single track, the two cars that find themselves nearly head-on and have to resolve it. The learning lives in the hard cases. The easy miles are already solved.

A loan book now has the same three inputs available, today, for the first time.

The sensors are data. A lender can now see a borrower with a richness that was simply not available a few years ago: the credit bureau record, but also, in India specifically, the Account Aggregator framework — which lets a borrower consent to share their own bank-statement data securely — and the UPI rails, which leave a fine-grained trace of how money actually moves through a life. That is behavioural and financial perception of a borrower at a fidelity the grain-store keeper, who had only reputation and a handshake, could not have dreamed of.

The compute is cloud. The cost of running and retraining models has fallen to the point where it is no longer a constraint on how often you can update your judgment. You are not rationing computation the way a risk team rations its own time.

And the models can now be retrained on what actually happened — on realised repayment outcomes. Every loan that pays, every loan that slips, every recovery that lands or doesn’t, is a labelled example of whether a past probability estimate was right. The model that decided can be confronted, continuously, with the consequences of its own decisions, and corrected.

Here is where the self-driving detail earns its place. The easy borrower — thick credit file, salaried, long history, obviously prime — is the straight sunny road of lending. Every lender can already say yes to that person, and a model learns almost nothing new from getting an easy yes right. The value, and the difficulty, is in the hard-to-read borrower: the thin-file applicant a static rule waves away because it cannot see them clearly, not because they are a bad risk. That is the corner case. And the corner case in lending is not an edge condition on a road. It is a person — someone who could repay, productively, if a lender were sharp enough to read them. A book that learns is a book that gets better, turn after turn, at exactly the cases the blunt rule gives up on.

Now hold the causal loop from the top of this part against that. A self-driving car, learning, reads the same road better. A loan book, learning, changes who is on its road. It selects better borrowers, who pay more reliably, which gives it cleaner data to select on next time. The compounding is what makes this more than faster scoring. The judgment about risk, which for all of history could improve only as fast as a human could observe, conclude, and revise, can now improve at the speed of the data the book itself produces.

That is the prize. The rest of this essay is mostly about the discipline it demands — because a loop that compounds good judgment will compound bad judgment just as fast, and faster is not automatically better.

What does a learning loan book look like?

Concretely, then.

It looks like risk-based pricing that actually moves — where the rate a borrower is offered reflects that specific borrower’s risk, set at origination by a model that has learned from the last cohort, rather than a coarse rate-card written two quarters ago and applied to everyone in a band.

It looks like early-warning systems inside the portfolio — the book watching its own live loans for the faint signals that precede trouble, and adjusting exposure before an account goes bad, rather than discovering the problem in a delinquency report after the money is already lost. Most lending today is reactive: it learns a loan was bad by watching it default. A learning book is anticipatory.

And it looks like collections that learn, which deserves more than a clause, because collections is where a lot of lenders quietly lose the money underwriting tried to protect. Recovery is not a script; it is people and operations — feet on the street, telecalling, settlement, and, at the end, legal — run across many states and languages at once. A learning book brings ground truth to that work the same way it brings it to underwriting. It can predict, account by account, the probability a delinquent loan cures on its own versus needs intervention, so scarce field effort goes where it changes the outcome rather than where the spreadsheet sorts it. It can learn which channel and which sequence — a reminder, a call, a field visit, a restructure — actually works for a particular borrower, instead of firing one dunning routine at everyone. And it can learn when a settlement recovers more, sooner, than chasing the full amount through a process that costs more than it returns. Every recovery that lands or doesn’t is another label. Collections, done this way, is not the sad end of the loan; it is one of the richest sources of truth the book has.

Put those together and you get a flywheel I can state in one breath: more loans produce better outcome data, which produces sharper models, which produce lower credit cost and more accurate pricing, which win more loans — which produce more data. Round it goes, and each turn tightens. The headline number it drives toward, the one I would hold the whole thing accountable to, is profit per loan disbursed — not how much you lend, but how much you keep for every rupee you put out.

The borrower

Now the part that matters most to me, and the reason I find this worth building rather than merely interesting.

It would be easy to read everything above as a story about lender profit. It is not, or not only. When risk is priced accurately, two things happen to borrowers, and both are good.

The first is that more people get in. Every static, blunt underwriting model has a hidden cost: the false negatives — good borrowers it wrongly rejects because it cannot see them clearly. These are the corner cases from a moment ago, and this is where the analogy stops being an analogy. The thin credit file is not a bad borrower; it is a hard-to-read one. A coarse model treats the two as the same and turns away someone who would have repaid. A model that learns from richer data and real outcomes can tell them apart. It can say yes where a blunt rule said no, correctly.

Inclusion is, in large part, an accuracy problem wearing a moral coat — and the gains from accuracy land hardest precisely on the people the old rule could not read.

The second is that credit gets cheaper for the people who deserve it. In a book that prices everyone roughly the same, the good borrowers are quietly cross-subsidising the bad ones — paying a higher rate than their own risk warrants to cover losses they didn’t cause. Accurate, risk-based pricing ends that transfer. The borrower who is genuinely a good risk stops paying for someone else’s default and starts paying for their own, lower, real risk.

India has hundreds of millions of underserved credit-seekers — people who could productively use credit and either cannot get it or get it only at the punishing rates that blunt risk assessment forces on everyone it can’t read. If the loan book learns, that number shrinks. Not as charity. As a by-product of pricing risk correctly. That is the purpose, not the product.

It is also, in the end, the only durable way to build a financially valuable lender. You do not build a great lending business by chasing the profit directly, any more than you reach happiness by pursuing happiness directly. You build it by making something genuinely useful — pricing fairly, including the people the field wrongly excludes, getting the hard borrower right — and you let the profit follow. A lender that optimises for extraction ages badly; the book it builds is brittle and the borrowers it keeps are the ones with nowhere better to go. The test I’d hold any lending business to — the test I hold ours to — is simple: does it make more than it takes? A learning book, pointed correctly, is the most reliable way I know to keep answering yes.

Which is the whole moral of this series, and the line I’ll stand behind: the loan book that learns, wins. And when it wins well, everyone wins. The lender’s self-interest and the borrower’s inclusion turn out to point the same direction. Accuracy serves both.

Who is saying this?

Before I describe the machine we are building, you should know who is making the argument, because it changes how much weight any of this deserves.

The team behind Lokta built Apache Fineract, the open-source lending core that grew out of the Mifos community. Between them, Fineract and Mifos deployments have reached more than 20 million borrowers across 400+ financial institutions in dozens of countries, with an estimated $500 billion+ in loans disbursed over their lifetime, and Fineract is recognised as a UN-backed Digital Public Good.1 The same team went on to build and scale a commercial lending platform on those foundations. We have run loan books at scale, under regulation, where being approximately right is not good enough and the ledger has to tie out to the rupee.

I want to be honest about what that does and does not prove. It proves we can build a core — the system of record that holds the money, the ledger that has to be exactly right, the audit trail a regulator can lean on. It does not, by itself, prove the learning layer. That is the new bet. But it gives us the one foundation the learning layer cannot do without: a core that is correct, real-time, and provable, built by people who learned the hard way what a ledger has to guarantee. Put a clever model on a shaky core and you get fast, confident, unaccountable mistakes. The order matters, and we are building the learning on top of a core we already know how to make right.

Where does Lokta fit?

So how do you actually run a book like this — and why is it hard to copy?

Start with the foundation. In the first part I argued that money is, at bottom, information. If that is true, the infrastructure we run it on ought to be worthy of its information-nature, and mostly it is not. Elon Musk described the legacy financial system as “a large number of heterogeneous databases with batch processing that are not secure,” when what money really wants is “a single database that is real-time and secure.” That is the gap a lending core has to close: most lending systems are slow where money is instant, batched where money is continuous, and unprovable where money has to be accounted for to the rupee. You cannot run a book that prices and decides in real time, and has to show its work, on rails like that.

So Lokta runs on a deterministic core: the ledger and the money-of-record calculate by code that produces the same answer every time it runs, never by a model that guesses. Real-time, not batched. Provable, not approximate. The same inputs always yield the same number, and the system records the proof.

On top of that core sits the learning — and here is the mechanism I would point to if you asked what an incumbent cannot bolt on in a quarter. It is not the models; good models are increasingly available to everyone. It is the integrated whole: a deterministic core that is correct by construction, a governed experimentation engine that can test many underwriting and pricing variants against real outcomes safely, and a control I’ll describe in a moment — maker-checker on the learning loop itself. Provable, governed, continuous policy testing is the product. A lender can buy a model. It cannot easily buy the ability to run hundreds of policy experiments against its live book, prove what each one did, and promote the winners under control — because that requires the core, the experimentation layer, and the governance to have been designed together. That is years of work, not a quarter of integration, and it is the thing we have spent two decades learning how to build.

There is a fair objection to all of this, and it is the first one a sharp reader should raise: we are pre-customer. We have run no loans of our own. A flywheel that compounds on a book’s own data has nothing to compound on the day the book opens. So how does loan number one get priced well, before the book has learned anything?

The honest answer is that the flywheel is per-book, and it starts at go-live, not before. What a new customer starts with on day one is not a blank model. It is the domain priors built into two decades of running lending systems: sensible structures for the products, the bureau and Account Aggregator signals, the policy shapes that tend to work. The first cohort is priced on informed judgment, not a guess. From the first cohort onward, the experimentation engine begins learning from that lender’s own borrowers, and the loop starts to turn. Compounding belongs to the lender and their book; it begins the day they go live and tightens from there. We are not selling a book that is already smart. We are selling the machine that makes a book get smarter, and the credibility of the people who built the rails it runs on.

Governance, done right

I spent the first two parts insisting that judgment is everything. So none of this is allowed to be magic. The learning sits above the deterministic core and is governed, and the governance rests on a few principles I take seriously enough to build the whole stack around. Each one is also where a careless version of this idea would do real harm, so let me be specific about the limits.

Learn from what happened — and confront what you cannot see. A learning book must learn from realised outcomes, not a risk team’s stale assumptions about who ought to pay. But realised outcomes have a blind spot I will not paper over, because it cuts directly against the inclusion claim I just made. You only observe repayment on loans you approved. The applicants you rejected generate no label — you never find out which of them would have paid. A model trained naively on its own approvals learns to be confident about the borrowers it already says yes to, and learns nothing about the ones it turned away. Left alone, that quietly narrows the book over time, which is the opposite of inclusion. The discipline is to confront the blind spot directly. Reject-inference models how the rejected population would likely have performed; and where the model is genuinely uncertain, the book learns from a small, governed test budget — a capped share of marginal applicants, approved only where the loan clears affordability and suitability on its own merits, sized so the cost of learning is bounded and provisioned for in advance, and run under the same maker-checker gate as any other policy change. We learn at the margin deliberately; we never lend to someone the loan is wrong for in order to study them. Alongside it runs out-of-time, through-the-cycle validation — testing a model against periods and conditions it was not trained on, so it is not merely good at the recent weather. A book that learns only from its own past approvals is a book that learns to agree with itself. The point of the learning is to keep finding the borrowers the old policy was wrong about.

Bound what the model may use — and test, continuously, whether it found a way around the bound. A model left to chase accuracy with no constraints will happily discover that a forbidden attribute — caste, religion, gender — correlates with repayment in its data, and start reasoning from it. So those attributes are bounded out: the model is not permitted to use them. But the easy claim here is wrong, so let me be precise. Removing a protected attribute does not guarantee the model cannot find a proxy for it — proxies hide in pincode, occupation, device, name, a dozen correlated signals. So the guardrail cannot be a one-time exclusion. It has to be a continuous test: disparate-impact testing that runs against the model’s actual decisions and watches for unfair outcomes against protected groups, whether or not the attribute was ever in the data. The exclusion is necessary; the ongoing test is what makes it real. We bound what the model may believe, and then we keep checking that the boundary held.

Make the proof a by-product of the decision. Most failed audits are not failures of conduct. They are failures of memory — the institution did the right thing, but the information needed to prove it was never captured at the moment of the decision, so after the fact it simply does not exist. You cannot reconstruct what was never recorded. So every state-change in Lokta writes its own evidence at the time of the change. I want to state the limit honestly: recording the state-change is necessary, not sufficient. For a model that is continuously retrained, “explain the decision” cannot mean re-deriving one eternal answer — the model that decided last quarter is not the model running today. What audit-by-design buys you is the ability to reconstruct what the system did, on what evidence, and under which policy and model version — to pin every decision to the exact version of the policy and the model that made it, and the data it saw. Not a promise that the system can always re-derive the universe; a guarantee that nothing relevant was thrown away, and that every decision is anchored to the versioned thing that made it. That is what we mean by audit-by-design: provenance produced as a consequence of deciding, versioned, so the book can learn and you can still own it, change it, govern it, and prove it.

The brakes, not just the engine

A loop that learns fast can learn the wrong thing fast. An operator I respect put it to me as: show me the brakes, not just the engine. Fair. Here are the failure modes I worry about, and the control I trust against them.

The control I trust against all of these is the same, and it is the strongest under-used idea in this whole essay: the learning loop is itself under maker-checker. Winners are proposed, not deployed. A new policy or pricing model that beats the incumbent in testing does not go live on its own. It runs as a challenger in shadow mode first — scoring real applications alongside the live champion, generating outcomes, proving itself against the champion on data neither has seen — and a human gate promotes it: a credit committee, a maker-checker step on the change itself. The machine finds the candidates and makes the case with evidence. People decide what the book is allowed to become. Automating the search for better policy while keeping a human on the promotion of it is the whole design. The speed lives in the search; the brake lives on the promotion. That is how you get a book that learns fast without letting it bet the institution on something it learned last Tuesday.

Where I might be wrong

A real argument should name the place it could fail, not just the places it wins. Here is mine.

The thing I have sold you as inclusion — a book that learns to read the borrowers the field gets wrong — could, in the same motion, concentrate advantage rather than spread it. The loop rewards data, and the lender with the most data compounds fastest. A large incumbent that adopts this well could pull further ahead of everyone else, and the very borrower I keep calling the prize — the thin-file person whose first real credit history this book creates — generates data that accrues to the lender, not to them. The borrower gets included; the borrower does not own the asset their inclusion creates. It is possible the end state of a learning-loan-book world is not broader credit owned by many, but sharper credit owned by a few, with the included borrower a richer input rather than a freer participant. I do not think I can fully defeat that objection. It is real.

Here is why I bet anyway. The alternative — keeping the judgment static so no one can compound it — does not protect the thin-file borrower; it just leaves them rejected by a blunt rule instead of read by a sharp one. Concentration is a problem of who runs the learning and under what terms, and that is a problem you can shape: with portability of a borrower’s own data, with the Account Aggregator architecture that already puts consent in the borrower’s hands, with open foundations rather than closed ones, and with more lenders able to run a learning book rather than fewer. Building the capability and keeping it ownable and governable is, I think, a better answer than refusing to build it. So I am building it with my eyes open about how it could go wrong — which is the only honest way to build something this powerful.

The oldest question, finally answerable

Step all the way back to where this started. The grain-store keeper, lending seed against a harvest he could not see. Every advance in lending since has been an advance in one thing: how well a lender can tell a good risk from a bad one, at a distance, at speed, at scale. That was the question at the grain store. It is the same question at the NBFC. For all of history, the answer improved only as fast as human judgment could observe and revise.

For the first time, the answer can improve on its own — and improve the world it learns from as it goes. That is what’s new. That is why now. And the discipline around it — train on truth and confront its blind spots, bound the model and keep testing the bound, record the proof and version it, and keep a human on the promotion of every winner — is not a tax on the learning. It is what makes the learning safe enough to trust with other people’s money.

Here is what we’re building toward, stated as plainly as I can:

We are early, and we are founder-led. We work with design partners, not procurement — lenders who want to build this with us rather than buy it past us. If that’s the kind of book you want to build, and you’d rather build it with the people who built the rails than buy it from someone who didn’t — start a conversation with us.

Frequently asked questions

---

Read next:

• What money actually is — Part 1: how capital flows through India’s lenders, and why the NBFC is the most exposed node of the whole cascade.
• The price of money is uniform. The outcomes are not. — Part 2: the cross-section and the cycle both say the gap between lenders is intelligence about risk, not the cost of capital.
• AI in lending: why a deterministic core — the three-layer architecture — deterministic core, workflow AI, agentic AI — the learning loop sits on.
• The agent-native lending stack — how Lokta is built: agents run the book, a governing control plane keeps every move provable, on a deterministic core.

---

---

Chandramouli is co-founder of Lokta. He is building the machine that makes a loan book get smarter — on a core you can own, change, govern, and prove — and is on LinkedIn for lenders who want to build it with us.