Open-Source OXR Tops Global OCR Benchmarks with 1.3B Model
The open-source model OXR (Optical Everything Recognition), with only 1.3B parameters, has achieved global first place in three major document parsing benchmarks including OmniDocBench and olmOCR-Bench. By incorporating Recursive Self-Improvement (RSI) mechanisms, OXR significantly enhances accuracy and speed for complex layouts, handwritten formulas, and chemical structures, processing 100 pages in just 101 seconds on a single RTX PRO 6000 GPU, thereby providing high-quality context extraction for agent infrastructure.
Related Entities
Full Report
Contents5 sections
By Jay from Ao Fei Si QbitAI | Official Account: QbitAI
Wait, RSI applied to OCR? Is the performance really this impressive??
Recently, a domestic open-source model with just 1.3B parameters crushed document parsing benchmarks.
It took first place on OmniDocBench, olmOCR-Bench, and DocParsingBench.
Let's skip the benchmark scores for now and look directly at the results.
Handwritten calculus notes converted to Markdown with one click.

It can even render chemical structure diagrams...

Incredible—it seems capable of parsing virtually anything.

But what I didn't expect was that it's also incredibly fast???
On a single RTX PRO 6000, end-to-end document parsing for 100 pages takes only 101 seconds.
Uh oh, Anthropic's efficiency in distilling physical books is about to skyrocket (just kidding).

It has also gone viral in the overseas developer community, already accumulating over 1.1K GitHub Stars.
It briefly became the hottest Daily News topic on Twitter.

All of this is thanks to the most exciting concept in the AI industry today—
RSI.
This new species of self-evolving OCR is named OXR.
Optical "Everything" Recognition.
First Place on Three Global Benchmarks
Document parsing sounds technically unimpressive, yet it remains an unsolved challenge.
Traditional OCR often turns into a disaster when faced with seemingly ordinary PDFs.
Two-column papers get serialized incorrectly, handwritten formulas turn into gibberish, large tables spanning multiple pages collapse structurally, and chemical structural formulas are often discarded as messy lines by many tools...
When such poor-quality extraction is fed into RAG, no matter how smart the model is, downstream Tool Calls will fail completely.
Now, the barrier preventing AI from acquiring high-quality context has finally been broken.
- OmniDocBench: 97.18, #1 (Open-sourced by Shanghai AI Laboratory, covering 10 types of complex documents)
- olmOCR-Bench: 87.84, #1 (Released by Ai2, a renowned international AI organization; features over 7,000 rigorous unit-test-level questions)
- DocParsingBench: 87.76, #1 (#1 rank, covering 5 major industries and 14 real-world business scenarios)

An open-source document parsing model named OXR has taken the top spot on all three world-class benchmarks.
Moreover, the entire evaluation pipeline and code are fully open-source and reproducible.
I gave it a quick try myself, and it is indeed different. Finally, it's not just "artificial stupidity."
With previous tools, I mostly relied on them just to convert images to text, leaving the rest to the AI's own inference and interpretation.
OXR, however, can ingest 13 types of document elements in one go:
Tables, formulas, code blocks, images, chemical equations, footnotes, headers, footers, stamps...
Here is how it performs in specific scenarios—
Magazines: Outputs structured Markdown preserving complete semantic structure and reading order.

Mathematical formulas: Directly converted into standard LaTeX code.

Academic papers?
No need to let the LLM slowly call tools to read them; two-column layouts do not affect quality.

It can even parse math exams???
Looks like GPT will be better equipped to help elementary students with their summer homework o(╥﹏╥)o.

Of course, the most exciting aspect is still the fact that it is open-source.
Note that the significance of open-sourcing vertical small models is quite different from open-sourcing LLMs.
To be honest, while open-sourcing LLMs is great, it largely doesn't concern average users.
Even a 27B model has prohibitively high local deployment costs—you'd need at least an M5 Pro with 64GB RAM, and that doesn't even account for output speed issues.
But OXR is only 1.3B...
What does that mean?
You can run it at full capacity on an RTX 3060, allowing you to exploit its capabilities endlessly.
Overseas developers are equally thrilled.

Impressive stuff.

