README.md

---
license: apache-2.0
configs:
- config_name: boo-bench
  features:
  - name: pdf
    dtype: string
  - name: category
    dtype: string
  - name: id
    dtype: string
  - name: type
    dtype: string
  - name: rule
    dtype: string
  - name: page
    dtype: int64
  - name: expected_markdown
    dtype: string
  - name: tags
    sequence: string
  data_files:
  - split: real
    path: real.jsonl
  - split: trap
    path: trap.jsonl
  - split: ghost
    path: ghost.jsonl
  - split: script
    path: script.jsonl
language:
- en
- multilingual
pretty_name: Boo Bench
size_categories:
- n<1K
tags:
- document-parsing
- pdf
- ocr
- benchmark
- evaluation
- repetition
- hallucination
- vlm
---

# 👻 Boo Bench

![Boo Bench: a haunted house for document parsers](thumbnails/boobench_teaser.png)

**Quick links:** [\[💻 Code: ParseBench\]](https://github.com/run-llama/ParseBench) [\[📊 ParseBench dataset\]](https://huggingface.co/datasets/llamaindex/ParseBench)

Boo bench is built to capture the pages that scare VLMs (cause them to make mistakes) but most specialized document OCR APIs perform well on. It is a playful and simple litmus test for understanding the need for specialized models, tools, and agent harnesses for document processing, beyond simply straight shotting documents to VLMs. 

A **Boo** is an element on a page that scares a parser. We frequently see failure modes where certain pages cause parsers
to go into repitition loops or stop parsing properly.

**Boo Bench** is a haunted house of **179 pages built to scare document parsers into repeating themselves**.

## The four rooms

![Four rooms: real pages, trap pages, ghost pages and haunted scripts](thumbnails/boobench_rooms.png)

| Room (split) | Pages | Ground truth | What is inside |
|---|---:|---|---|
| 🕯️ `real` | 100 | the page's text layer | Real pages with a repetition: dot leaders, fill-in blanks, rules of `=`, rows of `0.00`, repeated lines, in 23 kinds. |
| 🕸️ `trap` | 48 | exact, generated | 16 trap families × 3 Halloween-themed pages: near-identical rows, sequences and lists that stop early, fill-in forms, repeated blocks, repetition written as an instruction (`la la la (×3)`), dense number grids, codes (Morse, binary, bar glyphs), box drawing and text art, tiled watermarks, homoglyphs (`O0`, `l1I`), stacked diacritics, right-to-left and vertical text, rare emoji sequences, nearly blank pages, giant words. |
| 👻 `ghost` | 16 | exact, generated | Grids, rows and tallies of ghost, pumpkin, bat, spider and skull emoji. |
| 💀 `script` | 15 | none needed | Scans of the UDHR's Article 1, the alphabet and the digits in 15 scripts (Armenian, Canadian syllabics, Cherokee, Ethiopic, Gujarati, Kannada, Khmer, Malayalam, Mongolian, Myanmar, Sinhala, Syriac, Tamil, Thaana, Vietnamese). |

Trap, ghost and script pages are image-only PDFs, so a parser has to read the pixels.

## What a Boo looks like

![A Boo: the page's table holds 159 x check marks, the parser wrote 8,181](thumbnails/boobench_boo_example.png)

A rotated table of study criteria marks each cell with an `x`: 159 of them on the page. The parser wrote 8,181 `x`
in one run, until its output ran out. The page is on the left, the parser's output on the right, the loop in red.

## Running it

Boo Bench runs with the [ParseBench](https://github.com/run-llama/ParseBench) CLI, on any of its pipelines:

```bash
pip install parse-bench            # or: uv tool install parse-bench

parse-bench run llamaparse_agentic --dataset llamaindex/BooBench                # downloads to ./data/boobench, runs, scores
parse-bench run llamaparse_agentic --dataset llamaindex/BooBench --group script # one room: real, trap, ghost or script
parse-bench download --dataset llamaindex/BooBench
parse-bench status --dataset llamaindex/BooBench
```

The score is the rule pass rate: the share of pages with no Boo, overall and per room.

### On your own documents

```bash
parse-bench repetition make ./my_docs                  # writes <name>.test.json next to every PDF
parse-bench run llamaparse_agentic --input_dir ./my_docs
```

`repetition make` reads each PDF's text layer and writes one `repetition_overshoot` rule budgeted from it, the way the
`real` room was built. A PDF without a text layer is skipped (`--scans` tests it as a page that repeats nothing).

## The rule: `repetition_overshoot`

The output is cleaned of markdown and HTML syntax (table separators, grids, rules, bold markers, tags), look-alike
characters are folded (`O`/`0`, `I`/`l`/`ǀ`/`1`, `$`/`5`), and the page fails on the worst overshoot of:

| Budget | Limit |
|---|---|
| One fill run (dots, dashes, underscores, `=`, `·`, `…`, `▪`) | 2 × the page's longest + 40, one line of the page (250), or 2 × the page's block of leader lines + 40 |
| All fill together | 2 × the page's total + 40, or 250 per line of the page |
| A run of one character, a 2-8 character unit or a token | 2 × its count on the page + 20 |
| A repeated line or HTML table row | 2 × the count of its rarest word on the page + 40 |
| A whole table written out again | 2 × its count on the page (at least once) |

On a text-layer page, a value the text layer lacks (a number drawn in a chart) is not budgeted, and a value repeated
across a table's distinct rows (a chart transcribed point by point) is data, not a loop. On a generated page the
reference is exact, so every copy counts. Every generated page passes with its exact transcription, written plainly,
with blank lines, as a markdown list or as an HTML table, and fails when its last row is looped 150 times.

## Leaderboard

![Who got spooked? The Boo Bench leaderboard](thumbnails/boobench_leaderboard.png)

Ghost-free: pages answered without a Boo, out of 179. **Boos** count loops, loops hidden inside an answer they broke
(for example a JSON response), and pages that came back empty. **Lost** counts pages still being written when the
10-minute clock ran out. Equal scores share a rank.

| Rank | Parser | Kind | Ghost-free | Boos | Lost |
|---:|---|---|---:|---:|---:|
| 1 | LlamaParse Agentic | Document parser | 100.0% | 0 | 0 |
| 1 | LlamaParse Agentic Plus | Document parser | 100.0% | 0 | 0 |
| 1 | Datalab Accurate | Document parser | 100.0% | 0 | 0 |
| 1 | Datalab Fast | Document parser | 100.0% | 0 | 0 |
| 5 | Datalab Balanced | Document parser | 99.4% | 1 | 0 |
| 5 | Extend (2.0) | Document parser | 99.4% | 1 | 0 |
| 5 | GPT-6 Luna | Frontier VLM | 99.4% | 1 | 0 |
| 5 | GPT-6.1 Terra | Frontier VLM | 99.4% | 1 | 0 |
| 5 | Reducto | Document parser | 99.4% | 1 | 0 |
| 5 | Reducto (non-agentic) | Document parser | 99.4% | 1 | 0 |
| 5 | Reducto (r-1) | Document parser | 99.4% | 1 | 0 |
| 12 | Azure DI (Layout) | Document parser | 98.9% | 2 | 0 |
| 12 | Claude Sonnet 5.5 | Frontier VLM | 98.9% | 2 | 0 |
| 12 | Grok 4.6 | Frontier VLM | 98.9% | 2 | 0 |
| 12 | Muse Spark 1.3 | Frontier VLM | 98.9% | 2 | 0 |
| 16 | LlamaParse Cost Effective | Document parser | 98.3% | 3 | 0 |
| 17 | AWS Textract | Document parser | 97.8% | 4 | 0 |
| 17 | Claude Haiku 5.5 | Frontier VLM | 97.8% | 4 | 0 |
| 17 | Gemini 3.8 Flash | Frontier VLM | 97.8% | 4 | 0 |
| 17 | Gemini 4 Argon | Frontier VLM | 97.8% | 4 | 0 |
| 21 | Claude Opus 5.5 | Frontier VLM | 97.2% | 5 | 0 |
| 22 | Gemini 3.5 Flash-Lite | Frontier VLM | 96.6% | 6 | 0 |
| 23 | Extend (v1) | Document parser | 96.1% | 7 | 0 |
| 24 | Mistral OCR 4.1 | Document parser | 95.0% | 9 | 0 |
| 24 | Mistral OCR 4.1 (Annotation) | Document parser | 95.0% | 9 | 0 |
| 26 | Infinity-Parser 2 Flash | Open VLM | 93.3% | 12 | 0 |
| 27 | Databricks AI Parse | Document parser | 92.7% | 13 | 0 |
| 28 | HunyuanOCR 1.5 | Open VLM | 92.2% | 14 | 0 |
| 28 | Pulse Ultra 2 | Document parser | 92.2% | 14 | 0 |
| 30 | MinerU 2605 Pro | Open VLM | 91.6% | 15 | 0 |
| 31 | Chandra 2 | Open VLM | 91.1% | 16 | 0 |
| 32 | Extend Light (1.0) | Document parser | 89.4% | 19 | 0 |
| 33 | olmOCR 2 7B | Open VLM | 88.8% | 20 | 0 |
| 34 | GLM-OCR | Open VLM | 86.6% | 24 | 0 |
| 35 | Qwen 3.8 27B | Open VLM | 82.1% | 24 | 8 |
| 36 | PaddleOCR-VL 1.6 | Open VLM | 77.1% | 14 | 27 |
| 37 | Nemotron Omni 30B | Open VLM | 61.5% | 12 | 57 |

## Data format

The rows follow the ParseBench format, one per page:

| Field | Meaning |
|---|---|
| `pdf` | path of the page, `docs/<room>/<id>.pdf` |
| `category` | the room: `real`, `trap`, `ghost` or `script` |
| `id` | the page's name |
| `type` | `repetition_overshoot` |
| `rule` | the rule's budgets, as a JSON string: `reference_text`, `page_fill_runs`, `page_lines`, and the slacks |
| `page` | unused (every document is one page) |
| `expected_markdown` | the exact transcription, for trap and ghost pages |
| `tags` | the room, plus `kind:` (real pages), `family:` (trap pages) or `script:` (scans) |

## Known limitations

- The `real` room's ground truth is a text layer, not a human transcription. The budgets are loose on purpose (a text
  layer can undercount a leader drawn with a symbol font), and a garbled text layer can still undercount a value the
  page shows many times.
- The factor of 2 means a loop shorter than the page's own count of that unit passes.
- `real/Exhibit_D_Gift-Loan_Disclosure_p1` has a resource cycle that some PDF libraries refuse to open. A parser that
  cannot read it returns nothing for it, which counts as a Boo.

## License and citation

Apache 2.0, like ParseBench. The `real` pages are single pages of publicly available documents. There is no paper
yet; if you use Boo Bench, please cite the dataset:

```bibtex
@misc{doulcet2026boobench,
      title={Boo Bench: A Haunted House for Document Parsers},
      author={Pierre-Loïc Doulcet},
      year={2026},
      publisher={Hugging Face},
      howpublished={\url{https://huggingface.co/datasets/llamaindex/BooBench}},
}
```

It runs on [ParseBench](https://github.com/run-llama/ParseBench).