Indra OCR, measured on RuleSage's rulebook pages

If you're new here: strata→signal is a small workshop that runs its own machines and writes up what it measures. Every figure here is read from the registered run's result files, written 2026-10-27 (UTC), or from the plan frozen that morning, and every verdict word follows that plan. Rulebook pages are copyrighted, so this page prints counts and scores, never a page's words or picture.

The words this page leans on

• Text layer. The text a PDF carries behind its picture. A born-digital page came from a layout program and has one; an image-only page (a scan, a flattened export, a picture) has none.
• OCR. Optical character recognition: a model that reads a page's picture and writes out the text. Indra OCR is Datalab's open OCR model; by its README its main recognizer has about 1.25 million parameters, all its default models 7.3 million. Tesseract 5 is the open-source engine; tessdata_best is its full-precision English model, tessdata_fast the smaller, integer-quantised one a Linux distribution ships.
• Reference. A born-digital page's own text, filtered to the glyphs visible in the rendered page. Coverage is the share of its characters an engine's output accounts for; retrieval needs it, because a word never read cannot be found. Read CER is the character error rate inside the text an engine did read; a quoted span needs it. Flex CER, after Clausner, Pletschacher and Antonacopoulos (Pattern Recognition Letters, 2020), charges edits, deletions and insertions together over the reference's characters, whatever the reading order.
• The 95% interval. A page bootstrap on every gated row: 10,000 resamples of the pages, the middle 95% printed. The verdict is read on the point value; the interval says how settled it is at that many pages.

The question, and the census

RuleSage's ingest reads each PDF's text layer and skips any page that has none. A census of the archive on 2026-10-27 found 635 distinct image-only pages in 402 files (638 counting three duplicate archive files, 2.95% of 21,614 pages): 351 covers, 85 in four scan files with no other text, 40 in two 72 ppi scans whose sibling file carries someone else's OCR layer, and 159 other interior and last pages. Two games in the archive have no text anywhere. The median raster on those pages is placed at 150 pixels per inch.

So the question was narrow: does Indra OCR 1.1.2, on a CPU, read rulebook pages accurately and completely enough that its text could enter RuleSage's corpus as chunks a reader could be cited to, and does it beat the obvious free baseline, Tesseract 5 with its best English model? The bars were set from the use: coverage is gated because retrieval needs the words to be there, read CER because a quoted span needs the characters right, and because a misread digit can put a wrong number in a rule, the share of digit tokens read exactly is reported beside them.

The verdict, and every gate

REJECTED, with one failed row, G2-fine-cover, a small-print row. The plan names this outcome, "rejected only on small print", and says what it licenses: nothing new. Body pages met the bars; small print did not. Every row is Indra 1.1.2 at its defaults, one page per rulebook; tessdata_best enters only through G3. The last column is what the image-text control (below) removed from Indra's output before scoring. S1 is the born-digital sample, S2 the table pages, S4 the degraded copies, and a fine page is small print; all are defined below the table.

On the failed row. The point value is 0.3007: on the 21 small-print pages Indra accounted for three tenths of the visible characters, half the bar. Its interval runs from 0.1483 to 0.6046, and because that interval holds the bar, the plan's rule labels the row "near the bar". That registered label means one thing only: at 21 pages the spread is wide enough that the bar sits inside its upper reach. It is that wide because one of the 21 pages carries 39% of the class's visible characters, and Indra read 0.01 of it; on the other 20 pages Indra's coverage is 0.49, still under the bar, so the FAIL does not rest on that page. (That split is read from the run's per-page result rows after the run; it is not a registered figure.) It does not mean the row nearly passed; the verdict is read on the point value, as registered, and the point is half the bar. Tesseract misses the same small print: on the same pages tessdata_best found 0.2871 of the visible text and tessdata_fast 0.3311.

On G3. Paired by page over the 190 natural pages, Indra's flex CER was 7.52 points below tessdata_best's, with the whole interval below zero, the registered form of "beats": Indra beat Tesseract 5 (tessdata_best) on the paired natural sample. Against tessdata_fast, reported and not gated, the gap is 6.96 points, interval [−13.35, −2.88].

How the bars were set, and what was read

The plan was frozen first, sealed by hash at 04:09:49Z on 2026-10-27 (UTC); the run's preflight started at 12:46:59Z and the result files were written at 13:59:38Z. One critique pass and a closure check preceded the freeze, and a planted-error suite of 17 exact checks on invented text stands behind the scorer. An exploratory 20-page smoke, on files excluded from every registered set, restated the predictions before the freeze; its numbers are not results, and the one smoke figure on this page, in the diagnostic section, is labelled as the smoke's.

