From Manual Review to Machine-Speed Accuracy

Manual processing was slowing our client down—thousands of mixed PDFs took days to classify, split, and key. We, at Futluz, engineered a GNIS AI pipeline (pronounced "Genius AI") — our private AI, trained on industry and corporate data and deployed inside the client’s own perimeter—with custom training across hundreds of formats, plus our own orchestration and review loop. The result: ~700,000 multi-page documents at 98.5% accuracy, minutes-not-days cycle times, and audit-ready JSON for seamless downstream integration. Intelligence came to the enterprise; the data never left it.

TL;DR

Problem: Thousands of semi-structured documents, heavy manual effort, slow turn-around, frequent errors.

Approach: GNIS AI–based pipeline with splitter/classifier, custom extractors, and batched processing—running entirely within the client’s network; wrapped with our own orchestration, validation, and exception-handling.

Scale & results: ~700,000 multi-page documents processed; 98.5% field-level accuracy (validated against client gold sets); minutes-to-seconds SLAs for ingestion → extraction → delivery.

Why it worked: Fit-for-purpose processors (digitize, classify, extract), batch APIs, and a robust toolbox—trained on the client’s own corpus and industry corpora, and augmented by our training and workaround code for edge cases.

The client challenge

A long-standing operational bottleneck: staff manually classified, split, and keyed data from thousands of PDFs and scans—medical records, legal forms, invoices, correspondence. Legacy OCR utilities struggled with layout variability, handwriting, stamps, smudges, and multi-document bundles. The result: slow cycle times, rising costs, and inconsistent data quality.

Before the current wave of AI, we trialed leading OCR services. They digitized text but lacked reliable structure and entity extraction across the client’s diverse formats. And each one required shipping sensitive records to a third-party cloud—a non-starter for the compliance team. We needed something that could understand documents, not just read them, and do it without the data ever leaving the building.

Why GNIS AI

GNIS AI, pronounced "Genius AI", is our private document intelligence platform: models pre-trained on deep industry corpora, then further trained on the client’s own corporate data, and deployed inside the client’s perimeter. That last part is the point. Intelligence is brought to the enterprise—the enterprise’s data doesn’t cross the perimeter to reach it. No documents, embeddings, or extracted fields are sent to a third-party API, and nothing the client trains on leaves their control or improves anyone else’s model.

Functionally, GNIS AI provides specialized processors for the stages that matter: digitization, split/classify to find document boundaries and types in a bundle, and extraction to turn content into fields, tables, and entities. Splitters identify page ranges but don’t physically split files; that’s intentional, and the GNIS toolbox provides utilities to perform the actual splitting and post-processing.

At scale, GNIS AI supports both online and batch APIs, with limits tuned to the hardware it’s deployed on, which let us design predictable throughput and back-pressure handling against a known capacity envelope rather than a shared multi-tenant quota.

Downstream, every run yields a canonical Document JSON—entities, pages, confidence scores, and provenance—so we can trace and audit each extracted field.

1. Private by architecture: GNIS AI runs in the client’s VPC, data centre, or air-gapped environment. Sensitive records never transit the public internet, and there is no vendor-side copy to subpoena, breach, or retain.
2. Industry-pre-trained: The base models already understand the client’s document families—claims, medical records, legal forms—so we started far up the accuracy curve instead of from zero.
3. Processor model: GNIS AI uses specialized processors to digitize, classify/split, and extract structured data—exactly the stages we needed.
4. Splitter / Classifier: Identifies document types inside large bundles and returns page ranges per document—a prerequisite to accurate downstream parsing. (Splitters label boundaries; you physically split with tooling.)
5. Custom Extractor: We trained/customized extractors on the client’s corporate data so the model learned their fields even on tricky layouts; training supports zero/few-shot through full fine-tuning for higher accuracy.
6. Batch + Online APIs: Process at scale (batch) and interactively (online) when operators need immediate results; the batch API writes structured Document JSON to the client’s own object store.
7. Toolbox SDK: Utility functions to manage responses, post-process splits, and wrangle output—handy for production pipelines.

