DocxIntel home
DocxIntel, a product of BizfyLabs
DocxIntel, a product of BizfyLabs
by
BizfyLabs
  • Capabilities
    • Analyse

      Resolve layout, reading order, tables and handwriting

    • Identify

      Pull entities, fields and clauses with coordinates

    • Classify

      Sort document types and split multi-page packets

    • Map

      Link and reconcile entities across your estate

    • Modify

      Redact, mask and transform documents safely

    • Ask

      Query your documents and get cited answers

    • All six capabilities, one platform→
  • Deployment
  • Accuracy
  • Industries
    • Banking & Financial Services

      Statements, KYC files, and financial filings

    • Insurance

      Claims, policies, and underwriting documents

    • Government & Public Sector

      Records, correspondence, and regulatory filings

    • Healthcare

      Patient records, referrals, and lab reports

    • Legal & Compliance

      Contracts, filings, and case documentation

    • Energy & Utilities

      Engineering documents, contracts, and reports

    • Every regulated industry we serve→
  • Pricing
  • Docs
Book a Demo
Home
DocXIntel

Menu

    • All capabilities
    • Analyse
    • Identify
    • Classify
    • Map
    • Modify
    • Ask
    • All industries
    • Banking & Financial Services
    • Insurance
    • Government & Public Sector
    • Healthcare
    • Legal & Compliance
    • Energy & Utilities
    • Deployment models
    • Reference architectures
    • Sizing & throughput
    • What's in the box
    • Security posture
    • Documentation
    • Accuracy benchmark
    • Pricing
    • Proof of Value
    • Compare
    • About
    • FAQ
    • Contact Us
Bundle contents

Exactly what you are installing, listed component by component.

Nine container images, an open-weight model set you keep, a Helm chart, SDKs, connectors, an offline documentation set and a security pack with an SBOM per image. Roughly 62 GB, signed, checksummed, and complete on arrival — because a bundle that needs to fetch something later is not an air-gapped bundle.

  • 9 signed container images
  • ~46 GB of open-weight models
  • CycloneDX SBOM per image
  • Full documentation, offline
Request the bundle manifest
Read the model licences
The DocxIntel deployment bundle contents — container images, model weights, charts and documentation
9
Container images
signed with cosign
46 GB
Open-weight model files
yours to keep and pin
~62 GB
Total bundle, compressed
one file, one checksum manifest
18 months
Support window per LTS release
security patches throughout

Bundle size varies by release as models are added or replaced. The exact manifest, with per-file sizes and SHA-256 digests, is published with every release and is available before you sign anything.

Services

The nine services that make up a DocxIntel deployment

Each ships as its own OCI image with its own SBOM, so you can scan, sign off and scale them independently. Only four of them ever request a GPU.

CPU

API gateway

TLS termination, OIDC and SAML token validation, role enforcement, rate limiting and request auditing. The only service anything outside the cluster ever talks to.

  • REST and gRPC on TCP 443
  • OpenAPI 3.1 specification published
  • Per-tenant and per-key rate limits
CPU

Orchestrator

The job state machine. Splits documents into page tasks, enqueues them by priority class, tracks attempts and retries, and commits state to PostgreSQL before acknowledging anything.

  • Interactive and bulk priority classes
  • Backpressure at a configurable high-water mark
  • Dead-letter queue visible in the console
GPU

Layout and OCR service

Page normalisation, layout segmentation, reading-order resolution, table-structure reconstruction and text recognition across Arabic and Latin scripts, including handwriting.

  • Deskew, dewarp and glare correction
  • RTL and bidirectional reading order
  • Coordinates and confidence on every block
GPU

Extraction service

Field, entity and clause extraction against schemas you define in the console, with every returned value carrying the page number and bounding box it came from.

  • Schema-driven field extraction
  • Cross-document entity mapping
  • Per-field confidence thresholds
GPU

Classification service

Document type classification and automatic splitting of multi-document packets, so a 300-page submission arrives at your workflow as the twelve documents it actually contains.

  • Customer-defined taxonomies
  • Packet boundary detection
  • Routing rules with confidence gates
GPU or CPU

Retrieval service

Chunking, embedding and vector search over the corpora you choose to index, providing the grounded context that makes Ask answers citable back to a page.

  • pgvector index inside your PostgreSQL
  • Hybrid keyword and vector search
  • Per-corpus access control
GPU

LLM serving

Serves the open-weight instruction-tuned model that powers Ask, mapping and summarisation, over an internal OpenAI-compatible interface reachable only inside the cluster.

  • Continuous batching for throughput
  • Deterministic decoding options for audit
  • Never reachable from outside the namespace