The page sets, one page per rulebook. S1: one page from each of 200 born-digital rulebooks out of 1,141 (174 body, 12 fine, 14 oversize), then more fine and oversize pages until each class held 30; the top-ups count in the class rows only. S2: one table-shaped page from each of 80 rulebooks out of 551 candidates. S3: every distinct image-only page, all 635. S4: each S1 natural page's render taken down to 150 dpi in grey, through a JPEG at quality 75, and back up, with two ungated rungs beside it, 100 dpi and a scan-like condition (rotated one degree, blurred 0.6 px, seeded noise). A fine page has at least a quarter of its word boxes under 7 pt, an oversize page a long side over 1,000 pt; the thresholds were chosen after one smoke page.

The reference, and two controls. Each born-digital page's text comes from PDFBox 3.0.3, the pinned jars RuleSage reads with, filtered to visible glyphs: Ghostscript renders the page with and without its text, and a glyph counts only where the two differ. A page with under 200 visible characters, or under 0.8 of its glyphs visible, is a thin reference and leaves every arm: 27 did, among them 9 of the 30 fine pages and 1 of the 30 oversize pages, which is why those rows hold 21 and 29, and 10 of them among the 200 natural pages, 5.0%, at the void rule's limit and not over it. Because rulebook art repeats the body's words, every engine also reads the text-removed render, and any output line matching a line read from it is removed before scoring. And every body page's output is also scored against the next rulebook's reference: that null coverage was 0.0065 for Indra and 0.0055 for both Tesseract arms, against a void bar of 0.03.

The arms, and how it ran. Every engine read the same grey 200 dpi render from pypdfium2, Indra's own PDF path. Indra 1.1.2 ran its default models, one thread per process; at four threads it wrote identical text on 190 of 190 natural pages. Tesseract 5.5.0 ran with its default page segmentation, with tessdata_best (its repository at commit e12c65a9, 2024-03-09) and with the distribution's tessdata_fast. The scorer is a greedy flexible character accuracy after Clausner et al., not their implementation, at an alignment cutoff of 70; a cutoff of 60 and a case-folded reading are reported as sensitivities, and no gated class or table row (G1, G2, G5, G6) changes status under either; G3 and G4 were not recomputed under them. It ran CPU only, on one laptop's Intel Core Ultra 9 290HX Plus, with no graphics card touched, every rulebook-touching step in its own network-off system unit with the runtime's telemetry switched off: sockets were probed before and after each of the 48 batches and none opened, and the telemetry files the runtime would write were absent after every batch. Rulebook bytes lived only in a private working folder deleted by exact path at the end of each batch; the result files hold numbers, document ids and page numbers. 949 pages ran, 0 process errors, 0 void rules tripped.

The page classes

Each row is the gated reading, micro-averaged: sums first, then ratios. Word F1 balances how many output words are in the reference against how many reference words were output. Digits exact is the share of the reference's digit-bearing tokens read exactly inside a matched window, so a token never read counts against it as much as a misread one.

On body pages Indra's read CER is under half of Tesseract's with either model, and its insertions about half. On small print all three engines miss most of the visible characters: about seven tenths by character count, about half on the 20 pages other than the one named under the gate table. What Indra did read it read well (0.79% read CER, insertions 0.0069); the two Tesseract arms also wrote unmatched text equal to about a quarter of the reference (insertions 0.24 and 0.23), and tessdata_fast's read CER was 7.56%. The page-weighted reading of the natural sample, each page weighted by its rulebook's eligible pages, is coverage 0.8917 against the unit-weighted 0.8985, at the same read CER. Six pages where both engines' read CER is over three times the set median and within 20% of each other are listed as reference suspects and kept in, as registered.

The geometry the code sees. Indra resizes every page to a 1,024-pixel long side for its line detector, whatever the render resolution, and runs a second pass at up to 2,048 only when the page's median detected line is under 9 px. So the plan binned every S1 page by that covariate, the median word-box height in the detector's frame:

The 21 pages under 9 px are not the fine class's 21 (they share 9): the bins are a geometry covariate, the classes a text-layer stratification. Both engines fall away below 9 px, and nothing here says why Tesseract does.

Degraded rasters. The gated S4 row read almost as the clean render did, and Indra's two ungated rungs hardly moved:

A born-digital render pushed through a JPEG is a stand-in for a scan, not a scan; the plan says so.

The real image-only pages: text found, not text checked

There is no reference for an image-only page, so nothing on these 635 pages is an accuracy figure. What the plan allows is yield, per row of what the pages are.

