One model of the loan. Shared by every system.
A lending ontology is one canonical model of your borrowers, applications, repayments, and risk — the single object your whole stack reads and writes through. Governed AI and your team act on the same truth, on a deterministic core, and every change is logged.
Most lending stacks keep a different copy of the loan
Your loan does not live in one place. Five systems each keep their own copy — and they drift.
Loan origination
Keeps the loan as it was approved.
Loan management
Keeps the loan as it is serviced.
Core ledger
Keeps the loan as it is booked.
Collections tool
Keeps the loan as it is chased.
Data warehouse
Keeps the loan as it was yesterday.
One canonical loan object
A lending ontology is one governed model of the loan — borrower, application, repayment, and risk, plus how they relate — that your whole stack reads and writes through. Instead of many drifting copies, there is one canonical loan object, and every system and every agent acts on it.
Passive storage.
A lake holds data and waits. The ontology is the live loan, with the actions you can take on it built in.
A copy after the fact.
A warehouse holds an analytics snapshot. The ontology is the loan as it actually is, right now.
One live, governed model.
Deterministic and idempotent, with maker-checker as a first-class control and an audit trail a compliance officer can certify.
The deterministic core
A deterministic core means the same inputs always produce the same outputs. Run a decision twice, get the same answer twice — no hidden state, no drift.
Replay any decision.
Every decision can be replayed from its inputs and reproduced exactly.
Apply twice, safely.
The same instruction applied twice does not double-charge, double-disburse, or double-book.
Nothing off the record.
Every state change is recorded, in order, on an append-only trail.
The entities the model resolves to
Borrower
One identity, fed by bureau, bank statements, and behavioural signals.
Application
The request, its terms, and the policy version that decided it.
Repayment
Every scheduled and actual payment, reconciled against the core and the GL.
Risk flag
The signals and breaches attached to the loan, live.
Agents reason over one truth, not five guesses
Governed AI doesn’t just act safely on the canonical object — it acts better. One resolved truth makes the agents faster, lets them reason across the whole loan, and keeps every move inside policy.
Act, don’t reconcile.
An agent reads one canonical object instead of stitching the loan together from five systems and settling which copy is right. It decides in the moment, not after a reconciliation step.
See the whole loan at once.
Borrower, application, repayment, and risk are one connected model, so an agent reasons across the full loan lifecycle — surfacing patterns siloed data structurally couldn’t link — insight a fragmented stack can’t reach.
Faster, still bounded.
Speed doesn’t cost control. Every action stays policy-bounded, the consequential ones — re-pricing, restructuring, who gets credit — pass through maker-checker, and the whole trail is logged.
The book sharpens itself the more it lends
Because every application, repayment, and recovery writes back to the same loan object, agents can test hundreds of pricing and underwriting rules against real outcomes — in the time a risk team usually ships one.
Instrument outcomes
Every repayment and recovery writes back to the canonical loan object — the book’s own ground truth.
Test rules against it
Agents run hundreds of pricing and underwriting variants against real outcomes, continuously.
Promote the winner
A human authorises the new policy version under maker-checker; the promotion lands on the audit log like any other change.
The outcome this is built to produce is profit per rupee disbursed — lower delinquency and better-priced risk as the book learns from itself. Lokta is pre-customer and co-designing with its first partners: this is the design intent, not a result being claimed.
What the lending ontology unlocks
One governed model, one audit trail — and capabilities a fragmented stack can only do in pieces. Each pairs with the control that makes it safe.
Real-time re-pricing
Adjust an offer the moment the borrower’s risk profile moves.
Policy-bounded · maker-checker on consequential changes · logged
Restructuring
Reshape a live loan’s terms against the canonical object, not a copy.
Maker-checker authorised · every change on the audit trail
Policy versioning and promotion
Version every policy and promote a new one cleanly.
Human sign-off to promote · the promotion is itself an audited event
Instant audit and regulatory reporting
Produce the record from the same trail the system ran on.
Audit-by-design · append-only · nothing reconstructed after the fact
Agentic servicing
Let agents handle servicing actions on the live loan.
Policy-bounded actions · consequential calls go to maker-checker
Continuous policy testing
Test hundreds of rules against real outcomes, always-on.
Winners promoted only under maker-checker · deterministic core makes results reproducible
Built by the people who built the rails
We did not arrive at lending architecture recently — we built the rails the industry runs on.
The open-source lending core.
Our team built it — the OSS core used across hundreds of institutions and dozens of countries.
Proven at scale.
Served 60+ lenders across 15 countries and 12M+ borrowers before M2P acquired it in 2022.
How it fits LOS, LMS, and servicing
The canonical loan object sits under what you already run — LOS, LMS, and AI loan servicing — and gives them one loan to agree on. It boards from your existing systems; you adopt modules one at a time, not a rip-and-replace.
Deploy where your book lives.
On-prem or in your VPC, with a structural audit trail your compliance officer can certify, and RBI-ready by default. Consent-backed data collection, a complete audit trail, and board-level compliance sign-off are hard to meet against a fragmented loan record. One canonical object is built to make them routine.
Built for engineering-led teams.
Polylithic modules you adopt one at a time, an OpenAPI surface, and extend-in-tree — you change the platform in your own codebase instead of waiting on vendor change requests.
Operate on behalf of your lenders.
Run lending for multiple lenders on one governed model, with per-lender policy versioning, maker-checker, and an audit trail that holds up to each lender’s own compliance review.
Frequently asked questions
- What is a lending ontology?
- A lending ontology is one canonical model of the loan — borrower, application, repayment, and risk, plus the relationships between them — that the whole lending stack reads and writes through. Instead of a separate copy of the loan in every system, there is a single canonical loan object that governed AI and people act on, with every change logged.
- Why do LOS, LMS, and core banking systems disagree on loan data?
- They disagree because each keeps its own copy of the loan and updates it on its own schedule. The loan origination system, loan management system, core or general ledger, and collections tool all model the same loan slightly differently, so the records drift and have to be reconciled — which is slow and, in regulated lending, an audit liability.
- What is a deterministic core in lending?
- A deterministic core means the same inputs always produce the same outputs — run a decision twice and you get the same answer, with no hidden state. It is reproducible, idempotent, and event-logged, which is what makes it safe to move regulated money on and to certify after the fact.
- What does “audit-by-design” mean for a lending platform?
- Audit-by-design means the audit trail is produced by the system as it runs, not assembled afterward to satisfy a regulator. Every state change lands on one append-only log in order, so the record a compliance officer certifies is the same record the system acted on.
- What is “profit per rupee disbursed”?
- Profit per rupee disbursed is the outcome the architecture is designed to produce — better-priced risk and lower delinquency as the book learns from its own lending. Because every repayment and recovery writes back to one canonical model, agents can test and promote better policy under maker-checker, and the book sharpens itself the more it lends. Lokta is pre-customer, so this is the goal the design targets, not a result being claimed.
Start a conversation
We’re working with a small set of co-design partners to put the lending ontology into production. If you run a book and the reconciliation tax sounds familiar, that’s the conversation we want — with direct access to the founding team.