Reads the archive. Writes nothing without an archivist.
Scriba turns scanned records into described, searchable, sensitivity-classified documents: OCR for typed pages, a vision-language model for handwriting, ISAD(G) metadata drafts with every AI field labelled, and a search that answers with the page it found. It runs on a single GPU inside the archive, and nothing reaches the catalogue until a person has reviewed it.
The chain of custody
01
Ingest
Records and digital objects sync from the archive management system through its API, read-only.
02
Read
Layout analysis, OCR on typed pages, vision-language transcription for handwritten ones.
03
Describe
Page descriptions, summaries, keywords, subject headings and ISAD(G) fields, each labelled as AI output.
04
Classify
Four sensitivity levels from personal-data detection plus a contextual reading of each document.
05
Index
Text, visual and multi-vector embeddings, fused with full-text search.
06
Review
An archivist confirms or corrects sensitivity and metadata in the portal. Only reviewed records go on.
07
Write back
Appended to the catalogue through the same API, never overwriting, every write logged.
What it does
Reads two kinds of page
Typed pages go through layout analysis and OCR in under a second each. Handwritten pages go to a vision-language model that reads the page as a whole, slower and more forgiving of nineteenth-century cursive.
Drafts the description
A self-hosted language model writes summaries, keywords, subject headings and ISAD(G) fields from what was read, and checks them against the existing catalogue entry. Every generated field is labelled as such, in the data and on screen.
Flags personal data
Named-entity detection finds identifiers, addresses and contacts; a second model reads the context. The result is one of four GDPR-aligned levels, from public to restricted, with the reason spelled out for the archivist.
Finds by meaning
Semantic search fused with full-text search, visual similarity across page images, an entity explorer, and a chatbot that answers from retrieved pages, cites file and page, and says so when it finds nothing.
What the archivist sees
A web portal, in Portuguese, built around the review work rather than around the models. Four of its screens carry the day-to-day.
Arquivo
The archival hierarchy as synced from the catalogue, fonds to document, with each page image and the AI overlays on it: layout regions, recognised text, the generated description side by side with the original.
Sensitivity review
Every file with its level and the reason behind it. The archivist changes the level, leaves a note, and the change lands in the audit log.
Quality assurance
What the catalogue says about a record next to what the AI read in it: a wrong date, a title that hides the real subject, an entity nobody indexed. Corrections stay local until reviewed.
Pipeline monitor
Progress per stage, what is queued, what failed and why. Every stage is idempotent, so a failed page is re-run, not re-imported.
Where it runs
- On a single 32 GB GPU inside the archive. Eleven open-weight models take turns in scheduled memory profiles: reading, describing, indexing and answering never compete for the same card.
- No page, transcription or query leaves the building. There is no outside AI provider in the loop and no per-token bill.
- It connects to the archive management system already in use through its API: read-only for ingest, and for write-back only reviewed records, appended, logged.
- Everything is declared in code and runs as a small set of containers, so the archive's own IT can restart, back up and move it.
What it will not do
- Read handwriting fast. A vision-language model takes minutes per manuscript page, against under a second for a typed one. A large handwritten series is a matter of weeks, and the transcription is a draft, not a diplomatic edition.
- Publish an accuracy figure it has not earned. We measure against a frozen, hand-transcribed sample before quoting one, and until then we quote none.
- Decide access on its own. The four levels are a starting point; the archivist sets the final one, and historical material can be over-classified by design rather than under.
- Write to the catalogue unsupervised. Ever. The pilot has processed two historical record series end to end and is not yet serving citizens.
Bringing Scriba to an archive
- 01
Connect
Read-only sync of records and digital objects from the archive management system, onto a GPU machine the archive owns. Nothing is written yet.
- 02
One series, end to end
A first record series goes through the whole chain. Archivists see the results in the portal within days for typed material, longer for manuscripts.
- 03
Review
Sensitivity and metadata review in the portal, with corrections and notes. This is where the archive teaches the system what it wants.
- 04
Write back
Reviewed records only, appended to the existing description through the catalogue API, reversible and logged. Then the next series.
Questions about Scriba
Does Scriba replace the archivist?
No. It replaces the part of the work no archive has time for: reading every page, drafting a description, spotting personal data, indexing. The judgement stays with the archivist, and the system is built so that it cannot proceed without it: every write-back to the catalogue is gated on a human review, and every generated field is labelled as AI output in the data itself.
Which standards does it follow?
Descriptions are drafted into ISAD(G) fields and written back into the existing catalogue rather than a parallel one. Sensitivity uses four levels aligned with the GDPR, mapping onto the ISAD(G) access-conditions element, from public to restricted. Every change made in the portal, and every write-back, is recorded in an audit log.
Can it read handwriting?
Yes, with honest caveats. Classical OCR reads typed pages well and fast. On nineteenth-century cursive it produces nothing usable, so handwritten pages are transcribed by a vision-language model that reads the page as an image. That path is slow, minutes per page, and yields a draft transcription good enough to search and to describe, not a diplomatic edition. We publish no accuracy figure until it is measured on a frozen, hand-transcribed sample.
Where does the archive's data go?
Nowhere. Scriba runs on a single GPU machine inside the archive, with eleven open-weight models scheduled to share its 32 GB of memory. Pages, transcriptions, descriptions and search queries stay on that machine. There is no outside AI provider in the loop, which is what makes the sensitivity classification defensible: the documents being classified for personal data are never sent to a third party to be read.
Which archive management systems does it work with?
Any system with an API for records and digital objects. The pilot integrates with the archive's existing management system through its REST API: read-only ingestion of descriptions and files, and a gated write-back that appends the reviewed AI summary to the existing description without overwriting it. Adapting the connector to another system is part of a deployment, not a new product.
An archive nobody can search yet?
Tell us what it holds, how it is described today, and what hardware you have. We will come back with a first-series plan, in Portuguese or English.
[email protected]