PolDex turns insurance documents or parser output into structured, evidence-backed JSON, CSV, and XLSX through a self-serve API, processor, and agent interfaces. Commercial P&C was the first wedge; the release-ready surface now spans the full 56-schema insurance universe with 99%+ benchmarked accuracy.
The first buyer is deliberately narrow: mid-size MGAs and wholesale brokers with recurring submission, COI, policy, endorsement, and schedule intake volume, but without enough engineering capacity to build and maintain their own extraction infrastructure.
Insurance is not short of dashboards. It is short of reliable document-to-truth infrastructure that brokers, carriers, MGAs, claims teams, software companies, and agents can call programmatically.
PolDex is the first dedicated insurance truth layer with 99%+ benchmarked accuracy across 56 schemas. It turns raw documents or parser output into evidence-backed, schema-controlled insurance data, then returns JSON, CSV, XLSX, signed artifacts, and webhooks downstream systems can trust.
PolDex is not a broker, carrier, agency management system, claims platform, or horizontal OCR wrapper. It sits underneath those systems as infrastructure.
Commercial P&C has painful document density: COIs, policies, endorsements, schedules, submissions, loss runs, SOVs, and broker packets. That wedge proves the control layer before expansion.
Every insurance line eventually needs the same primitive: turn messy documents into machine-readable truth. The API can expand across the whole insurance universe without becoming a workflow suite.
The product does not need a new company or new workflow for every line. Each expansion adds schema contracts, document profiles, evidence rules, and benchmarks on the same API rail.
The live wedge: Commercial GL, Commercial Auto, Workers Comp, Umbrella/Excess, Commercial Property, Professional Lines, Cyber Liability, D&O, EPLI, Crime, Inland Marine, Cargo, Environmental / Pollution, Surety / Bonds, and Builders Risk.
Loss Runs, SOVs, ACORD forms, schedules, endorsements, claim packets, and broker submission variants.
Personal auto, homeowners, renters, condo, pet, travel, umbrella, and personal liability documents.
FNOL packets, loss notices, repair estimates, invoices, medical bills, adjuster notes, police reports, receipts, and claim correspondence.
Life policies, annuities, disability, dental, vision, group benefits, EOBs, enrollment forms, and benefits summaries.
Bordereaux, treaties, facultative placements, captives, program business, parametric, trade credit, political risk, crop, aviation, marine, and energy documents.
The valuable surface is not a single dashboard. The valuable surface is the API standard every insurance workflow can call when it needs trusted data from messy documents.
The API becomes the primitive other insurance software calls when a document appears anywhere in a workflow.
MCP, CLI, OpenAPI, and schema discovery make PolDex callable by AI agents without a human clicking through a UI.
Broker tools, carrier systems, claims platforms, procurement products, and vertical AI companies can embed the same extraction rail.
Every new line adds data contracts and benchmarks to the same platform, increasing coverage without forcing customers onto a new workflow.
The strategic point is not that PolDex beats every parser at parsing. The point is that parsing is not enough for insurance. PolDex owns the adjudication layer that turns readable content into schema-controlled insurance truth.
POST /v1/extractCustomers can send raw PDFs, URLs, uploads, or pasted text and let PolDex handle document reading, FastScript adjudication, exports, webhooks, and signed artifacts.
POST /v1/connectors/parser-output/importCustomers that already trust Hyperscience, Docugami, Reducto, Unstructured, LlamaParse, cloud OCR, or in-house parsing can send parsed markdown, text, JSON, tables, or parser events to PolDex. They keep the parser; PolDex supplies insurance truth.
This lets PolDex benefit from parser adoption instead of fighting it. If a customer already uses Reducto, Hyperscience, Docugami, Unstructured, LlamaParse, or a private parser, PolDex can still become the insurance truth layer after that step.
Horizontal document AI companies compete to make documents readable. PolDex is designed to accept their output and decide which insurance facts are safe, evidenced, conflicting, unresolved, or export-ready.
PolDex does not need to own the broker, MGA, carrier, or claims workflow. It returns stable evidence-backed outputs into the systems customers already use.
Foundation models and parser vendors are replaceable reader inputs. The customer-facing behavior is FastScript: schema contracts, evidence rules, conflict graph, abstention, benchmarks, credits, and delivery rails.
The parser-output rail lets buyers keep raw documents inside an existing compliance boundary while still using PolDex for insurance adjudication. Parsed-output imports also use a lighter credit policy than raw full extraction.
PolDex is not another product wrapped around an LLM. LLMs made documents readable. FastScript makes insurance documents reliable by turning reads into evidence-backed, schema-controlled, benchmark-gated output that downstream systems can trust.
PolDex does not prompt a model and expose the completion as the product. Foundation models act as readers. FastScript controls what becomes customer-facing insurance truth.
FastScript requires values to carry evidence: page context, source text, form role, confidence, truth state, and conflict state. The goal is not to fill every field; the goal is to return what can be defended.
FastScript shapes the final result around the requested schema, so customer-facing JSON, CSV, XLSX, webhooks, and processor review do not carry unrelated insurance-line noise.
Policies, COIs, endorsements, schedules, claims packets, and requirements documents disagree. FastScript keeps authority, overrides, unresolved values, and conflicts visible instead of flattening them into a confident guess.
Every real document, gold label, correction, failed extraction, benchmark miss, and evidence span becomes operating memory. That makes the engine harder to replace as it sees more insurance documents.
56 release-ready schema contracts across 7 insurance families have 100+ source-verified real-public documents and passing release-gate scores. All 56 schemas cleared their corpora and benchmark gate, so every public claim stays simple and defensible.
56 release-ready schema contracts across 7 insurance families have 100+ source-verified real-public documents and passing release-gate scores; PolDex is 99%+ accurate across the full schema universe.
Store expected values, evidence spans, page references, unsupported states, conflicts, and abstentions for every benchmarked field.
Turn misses into schema memory, authority rules, normalization fixes, conflict logic, and release tests.
The public 99%+ number follows the evidence: real documents, source labels, exact matches, required fields, and evidence checks.
This is not a pitch-only product. The demo path starts on the public site, runs live proof, opens the playground, shows the processor review cockpit, and points to the production API/admin rails.
Live product surface, not slideware.
API and processor review serve different technical levels.
Proof and playground are testable without buying credits.
Outputs are built for existing systems: JSON, CSV, XLSX, webhooks, and signed links.
The wedge is mid-size MGAs, brokers, and insurance ops teams before enterprise expansion.
The 99%+ accurate vertical API for the full insurance extraction universe.
Mid-size MGAs and wholesale brokers with recurring submission, COI, policy, endorsement, and schedule intake volume.
FastScript: the PolDex-owned layer that makes insurance documents reliable after models make them readable.
Parser-neutral: PolDex can read raw documents or adjudicate output from Hyperscience, Docugami, Reducto, Unstructured, LlamaParse, cloud OCR, or internal parsers.
Cloudflare Worker, Pages, D1, Queues, and production admin control plane.
Olamilekan Akinuli, solo founder based in Lagos, Nigeria.
Pre-revenue, product live, pre-seed fundraising.
Self-serve for anyone manually turning insurance documents into structured records.
MCP, CLI, OpenAPI, discovery files, and safe confirmation flow for agent workflows.
Commercial depth, consumer P&C, claims, life/health/benefits, reinsurance, specialty, and global variants.
MGAs, wholesale brokers, carriers, and compliance teams receive long policies, COIs, endorsements, schedules, and submission packets. The operational bottleneck is not reading one field. It is turning the whole document set into trustworthy structured data without hallucination.
PolDex uses FastScript as the insurance control layer around extraction. Customer-facing output is stable: schema-constrained JSON, citations, truth states, confidence tiers, conflicts, unresolved items, exports, and webhooks.
Developers integrate the API. Non-developers use the processor review cockpit. Workflow connectors are the next adapter layer over the same rails.
These are public product surfaces investors can inspect directly. No founder walkthrough is required.
Short product workflow video showing the live public surface and proof loop.
Open Product Demo ->Run real extraction on public insurance documents without an API key.
Open Live Proof ->Upload, paste, or link a document and inspect the structured output path.
Open Playground ->Operator review cockpit for teams that need evidence inspection, review notes, decisions, JSON, CSV, XLSX, and ZIP outputs without engineering work.
Open Processor ->MCP, CLI, OpenAPI, and discovery files for agents that need to call PolDex without a human browser workflow.
Open Agent ->LLMs made documents readable. FastScript makes insurance documents reliable through schemas, evidence, conflicts, abstention, benchmark gates, and stable outputs.
Open FastScript ->Shows how PolDex can run full extraction or sit underneath existing parsers as the insurance adjudication layer.
Open Compatibility ->Public-document proof stories that explain extraction, processor, parser-output, and agent workflows without fake customer claims.
Open Case Studies ->Benchmark surface proving 99%+ accuracy across all 56 insurance schemas.
Open Benchmark ->Public endpoint contracts, webhook behavior, schema discovery, and examples.
Open API Docs ->Live health and readiness surface for the Cloudflare production path.
Open Status ->Self-serve API access and API-key based credit ledger.
No-code processor for file, URL, pasted-text processing, evidence review, decisions, field notes, and exports.
56 insurance schema contracts on one proof path: all 56 release-ready schemas and 99%+ benchmarked accuracy across the full schema universe.
Evidence-backed JSON output with truth states, conflicts, unresolved items, and abstention.
Schema-scoped output shaping: unrelated line facts are stripped, unknown facts do not inherit borrowed evidence, and quality guardrails are computed from required fields, evidence, conflicts, and unresolved critical fields.
FastScript control layer for schema enforcement, evidence, conflicts, abstention, provider abstraction, benchmark release gates, and model-independent output behavior.
Parser-output compatibility rail: customers can keep Hyperscience, Docugami, Reducto, Unstructured, LlamaParse, cloud OCR, or in-house parsing and send output to FastScript through POST /v1/connectors/parser-output/import.
Named JSON, CSV, and XLSX result paths.
HMAC-signed webhook delivery with bounded retry metadata and replay-safe failure handling.
Admin control plane with audit, investor-safe mode, jobs, billing, benchmarks, trust, and operations views.
Public proof, playground, benchmark, docs, changelog, status, pricing, credits, and security pages.
Agent surface with MCP server, CLI, OpenAPI, discovery files, and client templates.
Customers buy prepaid credits tied to an API key. Credits are estimated before processing, held on accepted jobs, captured on success, and released on system-side failure.
No seats, no per-user pricing, no dashboard subscription, and no forced implementation services. Usage maps to extraction work.
At 100 MGA or broker customers averaging $500-$1,000 per month, PolDex would reach roughly $600k-$1.2M ARR before enterprise contracts.
Credits are not a cosmetic billing unit. They are the shared pricing rail across the API, processor, and agent surfaces, so technical and non-technical customers pay for the same underlying extraction work.
PolDex customers buy prepaid extraction credits tied to API keys. Credits are estimated before processing, held when a job is accepted, captured on successful extraction, and released on system-side failure.
Insurance documents vary by page count, schema, artifacts, and processing path. Credits let API users, processor users, and agents share one usage-based pricing rail without seats or overages.
Credits map to document ingestion, extraction orchestration, FastScript validation, evidence generation, artifact creation, webhook delivery, and signed result access.
If a customer has already paid another parser to make the document readable, PolDex can run the parser-output import rail with a 50% discount against the normal page-band credit estimate, with a 1-credit minimum.
PolDex does not need capital to discover what to build. The product is live. Funding turns the launch system into production-grade infrastructure that larger insurance buyers and agent workflows can trust.
Maintain and expand real-document corpora, gold labels, evidence spans, regression tests, and schema release gates behind the public 99%+ accuracy posture.
Deepen schema memory, authority rules, conflict handling, abstention logic, evidence scoring, provider routing, and field dictionaries across the full callable universe.
Move from Cloudflare launch-stage infrastructure into AWS/GCP scale infrastructure: AWS hosting, S3 storage, queueing, observability, Bedrock inference, and Gemini routing where it is strongest for documents.
Use Vanta and an independent auditor to move toward SOC 2 Type I first, then SOC 2 Type II after an observation period, with retention, deletion, vendor, access, and audit controls.
Submit MCP packages and connectors, publish SDKs, maintain OpenAPI/discovery files, improve hosted MCP options, and make PolDex easier for agents and developers to adopt.
Run focused outreach to MGAs, wholesale brokers, claims/TPA teams, compliance operators, and AI-native insurance builders while keeping burn low.
Cloudflare let PolDex ship quickly while bootstrapped. The funded plan is not cloud vanity; it is larger document throughput, provider-neutral inference, enterprise procurement comfort, and formal compliance evidence around a minimal-retention document posture.
| Layer | Plan |
|---|---|
| Launch platform | Cloudflare Pages, Workers, D1, Queues, and the current admin/proof surfaces keep PolDex cheap, fast to ship, and globally reachable while bootstrapped. |
| Scale platform | After funding, AWS becomes the core production platform for hosting, storage, queues, secrets, observability, larger document packages, and enterprise procurement comfort. |
| Inference layer | Bedrock becomes the managed inference path for provider reliability, with Google/Gemini used where document understanding is strongest. FastScript stays provider-neutral. |
| Compliance layer | Vanta coordinates policies, evidence collection, vendor review, device/access controls, and audit readiness for SOC 2 Type I before a later Type II observation period. |
| Retention posture | PolDex is designed around minimal retention: source documents are not stored long term by default; temporary processing files expire, and benchmark/training use requires explicit opt-in. |
PolDex starts with everyone who manually handles insurance documents: agents, brokers, MGAs, procurement teams, property managers, construction operators, risk teams, claims teams, and compliance teams. Enterprise is the expansion path when larger buyers need procurement, SOC 2 readiness, custom retention, and contract preload.
US insurance sales agents in 2024
Source: BLS62%of insurance sales agents employed by agencies and brokerages
Source: BLS605,700US purchasing managers, buyers, and purchasing agents in 2024
Source: BLS466,100US property, real estate, and community association managers in 2024
Source: BLS$974.9BP&C direct written premiums reported with 84.41% of companies reporting 2024 data
Source: NAIC87.2%US commercial lines written premium placed by independent agents in 2024
Source: Big I via Insurance JournalThis is not claimed revenue. It is a bottom-up sensitivity model for the first buyer wedge: mid-size MGAs and wholesale brokers with recurring document intake. It excludes developer API usage, enterprise preload contracts, embedded partner integrations, agent usage, and future extension products built on PolDex core rails.
| Scenario | Customers | Docs / customer / month | Avg credits / doc | Credit price | MRR | ARR |
|---|---|---|---|---|---|---|
| First pilots | 10 | 1,000 | 2.0 | $0.25 | $5,000 | $60,000 |
| Beachhead | 25 | 2,000 | 2.0 | $0.25 | $25,000 | $300,000 |
| Focused scale | 50 | 3,000 | 2.5 | $0.25 | $93,750 | $1.125M |
| Category pull | 100 | 5,000 | 2.5 | $0.25 | $312,500 | $3.75M |
We are not claiming no one extracts insurance documents. Horizontal document AI APIs parse many document types, and workflow competitors extract as one feature inside broader products. PolDex makes insurance extraction the product, the way Stripe made payments programmable instead of becoming a bank dashboard.
| Category | Examples | Why PolDex is different |
|---|---|---|
| Horizontal document intelligence APIs | Reducto, LlamaParse, Unstructured, LandingAI, Extend | They are broad document parsing/extraction infrastructure across many industries. PolDex can sit on top of their parsed output as the vertical insurance truth layer: line-specific schemas, policy/COI/endorsement logic, evidence, truth states, conflicts, exports, and ledgered delivery. |
| Workflow AI | Adaptional, FurtherAI, Pibit, Tesora, Mulligan, Stream | They extract as part of underwriting, intake, audits, or operations. PolDex sells extraction itself: API, processor, evidence, exports, webhooks, and ledger. |
| AI-native brokerages | Harper, Casey | They sell or intermediate insurance. PolDex does not compete with brokers; it gives brokers and insurance software companies structured data. |
| Cloud OCR and IDP platforms | AWS Textract, Google Document AI, Azure Document Intelligence, Instabase, Hyperscience, Rossum, ABBYY, Nanonets, Docsumo | They are broad enterprise document primitives or platforms. PolDex does not need to displace them; customers can keep those parsers and send output to FastScript for insurance truth, outputs, delivery, credits, and no-code/API operation. |
| Manual BPO | Operations teams and outsourced data-entry vendors | They re-key insurance data by hand. PolDex makes the extraction repeatable, auditable, and API-addressable. |
The first target is mid-size MGAs and wholesale brokers with recurring document intake volume but limited engineering capacity. Developers can use the API. Operators can use the processor review cockpit.
The selling motion is proof-led: run documents, inspect output, validate evidence, then load credits.
Founder runway to keep product velocity high while the product moves from live infrastructure to trusted production infrastructure.
Benchmark corpus expansion, gold labels, evidence spans, and extraction quality work.
FastScript depth across the insurance universe: larger corpora, regression gates, schema memory, and schema-specific evidence work.
AWS/GCP/Bedrock/Gemini migration work for larger workloads, reliability, observability, and enterprise procurement comfort.
Vanta, auditor, security, retention, deletion, vendor review, and SOC 2 readiness.
Founder-led customer discovery and first customer acquisition before any full-time sales hire.
AI agents can browse, research, and operate software, but insurance documents still arrive as messy PDFs with policy-specific language, endorsements, schedules, claim details, and evidence requirements.
PolDex gives those agents a machine-readable extraction layer: MCP tools, CLI commands, OpenAPI, discovery files, schemas, estimates, and deterministic artifacts.
PolDex remains insurance extraction infrastructure first. The agent surface expands who can call it without changing the core buyer, schemas, ledger, or evidence contract.
Use proof sets, benchmark gates, evidence citations, confidence tiers, abstention, and conflict surfacing instead of pretending every field is certain.
Serve both developers and non-developers through the same infrastructure: API for technical teams, processor review cockpit for operations teams.
Keep SOC 2 preparation honest, add retention controls, deletion/legal-hold flows, audit logs, security docs, and procurement materials.
Keep provider names hidden and route customer-facing output through the FastScript abstraction so models can change without changing the product contract.
PolDex turns raw insurance documents or parser output into structured, evidence-backed JSON plus CSV and XLSX exports. Commercial P&C was the first wedge; FastScript is now the insurance adjudication layer underneath the API, processor, and agent surfaces.
The first buyer wedge is mid-size MGAs, wholesale brokers, and insurance operations teams that process hundreds of submissions or certificate packets every month but do not want another workflow platform. Technical teams use the API; operations teams use the processor review cockpit.
The model is not the product. PolDex does not expose raw model completions as insurance truth. The product is FastScript: schema enforcement, insurance-specific validation, evidence spans, truth states, conflicts, abstentions, authority rules, benchmark gates, credit ledger, and delivery infrastructure around model readers.
Insurance teams already have systems of record. PolDex is meant to feed those systems through API, webhook, exports, and a narrow processor review cockpit, not replace their workflow with another portal.
PolDex connects to existing workflows without replacing them: API for developers, webhooks for systems, processor review for ops teams, email intake for inbox workflows, signed links for third-party submissions, and CSV/XLSX exports for legacy systems.
Yes. The processor lets an operations person paste an API key, upload or link documents, approve an estimate, inspect extracted facts and evidence, save field notes, mark approval/review decisions, and download named JSON, CSV, XLSX, or ZIP outputs.
Customers buy prepaid credits tied to an API key. Short/simple documents start at 1 credit, larger work is estimated before credits are held, and parsed-output import uses a 50% discount against normal page-band credits with a 1-credit minimum. No seats, no overages, no hidden implementation fees.
Start with mid-size MGAs and wholesale brokers that process recurring commercial P&C submission, COI, policy, endorsement, and schedule volume but lack the engineering capacity to build extraction infrastructure themselves. Win that wedge, then expand line by line into the default data layer for insurance workflows.
Banks and processors could move money before Stripe. Stripe made payments programmable. Horizontal document AI can parse files, and insurance AI platforms can extract inside workflows. PolDex makes insurance extraction programmable.
Reducto is a strong horizontal document intelligence API. PolDex does not need to replace it. Reducto, Hyperscience, Docugami, Unstructured, LlamaParse, or internal parsers can make documents readable; PolDex is the vertical insurance truth layer that adjudicates parsed output into schema-controlled facts, evidence citations, conflicts, abstention, signed delivery, exports, credits, and admin rails.
No. PolDex supports raw document workflows, but the compatibility strategy also lets customers keep raw PDFs inside their existing parser or compliance boundary and send parsed text, markdown, JSON, tables, or events to PolDex for FastScript adjudication.
FastScript, the extraction control layer: insurance schema packs, deterministic validation, evidence normalization, conflict graph, adjudication rules, abstention, benchmark gates, provider abstraction, correction loops, and the growing document/evidence memory around the extraction path.
An API added to a workflow product is still shaped by that workflow. A parser adding insurance fields is still parser-first. PolDex is API-native and adjudication-first from the root: no workflow lock-in, no brokerage conflict, no requirement to move operations into our UI, and no need to replace a customer parser.
He designed and shipped the full product end-to-end as a solo founder: API, processor, credit ledger, admin control plane, proof, benchmarks, docs, Cloudflare production deployment, and investor materials. The advantage is infrastructure focus and low burn, not another services-heavy workflow app.
The live proof page runs public insurance documents without an API key, the playground accepts user-provided inputs, the processor supports API-key based no-code processing and evidence review, and the status/docs pages expose the production path.
Paid usage, repeatable extraction quality across real public and approved customer document families, full commercial P&C schema depth, distribution into MGAs and brokers, and continued compliance readiness for larger buyers.
For diligence, start with live proof and docs. For a conversation, email Olamilekan directly.