Our solution

1. Ingestion & pre-processing
   • Documents land in secure object storage inside the client’s own environment—never in a vendor bucket.
   • A lightweight service validates MIME, page counts, and routing keys; jobs are queued into batches sized to the GNIS AI deployment’s throughput envelope, with per-processor and node-level capacity in mind.
2. Split & classify
   • We run a Splitter/Classifier processor to tag page ranges and document types inside bundles.
   • Because splitters don’t cut files themselves, we use the GNIS toolbox to physically split and persist child documents for downstream extraction.
3. Custom extraction
   • For each document type, we attach a Custom Extractor—fine-tuned on the client’s corporate data—to pull entities like names, dates, claim numbers, totals, line items, and case identifiers, even when position varies across templates.
   • We version processors as models improve, so quality gains can be deployed safely per type. Model weights and training artifacts stay in the client’s registry.
4. Validation & exception handling
   • We set confidence thresholds per field and route “low-confidence” cases to a review queue in our app—an in-house review UI with audit logs and keyboard shortcuts, running alongside the model on the same private infrastructure.
   • Operators correct fields; corrections feed a feedback store we use to re-train/fine-tune specific extractors.
5. Delivery & downstream integration
   • Normalized JSON aligns to the client’s master schema; we publish to message topics for downstream systems, data warehouses, and dashboards.
   • All processing returns Document JSON (structured pages, entities, provenance) for full traceability—delivered over the client’s internal network.

Training & quality management

We started by enumerating critical fields by doc type and writing labeling guidelines. A small, carefully curated training set per family consistently outperformed large, noisy datasets. We ran short training cycles, instrumented confidence histograms by field, and targeted the worst offenders (handwritten dates, stamped IDs, table totals) with layout-aware rules and post-processors. Each correction in review generates a “truth row” we can fold back into training—inside the perimeter, on the client’s own hardware. Over time, this closed-loop learning pushed the accuracy needle past 98.5% on the client’s gold sets, with measurable gains on long-tail formats. Because the model is theirs, every correction compounds into an asset they own.

Operations at scale

We designed idempotent batch jobs sized to the deployment’s batch limits, added retry policies for transient errors, and exposed a “traffic-light” dashboard (queued, processing, blocked, done). During spikes, the orchestrator meters submissions so we never overshoot cluster capacity or processor concurrency. Because the GNIS toolbox was built exactly for managing these outputs, it simplified a lot of the page/entity wrangling we otherwise would have scripted ourselves.

Security, privacy, and compliance

Processing occurs entirely inside the client’s perimeter—their VPC, data centre, or air-gapped enclave—with restricted role-based access, network egress controls, and per-bucket encryption. There is no third-party inference call, so there is no data egress to minimize in the first place: documents, prompts, embeddings, and extracted fields all stay within the client’s trust boundary, and the model is never trained for anyone else. We keep retention times tight and rely on the Document resource’s provenance for audit trails. The outcome: faster audits with less risk, and a data-residency story that satisfies the compliance team without a carve-out.

What the end-users experience now

Operators drop a batch and watch documents route themselves: bundles split automatically; types are labeled; fields appear with confidence badges; and any low-confidence items queue for quick human confirmation. The rest flows as standardized JSON into the case management system and the warehouse—so analytics teams can work immediately, not weeks later.

Business impact

Cost: Significant reduction in manual processing hours; reviewers now focus on true exceptions.

Speed: Intake-to-insight time collapsed, accelerating downstream case work.

Quality: Consistent, reproducible extraction with full audit trails.

We combine GNIS AI’s processors and SDKs with production-grade engineering: batching/orchestration, validation UIs, and feedback-driven training. Because the whole stack runs where your data already lives, the outcome is a repeatable blueprint you can apply across departments and document families—with measurable gains in speed, cost, and accuracy, and none of the exposure that comes with sending your records to someone else’s cloud.