Home / DPA Insights / Private Credit
Building for Judgment, Not Just Reading
Break the work into distinct roles and every step becomes visible, checkable, and auditable.
Automating funding requests was never about reading the numbers off a page. It was about the judgment behind them. The system is built around the questions a good reviewer asks: Which agreement governs this? Has it been amended? Do the numbers reconcile? Which exceptions need a person? Five specialized agents mirror a review team, so every step is visible, checkable, and auditable, and you can see which agent flagged something and why. Running our own model shaped the output around the workflow, kept sensitive credit documents inside a controlled environment, and kept cost predictable — at the price of owning setup, tuning, and maintenance. The person still owns the judgment. What changes is where their time goes.
In the first field note, we landed on an uncomfortable truth. Automating funding requests was never about reading the numbers off a page. It was about the judgment behind them. A clean pipeline once approved a request against an advance rate that two amendments had already overwritten. The arithmetic was right. The answer was wrong, and a reviewer caught it, not the machine. That reframed the whole project.
Designing around the questions, not the fields
A good reviewer doesn’t read a funding request top to bottom and stop. They interrogate it. Which agreement governs this? Has it been amended? Do the numbers reconcile? Which exceptions need a person?
So, we built the system to ask the same things.
Instead of one model doing everything, we split the work across specialized agents that mirror how a review team operates. One analyzes the funding request. Another reads the credit agreement. A third hunts for amendments. A fourth checks the calculations. A fifth produces structured output and exception reports.
Here is the part that mattered most.
Break the work into distinct roles and every step becomes visible, checkable, and auditable.
When something looks off, you can see which agent flagged it and why. That is the difference between a black box and something a reviewer can trust.
We never set out to replace human judgment. The aim was to take on repetitive analysis, surface the exceptions, and leave people in control of the decisions that count.
| Agent | What it does |
|---|---|
| First | Analyzes the funding request |
| Second | Reads the credit agreement |
| Third | Hunts for amendments |
| Fourth | Checks the calculations |
| Fifth | Produces structured output and exception reports |
Why we run our own model
One early decision shaped the architecture more than any single feature. We chose to run our own model rather than leaning on a general-purpose service.
Three things drove that decision.
- We could shape the output around this exact workflow rather than bend our process to someone else’s tool.
- The pipeline stayed inside an environment we controlled — which matters when you are handling sensitive credit documents.
- The cost stayed predictable rather than climbing with every document processed.
That choice wasn’t free. Running your own model means owning the setup, the tuning, and the maintenance. But for a workflow this specific and this sensitive, the control was worth it.
What the platform actually does
In practice, the platform reads a funding-request packet, identifies the governing agreement and the amendments that apply, lays out the inputs behind the calculation, and flags the exceptions worth a closer look.
What matters isn’t that it’s clever. It’s that the first pass is faster and cleaner, with a clear audit trail, and exceptions surfaced early rather than found late.
In early testing on a limited sample, work that took a skilled reviewer most of a day came back from the first automated pass in well under an hour, ready for review. That’s a small number of cases, not a production benchmark, and we’re careful about that distinction. The speed only counts because the pass is one a reviewer can trust.
Think about what that does to a reviewer’s day. Instead of grinding through routine packets from morning to evening, they spend their time on the handful of deals that are genuinely tricky. The amendment that doesn’t quite line up. The exception that needs a judgment call. The conversation with the deal team that a spreadsheet can’t have. That is the work they trained for, and it’s the work the packets used to crowd out.
The person still owns the judgment. What changes is where their time goes. And the work that used to live in one person’s memory becomes a repeatable, documented process. It doesn’t walk out the door when they do.
Where it stands
But the real takeaway was a shift in framing, from automating a process to understanding how AI, domain knowledge, and human expertise solve a real operational problem together.
The lesson holds anywhere expert judgment sits between a document and a decision.
In private credit, the judgment is the work, and automation earns its place only when it respects that.
Previous — Field Note #01Why Extraction Was Never the Hard Part
Start with the questions reviewers already ask.
Where does judgment sit in your credit workflow?
If your team reviews funding requests against amended credit agreements, we will start with the questions your reviewers already ask, and show where a first pass can surface the exceptions early.
Book a working sessionFrequently asked questions
Why isn’t data extraction enough to automate private credit funding requests?
Because automating funding requests was never about reading the numbers off a page. It was about the judgment behind them. A clean pipeline once approved a request against an advance rate that two amendments had already overwritten. The arithmetic was right. The answer was wrong, and a reviewer caught it, not the machine.
How do specialized AI agents review a private credit funding request?
Instead of one model doing everything, the work is split across specialized agents that mirror how a review team operates. One analyzes the funding request, another reads the credit agreement, a third hunts for amendments, a fourth checks the calculations, and a fifth produces structured output and exception reports. Every step becomes visible, checkable, and auditable, and when something looks off, you can see which agent flagged it and why.
Why run your own model instead of a general-purpose AI service?
Three things drove the decision. The output could be shaped around this exact workflow rather than bending the process to someone else’s tool. The pipeline stayed inside an environment the team controlled, which matters when handling sensitive credit documents. And the cost stayed predictable rather than climbing with every document processed. The trade-off is owning the setup, the tuning, and the maintenance.
Does AI replace the credit reviewer?
No. The aim was to take on repetitive analysis, surface the exceptions, and leave people in control of the decisions that count. The person still owns the judgment. What changes is where their time goes: to the handful of deals that are genuinely tricky rather than routine packets.
How much faster is an automated first pass on a funding request?
In early testing on a limited sample, work that took a skilled reviewer most of a day came back from the first automated pass in well under an hour, ready for review. That is a small number of cases, not a production benchmark. The speed only counts because the pass is one a reviewer can trust.