So, how exactly does a 1.3B document parsing model achieve SOTA accuracy?
The secret lies entirely in post-training—
Is it actually powered by RSI???
Unveiling RSI Training
For a long time, there has been a prevailing mindset:
To achieve extreme precision in AI, one must stack up tens-of-billions-parameter large models and massive amounts of manually annotated data.
But honestly, in the field of document parsing, annotation data is a bottomless pit.
Layouts are wildly inconsistent, with complex professional formulas, code, and charts intertwined. Relying solely on manual annotation is not only prohibitively expensive but also suffers from a shockingly high error rate.
You simply cannot exhaust the long-tail bad cases found in the real world. Engineers painstakingly select poor samples, manually correct them, and retrain the model. After finally releasing a new version, it still fails when encountering novel, bizarre layouts.
The speed of data preparation has become a hard bottleneck for model evolution.
The team undertook relatively aggressive exploration in this area.
They realized that document parsing has long possessed an often-overlooked characteristic:
Every input has an objectively determined ground truth.
Whether text is correct, whether table row/column spans are accurate, or whether formula symbols are missing can all be precisely measured.
If correctness can be judged objectively, why wait for humans to clean up the mess?
After conducting this thought experiment, OXR made a decision:
Introduce a Recursive Self-Improvement (RSI) training paradigm for document parsing during the post-training phase.
Without relying on additional human manual annotations, the AI system identifies errors itself, analyzes causes, prepares the next round of training data, and iteratively evolves.

This RSI process can be roughly divided into three stages:
1. Prediction & Classification
OXR first parses massive amounts of unlabeled real-world documents.
Next, a General Vision-Language Model (VLM) comes into play. Combining the original image, parsing results, and evaluation criteria, it categorizes samples into three types:
- Correct: Completely accurate; passes directly.
- Wrong: Clearly incorrect; sent for deep analysis.
- Uncertain: Unstable predictions or edge-of-distribution cases; also sent for analysis.
Retaining the "Uncertain" category is a somewhat counterintuitive piece of know-how.
If you only offer the model binary options of Correct and Wrong, the evaluator's hesitation is forcibly packaged into a definitive label, ultimately feeding toxic noise into the next training round.
With the Uncertain category, ambiguous samples can be safely handled.
In addition to the VLM, OXR performs multiple rollout samplings on itself.
If parsing the same document multiple times yields vastly different results, it indicates the model lacks confidence. Even if it happens to guess correctly once, such samples are immediately placed into the Uncertain set.
Finally, under the premise of preserving semantic integrity, the system applies slight image perturbations (minor scaling, compression, mild blurring, or translation) to these high-disagreement samples.
If the disagreement expands further after perturbation, it indicates the model is overly sensitive to harmless visual changes. This perturbation action is then recorded as a core root cause, directly guiding targeted reinforcement in the next round.
2. Attribution & Training Planning
Once erroneous and weak samples are filtered out, they must not be blindly fed to the model. You need to understand exactly where it failed.
In this stage, the General VLM acts like an experienced doctor, diagnosing each sample individually: Is it a failure in aligning cross-column cells, or an error in recognizing cursive handwriting?
The diagnosed natural language reasons are input into SigLIP2 to extract feature vectors, which are then clustered by an independent clustering model to form clear reason clusters.
For example, a financial report and a chemical experiment log may look completely unrelated in appearance and text. However, if attribution clustering reveals that both fail due to a rare cross-row/cross-column structure, this insight is distilled into a common direction for data construction.
This is precision targeting: reinforce wherever there is weakness.
3. Data Generation
With clear reason clusters, the generator knows what problems to practice.
OXR’s specific approach is: Reason clusters provide structural challenges, while the pool of real samples provides layout and visual style references.
Each time new data is generated, layout styles are extracted from real samples as anchors, naturally integrating the structural difficulties that need to be overcome.
Visual vulnerabilities discovered during perturbation testing are systematically incorporated into the synthetic pipeline, forcing the model to repeatedly desensitize itself during practice.
Finally, the generated data undergoes strict specification validation before being fed back to train the next generation of OXR.
After one round, the model’s shortcomings are addressed; running new real-world documents exposes new shortcomings, driving the next iteration.
Thus, RSI takes shape.
Data distribution becomes increasingly comprehensive and robust with each iteration.
This is why OXR achieves such high intelligence density.
When data quality reaches a certain level, the model no longer needs to rely on bloated parameter counts to memorize patterns.
Lightweight and Pluggable Architecture
Having discussed data and algorithms, let’s move to the next question.
Top accuracy—I can understand that.
But top speed as well? What’s going on???
On a single RTX PRO 6000, OXR parses a 100-page document end-to-end in just 101.0 seconds, ranking first among open-source solutions.
Initially, I assumed this was due to smaller parameter counts.
But later I realized that small models alone cannot achieve effective document parsing.
There is a lot of counterintuitive know-how behind this.
Reviewing the technical evolution of document parsing over the past two years, the industry has gone through several phases.
At first, everyone adopted Pipelines, using separate specialized models for detection, recognition, and ordering. These were extremely bloated and had sky-high maintenance costs.
Later, VLMs became popular. People realized that all tasks are essentially mappings from images to sequences, leading to attempts to use large end-to-end models to handle everything at once, letting the large model directly output text and layout for the entire page.
While elegant, this approach was slow as snails because autoregressive generation of long sequences is computationally expensive.
Subsequently, PaddleOCR-VL took a beautiful step forward:
It merged Layout Analysis (LA) and Reading Order (RO) into a small model, followed by a Recognition model, creating a two-model, two-stage architecture.
This brought layout detection speed back to the millisecond-level performance of traditional object detection, becoming the industry standard solution for the past two years.
But is this perfect?
Not quite. Every added layout annotation forces the binding of a reading order annotation, doubling the difficulty of data processing.
After deep deliberation, the OXR team proposed a completely different task-level restructuring:
An independent lightweight model handles Layout Analysis (LA), while the main OXR model simultaneously handles Content Recognition and Reading Order determination (RO).
That is:
Layout Analysis → Recognition + Reading Order
This seemingly simple split-and-combine approach brings two major engineering breakthroughs:
First, it completely eliminates the performance overhead caused by reading order.
In the entire pipeline, the time cost of determining reading order was originally far less than that of text recognition.
After OXR integrated reading order determination into the main model, it not only avoided adding extra latency but also significantly improved the accuracy of reading order judgment, thanks to the main model's inherent semantic understanding capabilities (Content-Aware).
Meanwhile, the preceding Layout Analysis (LA) module, having shed the burden of complex sorting tasks, became extremely streamlined. This allowed for the adoption of lighter, more efficient detection models, causing overall throughput to skyrocket.
Secondly, the layout analysis module is independent and fully pluggable.
Different business scenarios have conflicting requirements for layout processing—a classic long-tail problem:
- For a region with mixed text and images, content teams may want to extract it as a single image, while knowledge base teams prefer to extract the text within it as body content;
- For densely arranged four-panel comics, Business A might want to crop them as a whole, while Business B wants to split them into four separate images;
- ...

