Consumer and commercial QC, documentation verification, credit reports, CTRs, invoices, vendor contracts, SOC 2 reviews — captured once, run by anyone, the same way every time. On real files, with an audit trail an examiner can follow.
Start with yourself. Then move across — nothing gets rebuilt between these stops.
Lending QC before a loan funds, the member on line two, the vendor file, the printer. The right way to do each job lives in your head and nowhere else — and the automation the big shops get from their core or LOS was never in your budget.
Drop the packet in. Watch every document get identified and indexed, the credit memo tie out against the executed note term by term, and the findings come back with the requirement behind each one — including the ones where it asks a person to look.
One run, and every report the file needs comes with it — the memo comparison, the collateral read, and the borrower’s obligations, each one cited to the documents it came from.
No sound needed — the captions carry it. Under two minutes.
Sample file · no borrower data
Frontier AI reads a loan file today. It will read it better in six months, and we won't have to do anything for that to be true — we didn't build the model, and not building it was the point.
The hard part is everything a bank needs before it can use that. You can't point it at real borrower data. You can't get the same answer twice. You can't show an examiner how an answer was reached. You can't keep it current when a state changes its lending law. And you can't get it past the one person who figured it out.
That's what we built. Not the intelligence — the way an institution actually puts it to work.
Not a category. Specific work that specific people do, badly served today.
Truth in Lending compliance, Reg Z alignment, fee disclosure accuracy, and calculation verification. Catches missing disclosures and terms that drifted between the quote and the final documents.
Policy adherence, covenant compliance, three-way alignment between the credit memo, the closing docs, and the core. Attorney-prepared language in all its variations.
Proof of income, residency, insurance, and stipulations — checked before funding rather than discovered after closing.
Turn a report nobody wants to read into a page anyone on the team can act on. Same format, every time.
Consistent, complete, and documented — on the same schedule, without the Friday scramble.
Somebody on your team hates this. It takes real time and produces nothing anyone thanks them for.
Read what you're actually agreeing to and what the report actually says. Surface the exceptions, the carve-outs, and the controls that aren't there — before the file goes in the vendor management binder.
Every institution has exceptions that don't look like anyone else's. That isn't a gap in the product — that is the product. Tell us yours and we'll build the notebook with you.
Everything below is written down somewhere. Each layer is more specific than the one above it. None of them reach the call on a single document.
None of that is in your policy. None of it is on a checklist. It gets passed along at a desk, and every institution's version is a little different — because it was learned from your files, your examiners, and your last ten years.
Which is why you can't buy it. A rules engine gives you the layers you already have. The gap is yours, and today it's carried by people rather than by the institution.
Write each one down once, and it stops being one person's memory.
This is what “institutional knowledge” is supposed to mean — and usually doesn't. Right now that knowledge isn't the institution's. It's Maria's, and the institution is renting it until she retires. Capturing the gap is how it actually becomes yours. Nothing about how your team works has to change; the difference is that the judgment gets recorded on the way past instead of evaporating.
Ask your best reviewer how they work a file and they'll tell you. It isn't in the policy manual and it isn't in the core. It's in their head, and maybe on a page somewhere — the order they check things, what they treat as a real exception, what they wave through.
Early Apple made digital things look like the physical things they replaced, so people knew what they had. A yellow pad with ruled lines told you: this is where you write down how something is done.
That's exactly what this is. Except when you write it here, it runs — and it keeps running after you've gone home, changed roles, retired, or are six feet under.
A notebook is one real file on your machine, with its own extension. Every document, every artifact, every finding and every conversation about that piece of work lives inside it — the way a workbook holds your sheets rather than scattering them.
Open it, work in it, close it, back it up with everything else you back up. It's a file. You already know how those work.
Chat is useful, and your team has probably already found that out. One person asks a good question and gets a good answer. Then the session ends and the value goes with it.
| Chat | Scout Notebook | |
|---|---|---|
| Who benefits | The person asking | Everyone who does that job |
| Repeatable | Depends on the prompt, and the day | Same input, same output |
| Built for banking | You teach it | Fifty states of lending law, day one |
| Stays current | However you left it | Updated when the rules change |
| Output | A conversation | Findings with source, requirement, and basis |
| When they leave | The method leaves too | The method stays |
Drag them in. No portal, no ticket, no onboarding project.
Compliance gaps, missing documentation, calculation errors, policy exceptions — each tied to the requirement behind it.
Confirm, dismiss, annotate. Nothing resolves itself. You control what reaches the report.
Now it isn't something you did once. It's a procedure your whole team runs the same way.
Most tools stop at 03. The gap between one person got a good answer and the institution got better is step 04.
You already have a procedure manual.
This is the one that runs.
Most institutions we talk to are already using something. Sometimes it's Copilot, because it came with the Microsoft agreement. Sometimes it's ChatGPT, because somebody got curious — often on their own dime. Either way, it wasn't a mistake. It's the reason this conversation is easy.
Those tools gave one person more power, and they're good at that. What they can't do is come to work at a bank: they don't know what belongs in a loan file, they can't be pointed at a real borrower's documents, they won't answer the same way twice, and they can't hand what one person learned to the next desk.
Scout Notebook doesn't replace that. It's what happens next.
Most of the market is racing toward the smallest model that mostly works. For summarizing an email thread, that's the right trade.
There's someone's mortgage in that file. We'd rather spend our engineering on running the top model efficiently than on running a cheaper one and hoping. Model quality is not where we look for savings.
Scout isn't built on one model. The engine underneath orchestrates whichever frontier model is right for the work, and swapping one for another is our problem, not yours — your notebooks don't change, your procedures don't change, nobody retrains.
Today a lot of that work runs on Anthropic, because we like where they are on capability and on safety. That's a current judgment, not an architecture. In eighteen months the best model for a loan file may come from somewhere else, and if it does, you'll get it without a project.
How the data moves and where it rests. The two connections that leave your machine. How the banking logic stays current, why Scout stops rather than run stale, how it knows when it read something wrong, and what a person — not the software — always decides.
Every claim on it is a term in our subscription agreement, not a marketing statement.
Or email contracts@visionfi.ai directly.
We hear these every week. Here's where we stand.
No — and that's deliberate. Scout calls frontier models through their providers' APIs, and we use the most capable ones we can put behind the work. They get better every few months and Scout gets better with them, without you doing anything.
What we build is everything a bank needs around that model, which is the part nobody was building. The banking knowledge: what belongs in a loan file, how fifty states differ, which attorney phrasings mean the same thing. And the safety and privacy architecture: zero data retention, documents that never reach our systems, a per-transaction audit trail, and human review required at every consequential decision.
A model on its own can't be pointed at a borrower's file. That gap is the whole product.
You probably don't need to stop. Both are good at making one person faster — and whether your institution bought Copilot or somebody quietly got good at ChatGPT, that was the right first move. What it can't do is work a real borrower file, produce the same answer twice, cite its basis to an examiner, or hand what that person learned to the next desk. That's the step Scout takes.
Usually what happened is one curious person got real value out of chat and it stopped there. That's not a failed technology — it's a missing step. The step is making what they figured out repeatable for everyone else.
The chat window, yes. That part is a weekend.
What takes years is everything else: the taxonomy across fifty states of lending law, the attorney phrasing variations, versioned domain logic, an audit trail an examiner will accept, the security architecture — and someone whose job is to keep all of it current, permanently. That's a program with headcount attached, standing in for something you can subscribe to per seat.
If somebody on your team wants to price it out, we'd encourage it. The comparison tends to make our case better than we do.
Possibly nothing you can see in a demo. That's the honest answer, and it's the problem.
Anything can be made to read a loan file and produce a page of confident-looking findings. What separates tools is what happens on the values it got wrong, or couldn't read, or read from the wrong box on the page — and none of that surfaces in a demo, because a demo is built from a clean file.
So here's a fair test to run on any vendor, us included: ask to see a review where the tool wasn't sure. Not one where it found something — one where it couldn't tell, and said so, and showed you why. Most tools can't produce that screen, because they were built to always return an answer.
A $24M credit union and a $40B bank look nothing alike on paper. Set charter type and asset size aside and you find the same person: too many hats, a stack of exceptions, and a way of doing things that's better than anyone else's and lives entirely in their head.
We build with those people. Not for them — with them. We know how to make this safe, private, and repeatable. We don't know which exceptions matter in your shop. Only you do.
Scout runs on the workstation your employee already has. There's no environment to provision, nothing of yours for us to store, and no scaling curve. That's why this doesn't price like a platform — and why nobody needs to build a business case for it.
Not a roadmap. Not a platform evaluation. One thing on your team's plate that takes too long and produces nothing anyone thanks them for. We'll show you what it looks like as a notebook.
Or email sales@visionfi.ai directly.
The commitments on this page — the data path, the updates, the offline stop, the regulator exit — are terms in our subscription agreement, not marketing claims. Ask for the agreement at contracts@visionfi.ai and check any of them before you sign anything.
You already have a way of doing this. The order you check things. What counts as a real exception. What you wave through because you've seen it a thousand times. None of it is in the policy manual — it's in your head, and every stack that lands on your desk goes through it one page at a time.
Scout runs your method, on every file. Drag documents into a notebook and it works the file the way you would — compliance gaps, missing docs, calculation errors, policy exceptions, each tied to the requirement behind it. You confirm, dismiss, or annotate every finding; nothing resolves itself. The difference is you're reviewing findings instead of hunting for them, and the hunting was most of the day.
It admits when it can't tell. Every value comes from one named spot on one named document and gets checked twice. When something can't be settled — a bad scan, two documents that disagree — it says review and asks you, instead of guessing confidently. You stay the judge. It just never gets tired on file forty.
And your way of doing it stops being unwritten. Save the method as a notebook and the person covering for you runs it exactly the way you would — not the way they'd improvise it. That's not replaceability; it's finally getting credit for the method being yours.
The work between the loans is the problem. You're paid to lend, and half the week goes to everything wrapped around it — making sure the closing docs match the memo, chasing stips, re-reading a credit report that's formatted like a ransom note, the QC scramble before funding.
Scout takes the wrapper, you keep the judgment. It checks the file three ways — credit memo against closing docs against the core — flags what's off, and cites the requirement behind every flag. It reformats the credit report into a page you can actually read. It never approves, prices, or declines anything; contractually, those calls are yours, made by you, at the moment you make them.
Your best habits become the branch's. The way you review a commercial file is better than the way it's done two desks over — and right now it only happens when you're the one doing it. Written into a notebook, it runs the same on your files and theirs, on a Monday morning and a Friday at 4:45.
Starting costs you one conversation. Pick the task you hate most. Ten minutes to set up, on your own machine, no IT ticket. If it doesn't earn its seat, it's one seat.
You're the person this whole thing was built for. At your size there is no QC department, no compliance team, no analyst — there's you, doing the lending QC before a loan funds, the member calls, the vendor file when the examiner's coming, and IT whenever the printer breaks. The exceptions don't pile up on a department. They pile up on you.
One tool across every hat, not five systems. The same notebook idea works the loan file, the doc verification, the invoice stack, and the vendor contract — you drag today's problem in, and it comes back as findings with the requirement cited behind each one. And it goes past review: build a workflow in chat that reads a member's credit report, surfaces the top cross-sell opportunities, and writes a script for the conversation — then save it as a notebook and every member-facing colleague runs it. The bells and whistles your core vendor never got around to, built by you, at your desk.
The subscription is the staff you don't have. Nobody at your shop has time to track what fifty states did to lending law this quarter — that's our job, and updates land on your machine without you doing anything. You get the same verification rigor a big bank's QC department would want: every value read from a named source, checked twice, and honest about what it couldn't settle. Big-institution rigor, without a single new hire.
And you can't break anything. Ten minutes to set up, on the computer you already have. No server — you'd know, because you'd be the one maintaining it. No integration with the core. Nothing to patch. If your examiner ever says stop, you stop and get the unused money back. Start with whichever job you dread most; the rest of the hats can wait their turn.
Your problem isn't findings — it's basis. Anyone can flag things. What you need is a flag you can defend: the source document, the specific requirement, the reasoning, and proof of which version of the logic produced it, months later, with the examiner across the table. That's what every Scout finding carries, on every file — and the audit trail is written locally, on your hardware.
It's built to be doubted. Four outcomes instead of two: pass, fail, review (a person should look — not an accusation), and skip (printed on the output, so gaps are visible instead of silent). "Couldn't tell" is never dressed up as a finding. And every run reports the health of its own reading before you decide how much to trust it.
The rules don't go stale. When we determine a federal or state change affects the banking logic, the update ships within 30 days. If a machine can't check in for seven days, Scout stops taking new work rather than review against rules that may have moved. And you finally get a real answer to the sampling question: review the population, not a defended ten percent.
The trust claims are contract terms. Documents never rest outside your workstation; exactly two connections leave the machine and neither carries content — verify it with your own network monitoring, which we're contractually barred from interfering with. If your regulator directs you to stop, you exit on 30 days' notice with a pro-rated refund. The security & architecture page was written for you.
You were right. The thing you've been telling people is real: this technology genuinely works. What you've probably also discovered is the ceiling — you can't point it at anything with a borrower's name on it, it answers differently on Tuesday than it did Friday, and everything you've learned lives in your chat history where it helps exactly one person.
Scout is the sanctioned version of what you've been doing. Real files, because the data path was built for them — documents never rest outside your machine, inference runs under zero data retention, and there's a security page your IT person can actually verify. Same answer every run. Findings with citations instead of vibes.
Your experiments become assets. Everything you figure out gets written into a notebook that runs — for you, then the next desk, then the department. You stop being the person who's good at prompts and become the person who built the procedures. One of those is a party trick; the other one is a career.
You can start without asking anyone. One seat, ten minutes, your own machine, no committee. Bring the ugliest task you can find — that's the demo we want. And when someone upstairs asks what this is, hand them this summary; there's a tab for them too.
What it is. A desktop app that takes the way your best person works a file — loan QC, doc verification, CTRs, credit reports — and makes it repeatable by anyone on the team, on real borrower data, with findings an examiner can follow. Your likeliest current state: one curious employee quietly getting real value from a chat tool, one person wide, gone when they leave. This converts that into institutional capability without a platform decision.
What it never does. It never extends credit, denies, prices, sends adverse action, reports to a bureau, or closes an account. A qualified person makes each of those calls, at the point of the decision — as a term of the agreement, not a marketing line.
The risk shape. Documents never rest outside your own hardware. Two connections leave each machine; neither carries content, and your security team is contractually invited to verify that. Regulatory updates ship within 30 days; software that can't check in for seven days stops rather than run stale. If your regulator directs you to stop, you exit on 30 days' notice with a pro-rated refund — we carry the examiner risk, not you.
The commitment shape. Per-seat, starting with one person, running in ten minutes. No servers, no integration, no implementation project. The honest evaluation: let your most curious person pick the task their team hates most, and watch it run on your own files.