How a paper archive becomes searchable
A company's paper archive is decades of invoices, contracts, delivery notes and letters that nobody can search. We scanned one whole archive, read every page with a vision model running on our own GPUs, and turned each document into typed fields you can find by number, date, partner or amount. The system checks for new arrivals every fifteen minutes and processes them in order.
A look under the hood: how the reading works, why every field must be grounded in the transcription, what happens when the model and the old labels disagree, and how sensitive documents stay hidden.
The short version
Paper goes through a scanner into an open-source archive. Each page is transcribed by a vision model on our own hardware, so nothing leaves the company's control. From the transcription, code and model together classify the document into a controlled vocabulary and extract typed fields: document number, date, net, VAT and total, partner identifier, currency. Every written value must be grounded in the transcription; a value the text does not contain is not written. Documents tagged as sensitive are visible only to people with that scope. A timer picks up new arrivals every fifteen minutes.
As of 2026-09-12 that is 2,526 documents and 7,183 pages read on our own GPUs, the counts we publish on the homepage. What follows is why it is built the way it is.
Scan, read, type, scope, find. The green step is the point: fields that are grounded in the page's own text, never guessed, so a search result is something you can act on.
The model reads, the code decides
A vision model is very good at reading a stamped, folded, photocopied invoice and very bad at being the last word on what the invoice means. So the split is strict: the model produces a transcription; deterministic code checks that each proposed field actually appears in that transcription before anything is written to the archive. Printed text comes out essentially perfect. Handwriting is approximate and is marked as such.
The controlled vocabulary is the company's own document types, not a generic taxonomy. Where an older sorting scheme had already labelled a document one way and the model reads it another, the document goes to a review queue instead of being silently overwritten. Disagreement is surfaced, not resolved by whoever ran last.
Sensitive documents stay with the people allowed to see them
Archive everything, then gate by role. A tag marks documents as sensitive, and the HQ only shows those to people who hold the archive scope for them. Everyone else does not get a locked entry; they simply do not see the document exists. The same scope applies to the agents, so no question phrased cleverly enough returns a file the person could not open.
The working-file side is mirrored the same way: each person's own cloud drive is synced both ways into the HQ, so the files they work on are theirs and the archive's originals are the company's.
Why our own GPUs
Two reasons, and cost is the smaller one. The first is that a company's archive is the most private thing it has, and a whole-archive read is exactly the job you do not send to a third-party API. The second is throughput: a whole-archive refresh is thousands of pages in one night, which is a batch job for a serving stack we run and measure, not a metered endpoint.
The stack is described in our production field report: the same model that reads these pages serves the rest of our fleet, and the archive digitizer is one of its measured workloads.
A field the page does not contain is not written. That rule is what turns a pile of scans into records you can trust.