Row (1) holds the pages likeliest to carry rules, the two no-text games among them, and every engine found at least 200 characters on 82 or 83 of the 85, a median of about 1,700 a page. On the 82 pages where both Indra and tessdata_best found at least 200 characters, the two outputs differ by a median flex CER of 0.047, Indra read against Tesseract's text: agreement between two engines, not correctness, and the plan's only road to correctness here is a person (below). Row (2)'s text may already reach RuleSage through the sibling's layer. Rows (3) and (4) yielded little: on the 351 covers Indra found at least 20 characters on 245 and at least 200 on only 3, and each engine found at least 20 characters on fewer than half of the 159 interior pages (Indra 67, each Tesseract arm 59).

The diagnostic: the detector's working size

The plan allowed one mechanism diagnostic, frozen with it and reported, never gated, and the critique it folded before the freeze said in advance how it would be read: an Indra arm with its detector's working long side raised from 1,024 to 2,048 px and its adaptive cap from 2,048 to 4,096, by a patch in the bench's wrapper, on S1's fine and oversize pages only; "if coverage recovers, the cap is the mechanism; if it does not, it is not"; reported, never a deployment setting. In the smoke, on 2 fine and 3 oversize pages, it recovered little (fine coverage 0.473 to 0.500), and the plan recorded that on those five pages the detection scale was not the main cause.

The registered run made that one change to the detector's working size, both numbers raised together, on the 21 fine pages: coverage went from 0.3007 to 0.7033 and word F1 from 0.458 to 0.731, while read CER rose from 0.79% to 2.96%, nearly four times, and insertions from 0.0069 to 0.0150. On the 29 oversize pages, already passed, coverage moved from 0.9618 to 0.9678. As a class figure that is the critique's "recovers", but the run's per-page rows show where it came from: one of the 21 pages carries 39% of the fine class's visible characters, and its coverage went from 0.01 to 0.99; on the other 20 pages coverage moved from 0.49 to 0.52, as little as in the smoke. (That split is read from the per-page result rows after the run; it is not a registered figure.) So the diagnostic isolates a cause for one page, where Indra's default detector working size, a 1,024 px first pass with a 2,048 px cap, is nearly the whole of the miss, and not for small print: on the other 20 pages both engines miss about half of the small print, and the cause is not isolated. It says nothing about why Tesseract misses the same text, which the diagnostic did not touch. This is a diagnostic: not a pass, and not a proposal. Any use of a larger detector size would need its own registered plan, with a guard built on Indra's own measured line heights, because an image-only page has no text layer to classify it by.

The predictions, written before the run

Nineteen predictions were frozen with the plan, each with a band, and scored HIT or MISS with the ends included: fourteen hit, five missed. A twentieth, on speed, was conditional on a PASS and was not scored.

P3b was narrowed to the failing side of the bar before the freeze, so that a pass would have read MISS. The plan says what the bands rested on: P6 and P7 on judgment alone, the smoke having run no table or image-only pages; P3 on two fine and three oversize smoke pages. Three of the five misses are in Indra's favour; one is fine coverage falling below even the predicted-fail band; one is the interior image-only pages yielding less than expected.

What this means for RuleSage: nothing changes

This was a gated bench, and the gate said REJECTED. In the plan's words, this outcome "licenses nothing new". The 635 image-only pages stay unread by RuleSage, no OCR text enters its corpus, and Indra is not proposed for anything. Had every row passed, the plan would have licensed only a proposal, to be measured in its own change on real image-only pages, never a replacement for the text-layer path; it did not pass.

Two things we could do next

The first is the plan's own optional follow-up; the second is what the plan says any class-guarded use would need first, and after the split above its premise rests on one page's reading. Neither is started or promised.

• A human rubric on 20 of the real pages. Twenty pages seeded from row (1), each shown beside Indra's text to a member of our team on a local page never opened by an agent, and graded all, most, some or none right, plus whether the page holds rules text at all; only the counts kept; about 30 to 40 minutes of one person's time. It is the only evidence that could ever back a sentence about whether RuleSage could answer from the two games that have no text.
• A registered run at the larger detector size, as an arm of its own under a new plan with its own bars and a guard computable from Indra's own line heights.

What this cannot say

• Accuracy on the real image-only pages. They have no reference; S4 is a stand-in, and the sibling layers are someone else's OCR at 72 ppi.
• Anything beyond these pages and this scorer. One page per rulebook, English only, one archive; a greedy flexible matcher, not the reference implementation; a fine class 21 pages wide.
• Why either engine misses small print. On 20 of the 21 fine pages the diagnostic recovered little, and it touched Indra only.
• Table structure, handwriting, or text inside pictures on born-digital pages beyond what the image-text control removes.
• Anything about RuleSage's answers. No retrieval or answer evaluation ran.
• Anything about speed. The plan reserves speed rows for a PASS, and there was none; no speed figure, ours or the README's, appears here.