In short, defining these requirements is extremely difficult, and satisfying everyone is nearly impossible.
However, in OXR's architecture, layout analysis is a completely independent, pluggable module—
Achieving maximum business adaptation flexibility with minimal modification costs.

If your business has highly specific layout segmentation needs—for example, processing ancient texts or medical forms—you can seamlessly replace this module with your own privately trained layout analysis model,
while continuing to leverage OXR's powerful content recognition capabilities on the backend.
Out-of-the-Box Ecosystem
Of course, since this tool is built for the developer community, no matter how impressive a model sounds, it’s useless if it cannot be deployed.
To address this, the official team provides a free API requiring no registration and no key application.
Yes, it is completely free—purely open access...
The official team stated that they will maintain the open-source free service at least as long as server load remains manageable.
How could we not support such generosity?
I immediately integrated this API into my writing app.
Honestly, compared to previous solutions, the PDF parsing performance is vastly superior.

For those interested in local deployment, that is also supported. OXR is fully compatible with mainstream inference frameworks.
You don't need to struggle with recompiling vLLM yourself; you can simply mount the plugin via the official Docker image or CLI to launch the service with one click.
Currently, OXR's code, weights, and the complete reproduction workflow for its benchmark evaluations are all publicly available.
Links are provided at the end of this article for those interested.

Naturally, if you have higher-level requirements—such as handling Word, PPT, Excel, and other formats, or seeking more comprehensive post-processing customization—you may also consider the commercial-grade engine maintained by the official team.
It is called SoMark.
This is also the name of the OXR team.

One More Thing
Finally, I have a few thoughts I’d like to share.
Why do we still invest so much effort into perfecting document parsing today?
As Agents take over workflows across industries, the most core and professional private-domain knowledge accumulated by humanity over the past decades largely remains trapped in messy-format PDFs, scanned documents, and reports.
No matter how intelligent Large Language Models (LLMs) become, if their input consists of garbled characters with broken sequences and fragmented tables, their output will inevitably be hallucinations.
In the past, many viewed OCR as low-skill grunt work. However, today, from OCR to OXR, its mission has fundamentally changed.
It serves as a bridge for human-machine interaction, reconstructing all complex multimodal documents from the human world into structured assets that are highly friendly to Agents, without loss of integrity.
Frankly, seeing domestic teams working on projects closely tied to engineering implementation is quite exciting.
Too many people focus on fancy narratives, constantly chasing cutting-edge technologies, which causes us to forget a crucial question—
What do users actually need?
At this stage of LLM development, the answer is definitely not just "higher model intelligence."
The bigger bottleneck lies in unexplored territories that require getting hands dirty.
If consensus forms around this idea—
The infrastructure for Agents will see its puzzle pieces fall into place at a visible speed.
GitHub: https://github.com/SoMarkAI/OXR
Hugging Face: https://huggingface.co/SoMarkAI/OXR-1.0
Online Demo: https://free-oxr.somark.cn/
Free API: https://free-oxr.somark.cn/api/v1