Open-source OXR Tops Global OCR Benchmarks with 1.3B Model
The open-source Chinese model OXR (1.3B parameters) has secured the top position in three major OCR benchmarks: OmniDocBench, olmOCR-Bench, and DocParsingBench. Leveraging RSI technology, it demonstrates superior parsing capabilities for complex documents like handwritten notes and chemical structures, achieving end-to-end processing of 100 pages in just 101 seconds on a single RTX PRO 6000 GPU.
Full Report
Contents6 sections
It can even parse chemical structure diagrams...
By Jay from Aofeisi
Quantum Bit | WeChat Official Account: QbitAI
Wait, is RSI applied to OCR really this powerful??
Recently, a domestic open-source model with only 1.3B parameters crushed document parsing benchmarks.
It took first place on OmniDocBench, olmOCR-Bench, and DocParsingBench.
Let's skip the benchmark scores and look directly at the results.
Handwritten advanced math notes converted to Markdown with one click.
It can even render chemical structure diagrams...

Incredible. It seems almost everything can be parsed now.
What surprised me most was its speed—it’s blazing fast???
On a single RTX PRO 6000 GPU, end-to-end document parsing for 100 pages takes just 101 seconds.
Uh oh, Anthropic’s efficiency in distilling paper 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 stems from the sexiest concept in the AI industry today—
RSI.
This new species of OCR, empowered by self-evolution, is named OXR.
Optical "Everything" Recognition.
First Place on Three Global Benchmarks
Document parsing sounds technically simple but remains an unconquered mountain to this day.
Traditional OCR often turns into a disaster when faced with a seemingly ordinary PDF.
Two-column papers get serialized incorrectly, handwritten formulas turn into gibberish, cross-page large table structures collapse, and as for chemical structural formulas, many tools simply discard them as messy lines...
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, featuring over 7,000 unit-test-level hardcore questions)
- DocParsingBench: 87.76, #1 (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 process and code are fully open-source and reproducible.
I gave it a quick try myself, and it is indeed different. Finally, it’s not "artificial stupidity."
With previous tools, I could only hope they would convert images to text, leaving the rest to AI 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, seals...
In specific scenarios, here is what it looks like—
For magazines, it outputs structured Markdown that preserves complete semantic structure and reading order.
Mathematical formulas are directly converted into standard LaTeX code.

References?
There is no need for the LLM to slowly invoke tools to read them; a two-column layout does not compromise quality.

It can even parse math exams???
It seems GPT will be better equipped to help elementary school students with their summer homework in the future o(╥﹏╥)o.

Of course, the most exciting aspect remains its open-source nature.
It is important to note that the significance of open-sourcing this type of vertical small model differs greatly from that of open-sourcing general-purpose LLMs.
To be honest, while open-sourcing LLMs is beneficial, it has little relevance to ordinary users.
Even a model with only 27B parameters incurs prohibitively high local deployment costs—you would need at least an M5 Pro with 64GB of RAM, and that doesn't even account for output speed issues.
But OXR... it's just 1.3B...
What does that mean?
With an RTX 3060, you can run it at full capacity, essentially getting unlimited free usage.
Overseas developers are also thrilled by this development.
Impressive indeed.
So, how exactly does a 1.3B document parsing model achieve state-of-the-art (SOTA) accuracy?
The secret lies entirely in post-training—
It relies on Recursive Self-Improvement (RSI)???
Unveiling RSI Training
For a long time, there has been a prevailing mindset:
To achieve extreme precision in AI, one must scale up to billion-parameter models and rely on massive amounts of human-annotated data.
However, in the field of document parsing, annotated data is practically a bottomless pit.
Layouts vary wildly, with complex professional formulas, code, and charts intertwined. Purely manual annotation is not only exorbitantly expensive but also suffers from high error rates inherent to human labeling.
Long-tail bad cases in the real world are impossible to exhaust. Engineers painstakingly identify bad samples, manually correct them, and retrain the model. Yet, after releasing a new version, it still fails when encountering novel, quirky layouts.
The pace of data preparation strictly bottlenecks model evolution.
The team undertook relatively radical exploration in this area.
They realized that document parsing has a frequently overlooked characteristic:
Every input has an objectively determined ground truth.
Whether text is correct, if table row/column spans are accurate, or if formula symbols are missing—all of these can be precisely measured.
Since correctness can be objectively judged, 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 tailored for document parsing during the post-training phase.
Without relying on new manual human annotations, the AI system identifies errors, analyzes causes, prepares training data for the next round, and iteratively evolves on its own.
This RSI process can be roughly divided into three stages:
1. Prediction & Classification
OXR first parses a vast amount of unlabeled real-world documents.
Next, a General Vision-Language Model (General VLM) comes into play. Combining the original image, parsing results, and evaluation criteria, it categorizes samples into three types:
- Correct: Fully accurate, passed directly.
- Wrong: Clearly incorrect, sent for deep analysis.
- Uncertain: Predictions are unstable or fall on the distribution edge, also sent for analysis.
Retaining the "Uncertain" category is a counter-intuitive know-how.
If you only offer the model binary options of Correct and Wrong, the evaluator model's hesitation is forcibly packaged as a definitive label, ultimately feeding toxic data into the next training round.
By including "Uncertain," ambiguous samples can be safely handled.
Beyond VLMs, OXR also performs multiple rollout samplings on itself.
If the results for a single document vary significantly across multiple runs, it indicates that the model lacks confidence. Even if it happens to guess correctly once, such samples are immediately relegated to the Uncertain set.
Finally, while preserving semantic integrity, the system applies minor image perturbations (slight scaling, compression, mild blurring, or translation) to these high-divergence samples.
If divergence increases further after perturbation, it suggests the model is overly sensitive to harmless visual changes. This specific perturbation action is then recorded as a core root cause, directly guiding targeted reinforcement in the next iteration.
2. Attribution & Training Planning
After filtering out erroneous and weak samples, you cannot simply feed them blindly into the model. You must first understand exactly where the model fails.
In this stage, the General VLM acts like an experienced physician, diagnosing each sample individually: Is it a failure in aligning cells across columns? Or is it an error in recognizing cursive handwriting?
The diagnosed natural language causes are fed 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: reinforcing weaknesses exactly where they exist.
3. Data Generation
With clear reason clusters established, the generator knows precisely what types of problems to practice.
OXR’s specific approach is: Reason clusters provide structural challenges, while the real-world sample pool provides references for layout and visual style.
Every time new data is generated, the system extracts layout styles from real samples as anchors, naturally integrating the structural difficulties that need to be overcome.
Visual vulnerabilities discovered during previous perturbation tests are systematically incorporated into the synthetic pipeline, forcing the model to repeatedly desensitize itself during training.
Finally, the generated data undergoes strict specification validation before being fed back to train the next generation of OXR.
Once a cycle is complete, the model’s shortcomings are addressed; when new real-world documents are processed in the next round, new shortcomings emerge, driving the next iteration.
RSI is thus formed.
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 information.
Lightweight and Pluggable Architecture
Having discussed data and algorithms, let’s move to the next question.
I can understand prioritizing accuracy.
But why is speed also ranked first???
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 sizes.
However, I later realized that document parsing cannot be achieved solely by making the model smaller.
There is significant counter-intuitive Know-How behind this.
Reviewing the technical evolution of document parsing over the past two years, the industry has gone through several stages.
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 LLM 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, quickly becoming the industry standard solution over the past two years.
But is this perfect?
Not quite. Every added layout annotation forces a binding with a reading order annotation, doubling the difficulty of data processing.
After deep analysis, 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 (RO).
That is:
Layout Analysis --> Recognition + Reading Order
This seemingly simple split-and-combine approach brings two massive engineering breakthroughs:
First, it completely eliminates the performance overhead caused by reading order determination.
In the entire pipeline, the time cost of determining reading order was originally much less than text recognition.
By integrating reading order determination into the main model, OXR not only avoids adding extra time but also significantly improves reading order accuracy because the main model possesses semantic understanding capabilities (Content-Aware).
Meanwhile, since the preceding Layout Analysis model (LA) sheds the complex burden of sorting, its task becomes extremely pure. It can directly adopt lighter, more efficient detection models, causing overall throughput to skyrocket.
Second, the Layout Analysis module is independent and fully pluggable.
Different business scenarios have conflicting requirements for layout definition, presenting a long-tail problem:
- For a mixed text-image region, content teams might want to extract it as a single image, while knowledge base teams want to extract the internal text as body content.
- For densely arranged four-panel comics, Business A might want to crop the whole thing, while Business B wants to split it into four individual images.
- ...