What to take with you

• On rulebook body text, Indra OCR 1.1.2 on a CPU read 0.38% of characters wrong and found 0.978 of the visible text, one page per rulebook over 169 pages; tables, a 150 dpi JPEG stand-in and oversize spreads met their bars too.
• It beat Tesseract 5 (tessdata_best) on the paired 190-page sample by 7.52 points of flexible character error, the whole interval below zero.
• On small print all three engines here miss most of the text: Indra found 0.30 of the visible characters, tessdata_best 0.29 and tessdata_fast 0.33, against a bar of 0.60. That one row is the verdict, REJECTED, and the plan predicted it.
• One diagnostic found a cause on one page, not for small print: doubling the detector's working size lifted fine coverage from 0.30 to 0.70, almost all of it on one page that carries 39% of the class's characters; on the other 20 pages coverage moved from 0.49 to 0.52. Planned, reported, never gated, not proposed.
• Nothing at RuleSage changes. Its 635 image-only pages stay unread.

The licence, as published

Indra OCR's code is under Apache-2.0, read at its repository's commit e20355319b5a. Its weights are under the "AI PUBS OPEN RAIL-M LICENSE (MODIFIED)", version 0.1 of 2 March 2023, read at the weights repository's commit a1283c4b, the revision the package pins. Its Attachment A bars use by anyone over $20 million of prior-year gross revenue or of total equity or debt funding, "except where Your Use is limited to personal use or research purposes"; its clause 2(c) bars use "for any purpose" if the user, or an entity the clause ties to the user, "provides or otherwise makes available any product or service that competes with any product or service offered by or made available by Licensor or any of its affiliates", with no research exemption; its §7 asks for attribution; and its §8 applies the licence to the model's output and derivatives of it. This bench published no output: no OCR text left the run's folder, and nothing it produced enters RuleSage. The weights ran pinned, network-off, on this workshop's own CPU, as an evaluation.

Who ran this, and thanks

Thanks to Datalab for releasing Indra OCR, its code under Apache-2.0 and its weights under the licence above, and to the Tesseract project for Tesseract 5.5.0 (Apache-2.0) and its tessdata_best models. The rulebooks are their publishers' copyrighted work and stay inside RuleSage's archive; this page prints counts and scores only. Software the bench stood on: ONNX Runtime 1.31.0 (MIT), which ran Indra on the CPU; PDFBox 3.0.3 (Apache-2.0), the reference's text; Ghostscript 10.06.0 (AGPL-3.0), the visibility renders; pypdfium2 5.14.0 (Apache-2.0 and BSD-3-Clause, over PDFium), the engines' input; rapidfuzz 3.14.6 (MIT), the alignments; NumPy 2.5.4 (BSD-3-Clause) and OpenCV 5.0.0 headless (Apache-2.0); Python 3.13 and Java 21. The matcher follows Clausner, Pletschacher and Antonacopoulos's flexible character accuracy as a greedy implementation of our own. A small human team asked the question, approved the plan before the run and will approve this page; a fleet of AI agents wrote the plan, the critique and the kit, ran the census, the smoke and the registered run, and drafted this page under that team's rulings.

Sources

Read 2026-10-27 (UTC) unless dated otherwise.

• Our records: the frozen plan (sealed 04:09:49Z, 2026-10-27), its critique pass and closure check, the census, and the registered run's result files (written 13:59:38Z, 2026-10-27). No data kit ships, because the page lists name archive files.
• Indra OCR, code and README: https://github.com/datalab-to/indra · weights, model card and licence at the pinned revision: https://huggingface.co/datalab-to/indra-ocr
• Tesseract 5 and tessdata_best: https://github.com/tesseract-ocr/tesseract · https://github.com/tesseract-ocr/tessdata_best
• Clausner, Pletschacher and Antonacopoulos, "Flexible character accuracy measure for reading-order-independent evaluation", Pattern Recognition Letters 131 (2020), 390–397, doi:10.1016/j.patrec.2020.02.003.

Measured 2026-10-27, 12:46:59Z to 13:59:38Z (UTC), on one laptop CPU: three OCR arms plus one diagnostic arm, every reference and both control renders, 0 process errors, 0 void rules tripped. One frozen plan, twelve gates, nineteen scored predictions.

Corrections and later measurements will be added below, each dated (UTC), with a window at both ends where one applies and saying in plain words what it counts.