Documents become structured intelligence.
nautris is a document compiler. Any PDF, Office file, HTML page, image, e-mail, or scan is lowered into one canonical, lossless representation, the CDOM, from which every output is generated. Deterministic, traceable, reproducible, and entirely inside your own walls.
No document ever leaves your network. Verify it with a packet capture. No install needed either: the cloud console runs the same engine for quick tests, or as your deployment.What if documents behaved like source code?
Source code compiles to one intermediate representation, and every tool (the linker, the debugger, the optimizer) reads from it. Documents never had that. So every parser reinvents structure, every output drifts from the last, and nothing is reproducible. nautris gives documents a compiler.
Every format. Every language. Every broken edge case.
Formats arrive as chaos: clean PDFs and corrupt ones, Office files, HTML, Markdown, images, scans, right-to-left Arabic, CJK, tables that span pages. Readers lower each one into the same canonical tree. Adding a format is a plugin, never an N×M rewrite.
One representation. The single source of truth.
The Canonical Document Object Model is a flat tree of typed blocks joined by relationship edges. It preserves hierarchy, tables, images, reading order, metadata, and page coordinates. Nothing is thrown away. It is versioned and deterministic: the same bytes always compile to the same tree.
every node traces back to a page coordinate
Structure is not enough. It reads the fields.
On top of the CDOM, deterministic analyzers extract meaning: tables become datasets and forms become named fields. An invoice stops being pixels and becomes invoice_number, total, supplier. Rules only, no model guessing, and every field carries the exact block it came from.
The same analyzer layer recovers table structure, pulls labelled key/value pairs, and reads invoice and form fields, always with rules, never a model. Each result is a semantic object attached to the block it came from, so a field is one click from the page it sits on, and it carries an honest per-field confidence.
A compiler, front to back.
The core path is generative-model-free: deterministic passes, no LLM in the loop. Everything before the CDOM builds it; everything after is an exporter reading from it.
Readers
Per-format lowering. Magic-byte typing, native text vs. OCR routing per page.
Cleaning
Normalize, de-duplicate, repair broken text layers, detect PII for review.
Normalization
Unicode, reading order, language detection, table structure recovery.
CDOM
The canonical tree. Versioned, deterministic, provenance on every node.
Exporters
JSON, RAG, graph, context, fine-tune. Each reads the same tree.
Same source. Another exporter.
The CDOM never changes. Choose an output and the engine regenerates it from the same tree, with no re-parsing and no drift. Click through:
A parser that guesses is a liability.
A model that reads your document invents what it cannot see and answers differently every time. In regulated work that is not a feature. It is a defect you cannot audit.
- HallucinatesFills gaps with plausible text that was never on the page.
- Not reproducibleThe same file yields a different structure on the next run.
- UnauditableNo trace from an output back to where it came from.
- DeterministicSame bytes in, identical CDOM out. Every time.
- Traceable & versionedEvery node carries its page and bounding box; the schema is pinned.
- ExplainableNo generative model touches your data on the core path.
See exactly where every answer came from.
Open a document in the review UI and the CDOM is drawn back onto the source page: every block boxed and numbered in reading order, coloured by type, and flagged where personal data was found. Provenance you can point at, not take on faith.
every output node links back to the exact page coordinates it came from
The reason regulated teams can adopt it at all.
It runs where the documents already live. Nothing is sent out, nothing phones home, and the whole engine is a single self-hosted artifact gated by an offline-verifiable license.
In your walls
On-prem or your VPC. Documents never cross the perimeter.
GDPR-native
PII detection with human-approved redaction, audit-log export.
Air-gapped
Offline-verifiable licensing. No outbound calls, ever.
Horizontal scale
Dead-letter isolation, retries, idempotent re-runs across the batch.
numbers from the built-in evaluation harness, reproducible on your own corpus: run it yourself
Measured on the shipped product. Not a lab build.
Every number below comes from the released container image running on a single rented cloud GPU, driven from outside over the public API. Timings cover the whole path: upload, extraction, chunking, embedding, semantic indexing. The corpus and the scoring harness ship with the engine, so every figure is reproducible.
methodology: one worker on one NVIDIA RTX 4090, no batching, warm-up excluded; accuracy scored by fetching the canonical trees back over the API and running the published harness against ground truth. reproduce it on your own documents
And on the industry's public benchmark: first place.
nautris is a document compiler platform: many input formats in, ETL, provenance, governance, and six output formats out. The tools below do one slice of that: PDF parsing. On the public DP-Bench comparison (200 documents, published ground truth, the benchmark's own scoring code, unmodified), the platform outranks every dedicated parser: first overall, and first on all three quality metrics. Both engine modes are published: the full pipeline holds first place, and the model-free fast mode (a per-page hybrid since 0.9.0: it handles most pages in milliseconds and routes only the pages that demand it to the full pipeline) places on its own at #5 with reading order equal to the full pipeline's.
measured 2026-07-22 on the released nautris engine (first on the 0.8.4 image, reconfirmed byte-identical on the 0.9.0 release) against the open opendataloader-bench harness (DP-Bench corpus): their corpus, their metrics (NID, TEDS, MHS), their evaluator, unmodified; competitor scores are the benchmark's own published results, reproduced byte-exact before ours were scored; the benchmark's internal experimental variants (excluded from its own charts) are likewise excluded here. 200/200 documents, zero failures, 0.93 s/document on one RTX 4090 and 1.62 s/document on an 8-vCPU CPU pod, where the identical run rescored 0.920: same result, no GPU required.
Don't take our word for it. Run your own documents through it.
Point it at a folder of your real, messy files and it returns a quality report: what was extracted, coverage by format, table and field counts, OCR use, mean confidence, and exactly where it flagged low-confidence or personal data. Reproducible, self-hosted, and yours to inspect before you commit a single document.
Running in three commands.
One container, one license token, no account and no API keys to invent: the engine mints its own token on first boot and shows it in the review UI.
Get a free license
Personal licenses are free and issued instantly, straight to your e-mail. The engine verifies the token offline.
# from get.nautris.com export NAUTRIS_LICENSE="nl1...."
Pull and start the engine
Pull the public image straight from our registry, no account or login, then bring the stack up. Your API token is in the startup logs.
docker pull registry.nautris.com/nautris:latest
docker compose up -d
docker compose logs api | grep "Default API token"
Compile a document
One call in, the canonical tree out. Then open localhost:8000/ui to see it drawn on the page.
curl -X POST localhost:8000/v1/parse \ -H "X-API-Key: dek_..." \ -F "file=@mydoc.pdf" | jq .tree
Pull it from our registry (registry.nautris.com/nautris, public, no login). Full walkthrough, production setup, and configuration in the docs.
Free for personal use. Let's talk for commercial use.
nautris is free to run for personal, non-commercial, and evaluation use. If you deploy it inside a business, or embed it in a product, service, or tool you charge for, contact us and we'll agree a fair commercial license together.
- Personal & non-commercial projects
- Research & evaluation
- The full engine, self-hosted
- No account, no phone-home
- 90-day license token, renewed free in one click
- Company & production use
- Embedded in a paid product or tool
- Air-gapped & compliance options
- Priority support & SLA
nautris is proprietary software. © 2026 nautris. All rights reserved. See the terms. Licensing questions? Write to contact@nautris.com.
Questions engineers ask first.
Does any document or telemetry ever leave my network?
No. The engine runs entirely inside your infrastructure, the license token is verified offline against a public key pinned in the build, and there is no phone-home of any kind. It is the sort of claim you should not take on faith: run a packet capture and watch the silence.
Do I need a GPU?
No. The core path is fully CPU-deterministic. The same published image accelerates OCR automatically when an NVIDIA GPU and the container toolkit are present (10-30x faster on scanned documents, byte-identical output), and simply runs on CPU otherwise.
What does it take to run?
Docker Compose and a modest machine: 2 cores and ~6 GB of RAM to start, 4+ cores and 8-16 GB to be comfortable, ~12 GB of free disk for the image and model cache. When resources run short, failures stay contained and visible; nothing corrupts silently.
Can it run fully air-gapped?
Yes. Licensing is offline-verifiable and nothing phones home. The only network fetch anywhere is a one-time model download on the first job; pre-seed that cache from a connected machine and the deployment runs fully disconnected.
What happens when it finds personal data?
Deterministic detectors flag PII blocks and hold them for review. A person approves or rejects each redaction in the review UI, approved redactions are applied on export, and the audit log records who decided what.
What exactly counts as commercial use?
Any use inside a business or organization, any production deployment, and any use where the engine is embedded in or supports something that generates revenue. Personal projects, research, and evaluation are free. In short: run it freely for yourself; talk to us before you build a business on it. The terms spell it out.
Can I evaluate it at work before buying?
Yes. Evaluation is part of the free grant, so you can prove it on your own documents inside your company before any money changes hands. The commercial license starts when the evaluation ends and the engine goes into real business use.
How is commercial pricing structured?
There is no one-size price list: a license is agreed per deployment and use case, so a single team processing invoices is not priced like an OEM embedding the engine in a product. Tell us what you are building at contact@nautris.com and we will agree a fair license together.
Can I embed it in a product I sell?
Yes, that is exactly what the commercial license covers: embedding, OEM, and offering the engine's capabilities inside your own product or managed service. It is not permitted on the free tier, so contact us and we will set up terms that fit.
Which formats can it read?
PDF (born-digital and scanned), Word, PowerPoint, Excel, HTML, Markdown, plain text, images, and e-mail. Every reader lowers its format into the same canonical tree, so adding a new format is a plugin, never a rewrite of the pipeline.
Get in touch.
No ticket queue and no bots on this end: mail goes straight to the people building the engine, and a human answers.
contact@nautris.com
Deployment help, questions while evaluating, bug reports, feedback: anything about running the engine.
COMMERCIAL & LICENSINGCommercial licensing
Commercial licenses, OEM and embedded use, pricing for your deployment. Same inbox, marked subject: it gets priority.
Build your document intelligence on facts, not guesses.
Free to prove on your own documents, self-hosted from the first minute. Going to production inside a business? Reach out and we'll set you up with a commercial license.
Prefer not to run it yourself? Try it in the cloud - the hosted console, with the engine managed for you.