Holofin and the case for treating OCR as infrastructure, not a commodity

A passport photographed at an angle on someone's kitchen table. A bank statement scanned at 150 dpi on a ten-year-old office machine. A KBIS company extract with a stamp printed straight across the company number. A proof of address that is really a screenshot of a PDF of a photo.

This is what document extraction actually looks like in a regulated onboarding flow. Not the clean, born-digital invoice in the demo. The messy real thing, arriving by email and upload, in every format and every quality, hundreds a day.

Most teams assume this problem was solved twenty years ago. OCR reads text off an image; surely that is a commodity by now. It is not, and treating it as one is where a lot of compliance operations quietly break.

Every check downstream inherits the error extraction makes

Extraction is the first step of the chain. Identity checks, screening, risk scoring, the decision to onboard or decline: all of it runs on the fields pulled out of a document at the very start. If that first read is wrong, everything downstream inherits the error. A misread digit in an IBAN, a date of expiry parsed as a date of issue, a name split across two fields: each one becomes a false rejection that costs a customer, or a false match that costs an analyst an afternoon of manual review.

So the quality of extraction sets the error rate for the entire process. And on messy real-world documents, the gap between a good extractor and a mediocre one is the difference between a flow that scales and one that drowns its ops team in exceptions.

Where OCR engines diverge: noise, script coverage, and structure

On a clean document, almost every OCR engine performs well. That is why the demos always look great. The divergence shows up on the documents that are hard, and it shows up along three specific axes.

• Robustness to noise. Skew, blur, low resolution, glare, a stamp over the text, a fold across the page. A weak engine's accuracy falls off a cliff the moment the input stops being pristine. A strong one degrades gracefully.

• Language and script coverage. An engine trained largely on Western European documents will struggle with an Arabic ID, a Cyrillic registry extract, or a mix of scripts on the same page. Coverage is uneven, and it matters enormously the moment a business operates across borders.

• The jump from reading characters to understanding structure. Pulling text off a page is a different problem from knowing that this string is an IBAN, that one is an expiry date, and the number in the corner is a page count rather than an amount. A flat character dump leaves all of that reassembly to whatever comes next. A layout-aware engine returns structure, and that structure is what makes the output usable without a human stitching it back together.

The third one is the most important, and it is where the real shift has happened.

How Holofin chains precision OCR, layout models and an agentic correction pass

The reason the best extraction today outperforms classic OCR is that it stopped being a single step. OCR alone plateaus, because reading characters and understanding a document are genuinely different problems.

The current state of the art is a multi-pass pipeline:

1. Precision OCR reads the characters.

2. Vision-language models recognise the layout, the tables, the headers and the zones, turning a picture of a page into a structured framework.

3. A synthesis pass combines text and layout into clean, standardised output.

4. An agentic step reviews and corrects its own mistakes, the way a human editor would.

This is precisely the architecture Holofin is built on. Rather than treating extraction as one OCR call, it chains precision OCR, layout recognition through vision-language models, and a structured-output pass with an agentic correction layer on top. The result they report on complex financial documents, north of 95% accuracy in under a minute per document, is what you get from OCR as one stage in a pipeline designed around the messiness of real documents.

"We do OCR" and "we run a multi-pass extraction pipeline" are two very different claims, and on hard documents they produce very different data.

Why a serious engine classifies the document before it reads it

The market also looks for the single best engine. There isn't one.

An engine tuned for invoices can be mediocre on identity documents. One that excels on European bank statements can fall apart on an Asian registry extract. Performance is a function of document type, geography, and volume. A tool that has memorised the layout of one document type will beat a generalist on that type and lose everywhere else.

What distinguishes a serious extraction engine is narrower and more useful:

• Handling unfamiliar layouts without being retrained for each one.

• Classifying what kind of document it is looking at before extracting anything from it.

• Splitting a forty-page mixed PDF into its constituent documents on its own.

That is the difference between a narrow OCR and a document-understanding engine. It is also what a regulated operation needs, because the document mix in a real onboarding queue is never uniform.

Why Holofin ties every extracted value back to its coordinates on the page

Most OCR conversations skip this part, and in finance it matters most.

A good extractor returns more than a value. It returns the value's confidence, its bounding box and its coordinates on the source page, and it checks that value against your business rules before it leaves the pipeline. Confidence tells you which extractions to trust and which to route to a human. Position is what lets a reviewer verify a field in one glance, and what lets you answer a regulator six months later asking how a given number ended up in a given system.

Accuracy without traceability is a black box. It might be right, but you cannot prove it, and you cannot triage it. In a regulated process, an extraction you cannot audit is barely better than one you cannot trust, because either way a human has to redo the work to be sure. The output of extraction should be data you can prove.

Holofin turns the document into data you can trust, Forest runs the operation on it

Get all of this right, an extraction pipeline that is robust, structure-aware, context-appropriate, and auditable, and you have solved a genuinely hard problem. Holofin has taken that problem seriously, and it shows in the architecture.

A clean, trustworthy, traceable field is still an input. Something has to decide what happens next: clear the case and proceed, or route the low-confidence extraction to the right reviewer, or escalate a flagged document before it reaches the core systems, and log every one of those decisions so the whole thing holds up under audit. That operational layer, where an extracted value meets the rules, the other signals, the human in the loop, and the record, is where Forest sits.

The two halves fit precisely. Holofin turns a messy document into data you can trust. Forest runs the regulated operation around that data: routing it, governing who and what can act on it, escalating what needs a human, and keeping one audit trail across the whole flow. Neither of us drifts into the other's half, which is the reason this works. Holofin made the other half of the argument on their own blog: the decision is infrastructure, not an inbox. The two teams are working together on exactly this: reliable extraction feeding a governed operation, with proof spanning both.

Good OCR gives you data you can trust. What you do with it, under what rules, on which systems, with what record, is the operation. That is the part worth getting right, because in regulated finance the document was never the hard part. Everything that depends on it was.

Get Holofin and Forest running on your onboarding queue

If your ops team is retyping fields off blurred bank statements and KBIS scans, talk to Holofin.

If a human still decides every case by hand, book a Forest demo and show us the flow you're trying to run.

Forest is the operational infrastructure for regulated fintechs. Compliance, ops, and support teams work on your systems alongside your AI agents, under one permission model and one audit trail. On your own infrastructure. Learn more at forest.app.