In short, it is very difficult to define universally; satisfying everyone is hard.
However, in OXR’s architecture, Layout Analysis is a completely independent, pluggable module—
Achieving maximum business adaptation freedom with minimal modification costs.
If your business has highly specific layout segmentation needs—for example, processing ancient texts or medical bills—you can seamlessly replace the default 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 is built for the developer community, no matter how impressive a model sounds on paper, it’s useless if you can’t deploy it.
On this front, the official team provides a free API—no registration required, no API key application needed.
Yes, completely free. Purely open access...
The official statement confirms that they will maintain this open-source, free service as long as server load remains within manageable limits.
How could we not jump at this opportunity!
So I eagerly integrated this API into my own writing app.
To be honest, when it comes to PDF parsing, the results are significantly better than my previous solutions.
By the way, if you want to deploy locally, that’s also fully supported. OXR is comprehensively adapted to mainstream inference frameworks.
You don’t need to struggle with recompiling vLLM yourself; simply mount the plugin via the official Docker image or CLI to spin up the service with one click.
Currently, OXR’s code, weights, and the entire benchmark reproduction pipeline have all been made public.
Links are provided at the end of this article—feel free to grab them if interested.

Of course, if you have higher requirements—such as handling Word, PPT, Excel, and other formats, or seeking more advanced post-processing customization—you might also want to check out the commercially maintained engine from the official team.
It’s called SoMark.
This is also the name of the OXR team.
One More Thing
Finally, I’d like to share a few thoughts with you all.
Why do we still invest so much effort in perfecting document parsing today?
In an era where Agents are taking over workflows across industries, the most core and professional private knowledge accumulated by humans over decades largely remains buried in messy-formatted, complex-layout PDFs, scanned documents, and reports.
No matter how smart a Large Language Model (LLM) is, if you feed it input consisting of jumbled sequences and broken tables, all it can output is hallucination.
In the past, many people viewed OCR as a low-skill grunt work task. But today, moving from OCR to OXR, its mission has fundamentally changed.
It serves as the bridge for human-machine interaction, reconstructing all complex multimodal documents from the human world into structured assets that are highly Agent-friendly, without loss of fidelity.
Honestly, seeing domestic teams working on things close to engineering implementation is quite exciting.
Too many eyes are fixed on fancy narratives, constantly chasing cutting-edge technologies, causing us to forget something crucial—
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 areas that require getting your hands dirty.
If this becomes a consensus—
The infrastructure for Agents will fall into place piece by piece at a visible pace.
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
SoMark Official Website: https://www.somark.cn
Like, Share, and Follow!
Feel free to leave your thoughts in the comments!
— End —
🌟 Star Us 🌟
Daily updates on tech frontier progress