There is a reasonable case that this problem is finished.
A decade ago, pulling structured information out of a document meant templates, positional rules, and a maintenance burden that grew with every supplier who changed their invoice layout. Handwriting was a research problem. Tables broke everything. Anything unusual went to a human queue.
Most of that is genuinely over. Modern models read documents they have never seen, handle layout variation without templates, cope with handwriting, and extract from formats that would have required a bespoke parser. If your definition of the problem is turn this document into fields, the answer is close to yes.
Which is why so many programs built on that definition are underdelivering.
What extraction does not tell you
Three things, and they are where the work now sits.
Whether the document is the right one.
Extraction reads what you give it. Deciding which of the four contracts in the folder governs this relationship, whether the amendment supersedes the clause, and whether the signed version matches the executed one — that is judgment about a corpus, not comprehension of a page. It was never an extraction problem and it has not been solved by extraction getting better.
Whether the extracted value is correct in context.
A model can read a total from an invoice with high accuracy. Whether that total should be paid depends on the purchase order, the goods received note, the contract rate and the exception nobody wrote down. Extraction accuracy and decision accuracy are different quantities, and organizations routinely report the first while being measured on the second.
What to do when it is uncertain.
The old systems failed loudly — the template did not match, the document went to a queue. The new ones produce a plausible answer regardless. That is an improvement in throughput and a regression in signal, and it means confidence calibration and routing are now the engineering problem rather than recognition.
The part that has genuinely got harder
Verification is now more expensive relative to processing, and this inverts an assumption most business cases rest on.
When extraction was hard, the system told you when it failed. The cost of the failure was a human doing the work, which was expensive but visible and bounded.
When extraction is easy, failures look like successes. A wrong value that is well-formed and plausible enters your process and is discovered downstream, if at all. So the saving on extraction is partly offset by a new cost — checking output that no longer announces its own uncertainty — and that cost lands on a different team than the one that captured the benefit.
So: solved, for what?
| Task | State |
|---|---|
| Reading a document you have never seen and returning fields | Largely solved. Templates and per-format engineering are no longer the constraint. |
| Handling layout variation, handwriting, mixed formats | Largely solved for common document types in common languages. |
| Knowing which document governs | Not solved. This is corpus and records management, not extraction. |
| Knowing whether an extracted value should be acted on | Not solved. Depends on context that mostly is not in the document. |
| Knowing when the system is unsure | Partially solved and frequently unimplemented. The hardest engineering in a modern pipeline. |
| Removing the human entirely | Not solved, and increasingly the wrong objective. The human moves from processing to adjudicating exceptions — fewer people, harder work, different skills. |
Where to spend instead
Yes and no is an unsatisfying answer, so here is the sharper version: the recognition problem is solved and the adjudication problem is not, and almost every enterprise program in this space is scoped against the first while being judged on the second.
The practical consequence is where to spend. Not on extraction accuracy, which is largely a solved and commoditizing capability. On knowing which document is authoritative, on calibrating and routing uncertainty, and on the exception path — which is now where all the difficulty and most of the value sits.
If a vendor is competing on extraction accuracy, they are competing on the part that is finished. Ask instead what happens when their system is not sure, and how you would find out.
This is an argued assessment of a capability area. It cites no benchmarks and names no products, deliberately: published accuracy figures in this field are typically vendor-reported on vendor-chosen document sets and do not transfer to a specific corpus.
Related Reading
- Intelligent Document Processing (IDP)
- Enterprise Content Management (ECM)
- Enterprise Search & RAG Platforms
- An executive guide to open-weight models
- Most of your agent projects should be workflows
- Ten Google engineers explained why ML systems rot. Most MLOps advice still ignores them.
- Data Governance at Scale: Building a Federated Governance Operating Model
- Data Mesh vs. Data Fabric: Choosing the Right Architecture for Your Enterprise
Independent. No sponsorships. Unsubscribe anytime.