CPU

Admin and reviewer console

The browser UI: review queues with side-by-side page highlighting, schema and taxonomy design, user and role administration, audit search and the offline documentation set.

  • Side-by-side value and source highlighting
  • Role-based review queues
  • Arabic and English interface
CPU

Worker pool

PDF rasterisation, format conversion, archive expansion, connector polling and result delivery. CPU-bound work kept off the GPU tier, and usually the first thing you scale.

  • Rasterisation and format conversion
  • Connector polling and file delivery
  • Webhook and message-bus dispatch
Models

Open weights, on your storage, under a licence you can read

The models ship as files. They land on a volume you own, they are checksummed at load, and they keep working whether or not anyone is still selling them. That is the difference between owning a capability and renting access to one.

  • What ships: layout and table-structure models, a text-recognition ensemble covering Arabic and Latin script including handwriting, a document classification encoder, a retrieval embedding model, and an instruction-tuned language model in the 7 to 14 billion parameter class for Ask, mapping and summarisation
  • Why open weights matter: no external API to deprecate, reprice or rate-limit; no vendor able to change model behaviour under you between two runs of the same document
  • Reproducibility: models are pinned by version and digest, so a document processed today produces the same structured output when it is reprocessed for an audit in five years
  • Inspectability: the weight files are ordinary artefacts. Your security team can hash them, scan them, store them in your artefact repository and treat them exactly like any other dependency
  • Licence clarity: every model in the bundle ships with its licence text, and the permitted-use position for commercial deployment is published rather than buried in a contract

No customer document, prompt or extracted value is ever used to train or fine-tune anything. Your data trains nothing, because your data never leaves your infrastructure.

Read the model licences in full
Open-weight model files stored on customer-controlled infrastructure inside an air-gapped boundary
Reference

The deployment bundle, item by item

One archive, one manifest, one checksum file. Everything below is inside it on the day it reaches you.

Container images

Format
OCI image archives — loadable into Harbor, Artifactory, ECR, ACR or Quay with no registry pull
Count and size
Nine service images, roughly 14 GB compressed in total
Base images
Distroless or UBI minimal, non-root by default, read-only root filesystem where the service permits it
Signing
Cosign signatures plus a build provenance attestation, verifiable offline against a published public key
Architecture
linux/amd64. GPU images target CUDA 12.4 with driver 550 or later

Offline model bundle

Size
Approximately 46 GB of open-weight model files, delivered as a single verifiable archive
Layout and tables
Page segmentation, reading order and table-structure models
Text recognition
Arabic and Latin script recognition including handwriting, diacritics and Arabic-Indic numerals
Classification and embedding
Document type encoder and the retrieval embedding model used by Ask
Language model
Instruction-tuned open-weight model, 7 to 14 billion parameter class, quantisation variants included
Integrity
SHA-256 per file in a signed manifest, re-verified at pod start before any weight is loaded

Deployment artefacts

Helm chart
A single umbrella chart with a documented values reference. Helm 3.14 or later
Docker Compose
Single-node compose file for evaluation sandboxes and small production sites
Cluster add-ons
Reference manifests for GPU Operator, ingress, storage classes and network policies
Validation job
Post-install suite checking image digests, model checksums, GPU availability and end-to-end processing
Infrastructure examples
Terraform modules for the AWS and Azure private-cloud reference architectures

APIs, SDKs and connectors

API
REST and gRPC, OpenAPI 3.1 specification and protobuf definitions included in the bundle
SDKs
Python 3.10+, TypeScript on Node 20+, Java 17+, each with offline installable packages
Command line
Batch submission, schema management, health checks and bundle verification
Connectors
SharePoint and Microsoft 365, OpenText, Alfresco, generic CMIS 1.1, SFTP, IMAP and Graph mailboxes, S3-compatible object storage, Kafka
Export formats
JSON, CSV, XLSX, searchable PDF and annotated overlay PDF

Documentation and support artefacts

Offline documentation
Install guide, Helm values reference, API reference, runbooks and troubleshooting, as static HTML and PDF served by the console
Dashboards and alerts
Grafana dashboards and Prometheus alert rules for queue depth, GPU utilisation, throughput and error budget
SBOM
CycloneDX 1.6 per image, covering OS packages and language dependencies with versions
Security pack
Architecture and data-flow diagrams, control mapping, threat model summary, penetration-test summary, DPA template and a completed vendor security questionnaire
Licence files
Model licences, third-party open-source notices and your signed offline entitlement file

