A finance director asked me in June whether the tool his team bought in 2022 was OCR or IDP. He had the contract open on his laptop. It said “AI-powered intelligent document processing”. What his team actually had was a template engine with a character recognition step bolted to the front, and it fell over every time a vendor redesigned an invoice. The words on the contract told him nothing he could use.
That confusion is expensive, so it is worth sorting out. Three terms describe three different architectures, and the gap between them decides how many invoices your team still touches by hand at the end of the month. This post sits inside our series on agentic AI, which is the layer doing the work the older tools were never built for.
Three labels, three different jobs
Picture the work as a stack. Something has to read the page. Something has to turn what was read into named fields. Something has to decide whether those fields are good enough to act on. OCR handles the first job. IDP handles the first two, as long as the document behaves. Agentic document extraction handles all three, and the third one is where the money is.
OCR reads the page
Optical character recognition converts an image of text into machine-readable characters. On a clean, typed page it is very good at this, and has been for years. It will tell you the page contains the string INV-4471 and the number 12,480.00. It will not tell you which one is the invoice number, whether the total matches the line items above it, or what to do when the supplier switches templates in October. It reads. It does not interpret.
IDP reads the page into a template
Intelligent document processing was the industry’s answer to that gap, and for a while it worked. You show the system a layout, mark where the invoice number sits, mark where the total sits, and it extracts those zones on every document that matches. Add classification, add a few validation rules, add a review screen, and you have a workable pipeline for a stable set of suppliers.
Where template drift shows up
The catch is in the word matches. A template is a promise about geometry, and suppliers break that promise constantly. A logo moves. A tax column gets added for a new jurisdiction. A branch office sends the same invoice in a different format. Every one of those events sends a document into the exception queue, and someone has to either fix it by hand or build a new template. Teams I work with usually discover the real cost about eight months in, when the template library has grown past a hundred entries and nobody wants to own it.
Agentic document extraction reads, checks, and decides
Agentic document extraction removes the template as the organising idea. Instead of asking “where on this page is the total?”, the system asks “what kind of document is this, what should it contain, and does what I found hold up?” That sounds like a small change in phrasing. In practice it changes what the software can survive.
What the agent adds on top
An agent classifies the document first, then extracts fields based on what that document type is supposed to contain rather than where things sat last time. It runs the arithmetic. It compares the values against your purchase orders, your vendor master, and your posted history, so a duplicate invoice gets caught before payment rather than after. Then it makes a call: post this one, or stop and ask a person. Our DocPro platform is built around that last step, because deciding turns out to be harder and worth more than reading.
Confidence scores that mean something
A per-field confidence score is what makes the decision auditable. If the agent is sure about the vendor and the date but shaky on one line item, you want that one line item flagged rather than the whole document dumped into a review pile. Flat, document-level confidence tells your team nothing about where to look.
What actually changed
Two things shifted, and neither of them was character recognition getting better. Character recognition was already fine.
Ranges we observe on PTAS projects, not published benchmarks. Your numbers will depend on document mix, supplier count, and how much of your volume arrives as a photograph of a printout.
The layout assumption stopped holding
Template systems were designed for a world where a supplier sent the same document for years. That world is gone. Portals, e-invoicing mandates, regional tax formats, and the general churn of finance software mean layouts move constantly. Once the assumption underneath a system stops matching reality, no amount of tuning saves it. You end up maintaining the workaround rather than the work.
The accuracy conversation moved down the stack
The other change is what buyers now ask about. Five years ago a vendor could win a deal with one number. That has become much harder, and I think finance teams got there by being burned rather than by reading anything.
Character, field, and document accuracy
Character accuracy is the share of individual characters read correctly. Field accuracy is the share of named values that are right, so invoice number, date, total, tax. Document accuracy is the share of documents where every field a human cares about is right, which is the only one that predicts whether anyone has to touch the file. High character accuracy with mediocre field accuracy is a common and misleading combination, and it is the reason I wrote a separate piece arguing that OCR is the wrong frame for this problem entirely.
The three side by side
If you are sitting in a vendor call and want a quick way to place what you are being shown, this is the shape of it.
Reads characters
Turns an image into text. No idea what the text means. Output is a string, and everything after that is your problem.
Fills a template
Classifies, then maps text into fields using a known layout. Works well on stable formats. Breaks on anything it has not been shown.
Reads and decides
Works out the document type, extracts without a template, validates against your systems, and routes only what it is unsure about.
The question to ask
What happens on a layout you have never seen? The answer separates the three faster than any feature list on a slide.
Where each one still fits
None of this makes the older tools worthless. It makes them narrower, which is a different claim.
OCR is still the right answer when the job is transcription
Digitising an archive, making scanned contracts searchable, feeding a text layer to something else downstream. If nobody needs a decision at the end, you do not need a decision layer, and paying for one is waste.
IDP still earns its place on stable, high-volume formats
A utility that receives the same three form types from the same two sources every month has no template drift problem. A well-tuned pipeline there is cheap, predictable, and fast. I would not rip it out to look modern.
Move to agentic extraction when the exceptions are the job
The signal is not volume, it is variety. If your exception queue is growing faster than your document volume, or if two people have quietly become full-time template maintainers, the architecture is the constraint. That is the point where touchless processing becomes reachable instead of theoretical.
A note on the accuracy numbers above, because they get misused. The ranges in this post come from what we see on PTAS projects across invoices, bank statements, and onboarding documents. They are field observations, not a published benchmark, and they are not a guarantee of what you will get.
When a vendor quotes you one number, ask what it measures. A character accuracy figure in the high nineties can sit on top of field accuracy in the seventies, and that gap is exactly where your review queue comes from. Vendors confident in their work tend to lead with field-level and document-level figures, because that is where the difference shows up.
How to run a comparison that tells you something
Vendor demos are run on documents chosen by the vendor. That is not dishonest, it is just useless for your decision. Two habits fix it.
Use the documents that already hurt
Pull twenty files your team argues about. The crumpled scan, the handwritten amendment, the supplier who sends three pages of annexures, the credit note that looks like an invoice. If a system handles your median document you learn nothing, because your median document was never the problem.
The three numbers to ask for
Field-level accuracy per field type, so you can see whether the misses land on the fields that matter. Straight-through rate, meaning the share of documents that need no human contact at all. And exception handling time, because a system that flags well but makes correction painful just moves the cost sideways. Those three numbers on your own documents will tell you more than a week of slides. If you want the wider view of how this fits an operations stack, our piece on enterprise document AI covers the rollout side.
Common questions
What is the difference between agentic document extraction and IDP?
IDP maps a document onto a layout it already knows and returns the fields it found. Agentic document extraction works out what the document is, pulls the fields without a template, checks them against your own records, and then decides whether to post the document or send it to a person. IDP hands you data. An agent hands you a decision with the data attached.
Is OCR obsolete in 2026?
No. Character recognition is still how pixels become text, and modern systems still rely on it. What is obsolete is treating OCR as the whole product. Buying OCR and expecting a finished accounts payable workflow is where teams get caught, because reading the page was never the part that cost them money.
Does agentic document extraction still use OCR?
Usually, yes. On scanned or photographed documents, an agent still needs a text layer, so OCR runs underneath. The difference is what sits on top of it. In an agentic setup, the character recognition is one input among several, rather than the output on which the whole system is judged.
How do I know whether my current tool is IDP or agentic extraction?
Send it a document format it has never seen. A template-driven IDP tool will either fail or return fields from the wrong places. An agentic system will attempt to document, tell you which fields it is unsure about, and route them for review. The second test is whether the tool can say no. If every document comes back with the same flat confidence and nothing is ever escalated, there is no decision layer in there.