The standard take on document parsing is that it's a melting ice cube. The reasoning is the following: every frontier model release reads PDFs a little better, so within a couple of model generations OCR becomes a checkbox feature of the model API, and paying a specialized provider for it will look silly.
We think the opposite is happening, and the benchmark data agrees. The pareto frontier for document OCR (the best achievable accuracy at every price point) sits far above the latest frontier models, and the distance has held through every major release since GPT-4o. Whatever visual understanding the newest frontier model ships with, you can distill it into an engine that is more accurate on documents and an order of magnitude cheaper, sometimes both.
Models will get better on visual understanding over time. But we have conviction that this gap will remain or even widen.
Frontier Models Are Being Tuned for Reasoning, Not Reading
Frontier labs allocate post-training compute where the benchmarks and the revenue are: math, code, and agentic tool use. The GPT-5 system card headlines improvements in "writing, coding, and health," and document parsing appears nowhere in it. Google's Gemini 3 launch post leads with "state-of-the-art in reasoning" and "the best vibe coding and agentic coding model we've ever built" — reading documents doesn't come up. Anthropic is the partial exception, with Fable 5's release notes touting gains in chart and table interpretation, but even there the pitch is reasoning over documents, not faithfully digitalizing the messy ones.
You can see the consequences on ParseBench, the document parsing benchmark we open-sourced (~2,000 human-verified enterprise pages, 167,000+ test rules across tables, charts, content faithfulness, semantic formatting, and visual grounding). We ran the entire GPT lineage through it. Three generations of releases from GPT-4o to GPT-5.5 bought roughly 24 points of parsing accuracy while cost per page roughly quadrupled, and the newest, most expensive model still lands 20 points below the specialized frontier.
ParseBench overall score vs. cost per page for the GPT lineage. The line crawls up and to the right; the task frontier sits far above it.
Third-party benchmarks tell the same story. On olmOCR-Bench, the top specialized model beats the best frontier model, GPT-5.4, by over 6 points. Dr.DocBench, an expert-level parsing benchmark released in May, found the newest frontier VLMs all clustered in the low 60s and concluded that "no frontier VLM dominates expert-level document parsing." And OmniDocBench, the previous standard benchmark, is saturated.
There's a structural reason single models struggle here: grounding. Agents consuming parsed documents need to know where every element came from, and single-pass generation is bad at spatial localization — GPT-5 Mini and Haiku score below 8% on ParseBench's visual grounding dimension, while parsers built around layout detection score 55-80%. A model that reasons beautifully about a table but can't tell you which cell a number came from is a liability in production, because when a header shifts by one column, the agent silently pulls the wrong number.
The Pareto Frontier for Document OCR Sits Above the Models
For a fixed task, every method is a point on an accuracy-vs-cost plane, and the pareto frontier is the set of points nothing else dominates. My claim is that the pareto frontier for document OCR will always be much more accurate and much cheaper than the latest frontier models.
ParseBench puts numbers on that picture. LlamaParse Agentic scores 84.9% overall and is the only method competitive across all five dimensions. Our cost-effective mode lands within a few points of the best frontier VLM runs at roughly a third of a cent per page. Gemini Pro burns 8+ cents a page and scores 15 points below the agentic mode, which runs at about a seventh of that price.
No method comes close to 100%, and that's deliberate — the benchmark is meant to be hard. But notice the shape of the scatter: the LlamaParse points sit above and to the left of every VLM and every specialized parser. We don't have a smarter base model than Google. An engine built for one task simply gets to cheat in ways a general-purpose model can't.
You Can Always Distill Frontier Intelligence
There are four ways we exploit that gap:
- Route every page on a learned difficulty distribution: the difficulty distribution of "all prompts on the internet" isn't learnable in any useful way. The difficulty distribution of enterprise document pages absolutely is, and after a billion-plus pages of parsing volume, a document-complexity model can predict, before you spend a dollar, whether a page needs a frontier VLM, a small specialized model, or no model at all. An agentic judge validates and refines the output on the pages that deserve it. Most pages never need a frontier call.
- Post-train specialized document VLMs with RL: document OCR is unusually well-suited to RLVR because the rewards are verifiable — an extracted table either reconciles against ground truth or it doesn't. We post-train document VLMs specifically on tables, charts, and handwriting, the exact failure modes where general models are weakest, and get specialized accuracy at a fraction of frontier size and cost.
- Use the text and metadata already inside the file container: this is the part frontier-model maximalists consistently ignore. A digital PDF literally contains its own text; running a vision model over a screenshot of it means paying to re-derive information that's sitting in the file. Our custom PDFium fork pulls text directly where text is all there is, which cuts vision tokens by 50-90% and runs ~60% faster. Word, PowerPoint, and Excel files are structured OOXML carrying formatting, comments, versioning, and speaker notes that a pixels-only approach throws away. And for the point on the curve where you want no model at all, we open-sourced LiteParse, a model-free parser that chews through a 457-page PDF in under a second.
- Close the loop between eval and engine: every improvement above is only findable if you can measure it, which is why ParseBench is the public artifact of a much larger internal eval and auto-research loop that goes from failure case to harness or model update in days. Sarah Guo's "The Untrainable" has the cleanest articulation of why this compounds: "Capability eats many things, but a better model does not make private ground truth public." A smarter model next quarter doesn't hand our eval data, difficulty model, or routing policy to anyone else.
Point a general agent plus tools at a task with verifiable rewards, then compile the result into a distilled model, a distilled workflow, and stored context.
Every AI Startup is Doing the Same Thing
Greg Kamradt put it well on X: "If your entire startup was: 'we hillclimb a metric you care about-as-a-service' — you'd do pretty well."
Coding has the most public examples. Factory's router holds 99% of Claude Opus 4.7's pass rate on Terminal-Bench 2 at 20% lower cost per session. Cognition keeps shipping its own specialized models instead of reaching for frontier ones off the shelf: SWE-grep is "an order of magnitude faster than frontier models, while matching or outperforming them at context retrieval," and SWE-1.7 shipped last week under the title "Frontier Intelligence at a Fraction of the Cost." Cursor trained Composer with RL to hit frontier coding results at 4x the generation speed of comparable models.
In customer support, Decagon fine-tunes small models for each function in its agent stack, and their post on distillation states the constraint plainly: "Frontier models are too large to deploy with production latency constraints, and small models aren't capable enough on their own, making knowledge distillation the default response."
In spreadsheets, Shortcut runs the same Claude Opus 4.8 that powers Claude for Excel, and their harness scores 76% on hard finance tasks versus 66% for Anthropic's own product, at ~40% lower cost — same model, better engine. In legal, Harvey and Fireworks showed a tuned open-source model with a frontier "advisor" beating Claude Opus end-to-end on both cost and quality (18/100 tasks fully passed at $368 vs. 14/100 at $954), and their framing is exactly right: the frontier model "shows up as a callable tool, not as the dependency the product is built on top of." Even the aggregators are in on it: OpenRouter's Fusion fanned a budget panel of models out in parallel and beat GPT-5.5 and Opus 4.8 on deep research tasks, landing within 1% of Fable 5 at half the cost.
The mechanics differ across these companies — routing, distillation, harness engineering — but the bet is identical: pick a task, own the eval, and hillclimb accuracy and cost simultaneously in a way no general-purpose model release can. Documents are the task we picked.
The Gap Holds Even as the Models Improve
The gap in the pareto curve will continue to hold even frontier VLMs get better at visual understanding.
Every new release is a fresh baseline to measure and distill from. Fable 5 for instance is stronger than other frontier models on tables (~90%), though it struggles on charts and visual grounding - and is of course too expensive for real production use. We can take advantage of this by distilling its table parsing capabilities into specialized VLMs we run at a fraction of the size and cost. We can then combine this with the other well-tuned aspects of the engine (the PDF text layer, OOXML structure, layout and bounding-box metadata). The final result is a solution that is multiples cheaper than wherever the latest frontier model is but also better.
The other reason the gap persists is that document OCR isn't one demand curve. Some workloads need 99%+ accuracy and barely care about price, like financial data room extraction, where each point of per-field accuracy compounds into higher straight-through processing rates. Some need a million documents a day above an accuracy threshold, like offline-indexing a petabyte of SharePoint. Some need answers in seconds inside a live agent product, where a user just uploaded a file and is waiting. No single model sits on all three points of the accuracy-cost-latency surface. A routed engine covers the whole curve, and latency is the next axis we expect to collapse the same way cost did.
The deltas in accuracy and cost matter at scale. Agents are becoming the dominant readers of documents, and every read passes through a parse first. There are 10T+ pages of human knowledge locked inside PDFs, PowerPoints, Word docs, and Excel sheets. Agents are on track to process tens of trillions of pages a year within a decade. That is several times what human eyeballs actually read. At that scale, a few points of accuracy and a few cents per page decide which workloads are economically automatable at all.
So no, document parsing is not a melting ice cube. The ice cube framing gets the causality backwards: every frontier release doesn't erode the specialized engine, it feeds it. The economics of the parse layer are set by the best engine for the task, not the best general model.
ParseBench's dataset and eval code are fully open; run your own parser through it and see where it breaks. LiteParse is free and model-free. LlamaParse is the engine described in this post. And if squeezing every point of document accuracy out of every cent sounds like fun, we're hiring.