The security pack describes how the architecture supports your own certification and audit work. It does not claim certifications on our behalf — see the security page for exactly what is and is not asserted.

Supply chain

Everything your security review will ask for, shipped with the software

Most procurement delays are not disagreements. They are waiting — for an SBOM, for a data-flow diagram, for someone to answer question 47 of a vendor questionnaire. The security pack is in the bundle so that queue never forms.

  • A CycloneDX 1.6 SBOM per image, ingestible directly by Trivy, Grype, Black Duck or whatever your team already runs, with no internet lookup required
  • Cosign signatures and a build provenance attestation, verifiable offline against a published public key before anything crosses your boundary
  • Architecture and data-flow diagrams at the level an assessor actually wants, showing every service, every port and every storage location
  • Control mapping written against the frameworks your auditors use, describing how the architecture supports your certification rather than claiming one on our behalf
  • A completed vendor security questionnaire, a threat model summary, a penetration-test summary and a data processing addendum template you can hand straight to legal

BizfyLabs does not claim SOC 2 or ISO 27001 certification for DocxIntel. What the pack provides is the evidence your own certification and regulatory work needs — which, for an on-premise deployment inside your perimeter, is the thing that actually matters.

Security pack artefacts including SBOM, signed images, data-flow diagrams and control mapping
Positioning

What a bundle contains versus what an API key contains

A cloud parsing subscription is a good product with a very short packing list. The comparison is not about quality — it is about what you are left holding.

What a bundle contains versus what an API key contains
CriterionMetered parsing APIEnterprise BYOC tierDocxIntel bundle
What you receiveAn API keyVendor-controlled imagesImages, weights, chart, SBOM, docs
Model weightsVendor-hostedVendor-controlledOn your storage, pinned by digest
Works with no internetNoRequires cloud connectivityYes, by design
SBOM in the deliveryNot applicableOn requestCycloneDX 1.6 per image
Documentation offlineOnline onlyOnline onlyStatic HTML and PDF in the bundle
Self-hosting available onNo planTop enterprise tier onlyEvery licence
Cost of processing more pagesCharged per pageat published per-page ratesCharged per pageNo incremental charge

What you receive

Metered parsing API
An API key
Enterprise BYOC tier
Vendor-controlled images
DocxIntel bundle
Images, weights, chart, SBOM, docs

Model weights

Metered parsing API
Vendor-hosted
Enterprise BYOC tier
Vendor-controlled
DocxIntel bundle
On your storage, pinned by digest

Works with no internet

Metered parsing API
No
Enterprise BYOC tier
Requires cloud connectivity
DocxIntel bundle
Yes, by design

SBOM in the delivery

Metered parsing API
Not applicable
Enterprise BYOC tier
On request
DocxIntel bundle
CycloneDX 1.6 per image

Documentation offline

Metered parsing API
Online only
Enterprise BYOC tier
Online only
DocxIntel bundle
Static HTML and PDF in the bundle

Self-hosting available on

Metered parsing API
No plan
Enterprise BYOC tier
Top enterprise tier only
DocxIntel bundle
Every licence

Cost of processing more pages

Metered parsing API
Charged per pageat published per-page rates
Enterprise BYOC tier
Charged per page
DocxIntel bundle
No incremental charge

Comparison reflects publicly documented behaviour of metered document-parsing platforms as of 2026, including credit-based per-page pricing and enterprise-gated self-hosting. Verify against current vendor documentation before making a decision — we would rather you checked.

See the deployment models
Lifecycle

From bundle delivery to your third upgrade

What happens to the artefacts after they arrive, and what you can rely on three years in.

  1. 1
    Step 1

    Receive and verify

    The bundle arrives on encrypted media, through your transfer gateway, or as a download depending on your deployment model. You verify the cosign signatures and the SHA-256 manifest before anything is loaded — on your side of the boundary, with your own tooling.

  2. 2
    Step 2

    Scan against your own policy

    Load the SBOMs into your scanner and the images into your registry. Because the SBOMs ship inside the bundle, an air-gapped security review needs no vulnerability-database lookup at delivery time beyond the feed you already mirror.

  3. 3
    Step 3

    Install and validate

    One Helm release brings up all nine services. The bundled validation job then checks image digests, model checksums, GPU availability and end-to-end processing on a known document set, so you know the install is sound before real traffic reaches it.

  4. 4
    Step 4

    Operate on your own telemetry

    The bundled Grafana dashboards and Prometheus alert rules go straight into the monitoring stack you already run. Nothing is reported anywhere else — there is no vendor dashboard watching your cluster, because there is no connection for one.

  5. 5
    Step 5

    Upgrade on your schedule

    Feature releases quarterly, LTS releases with an 18-month security window, and cumulative upgrades so a long-disconnected cluster moves forward in one step. Roll through a canary namespace first; the chart supports it out of the box.

  6. 6
    Step 6

    Know your exit position

    If the relationship ends, the extracted data is already in your storage in open formats and the model weights are already on your volumes under their own licences. There is no export project, because there was never anything to export.

What am I actually installing?

The bundle questions that come up in every technical review, answered specifically.

Nine signed OCI container images, an open-weight model set of roughly 46 GB, a Helm chart, a Docker Compose file for single-node sites, a CycloneDX SBOM per image, an offline documentation set and a security pack. That is the whole bundle — around 62 GB compressed. There is no hidden component that reaches out for anything else at runtime.

Because a model you hold is a model you can keep. Open weights mean the files sit on your storage under a licence you can read, they keep working if a commercial API is deprecated or repriced, they can be inspected and scanned like any other artefact, and they can be pinned so that a document processed today produces the same output in five years. The per-model licence list is published on the model licences page.

Every image is signed with cosign, and the bundle ships a SHA-256 manifest covering every image archive and every model weight file. You verify signatures and checksums on your side of the boundary before anything is loaded into your registry, and the platform re-checks model checksums at pod start so a corrupted transfer fails loudly rather than quietly degrading accuracy.

Yes — a CycloneDX 1.6 SBOM for every image, shipped inside the bundle rather than promised on request. It lists operating system packages, language dependencies and their versions, so your existing scanning tooling can ingest it directly and your supply-chain review can be done offline.

Each LTS release carries an 18-month support window with security patches throughout. Feature releases ship quarterly. Upgrades are cumulative, so a cluster that has been disconnected for three quarters moves forward in a single Helm upgrade rather than a chain of hops, and the previous two LTS releases are always a supported starting point.

The full documentation set ships inside the bundle as static HTML and PDF, served by the admin console, so an air-gapped operator has the install guide, Helm values reference, API reference, runbooks and troubleshooting material without a route to the internet. The same content is published online for teams that have one.

Keep reading

Model licences→Every open-weight model in the bundle, its licence and what you are permitted to do with it.Deployment models→How the same bundle installs air-gapped, in your cloud, single-tenant or as a sandbox.Reference architectures→Where each of these nine services sits, on which nodes, behind which ports.Sizing and throughput→How much hardware the GPU services need for 50,000 to 5 million pages a month.Security architecture→Isolation, key custody, audit trails and what we do and do not claim about certification.API reference→Endpoints, payload shapes, authentication and callback behaviour for the submission API.

Ask for the manifest before you ask for a demo.

We will send the release manifest, the SBOM sample and the security pack so your architecture and security teams can review the actual artefacts rather than a description of them.

Talk to an engineer
How the Proof of Value works
  • No per-page metering
  • Runs in your environment
  • Written accuracy threshold
DocxIntel Logo

A product of BizfyLabs

Document intelligence that never leaves your building. Analyse, identify, classify, map, modify and ask — inside your own infrastructure.

BizfyLabs on LinkedInDocxIntel documentationBizfyLabs

Product

  • Capabilities
    • Analyse
    • Identify
    • Classify
    • Map
    • Modify
    • Ask
  • Accuracy benchmark
  • Pricing
  • Proof of Value

Technical

  • Deployment models
  • Reference architectures
  • Sizing & throughput
  • What's in the box
  • Security posture
  • Model licences
  • Documentation
  • API reference

Solutions

  • All industries
  • Insurance & TPAs
  • Healthcare
  • Banking & finance
  • Government
  • Legal
  • Energy & logistics

Compare

  • Compare approaches
  • LlamaParse alternative
  • Docsumo alternative
  • On-premise document AI

Company

  • About DocxIntel
  • FAQ
  • Partners
  • BizfyLabs
  • Careers
  • Contact

© 2026 BizfyLabs FZC LLC. All rights reserved.

DocxIntel™ is a product of BizfyLabs FZC LLC.

  • Privacy Policy·
  • Terms of Service·
  • Data Processing Addendum·
  • Acceptable Use·
  • Model Licences·
  • Security·
  • Cookies

Registered in the United Arab Emirates. Delivery partner: Bizfy Solutions LLP, Indore, India.

DocxIntel