Introduction to OpenInsure

OpenInsure is a fully open-source insurance operating system purpose-built for Managing General Agents (MGAs), captive insurance programs, and Risk Retention Groups (RRGs). It replaces legacy policy administration systems, spreadsheet-driven underwriting workflows, and duct-taped billing integrations with a single, coherent platform built on modern infrastructure.

For MGAs

Submission intake, delegated authority enforcement, producer portals, and automated bordereaux reporting.

For Captives

Member contribution tracking, cell structures (PCC/Series LLC), loss fund monitoring, and domicile compliance.

For RRGs

LRRA compliance, NAIC quarterly/annual statements, Schedule F reinsurance reporting, and reciprocal state registration.

API-First

Every capability exposed as a versioned REST API, TypeSpec-generated OpenAPI spec, and TypeScript SDK.

What OpenInsure Is

At its core, OpenInsure is a policy administration and underwriting operations platform. It handles the full lifecycle of a specialty insurance program:

Submission — A producer submits an ACORD 125 application (via portal or API). Workers AI extracts structured data from unstructured PDFs.
Rating — The deterministic rating engine applies factor tables (state, class, revenue band, loss history) to produce a quoted premium with a full audit trail.
Binding — The bind API checks delegated authority limits, applies SpiceDB ReBAC policies, and creates an active policy record in PlanetScale.
Servicing — Endorsements, cancellations, reinstatements, and renewals are all first-class operations with full state machine enforcement.
Billing — Installment schedules are created automatically. Stripe PaymentIntents handle collection. Commission splits are calculated and tracked in a fiduciary trust ledger.
Claims — FNOL intake triggers adjuster assignment, reserve setup, and document management. The settlement workflow routes through approval gates.
Reporting — Bordereaux, loss runs, bordereaux cession statements, and actuarial data exports are generated automatically.

Who It’s For

Managing General Agents (MGAs)

MGAs operate under delegated authority from carriers, which means they need real-time enforcement of binding authority limits, automated bordereaux reporting, and a producer-facing self-service portal. OpenInsure was designed from the ground up for this operational model.

Key capabilities for MGAs:

ACORD 125 ingestion with AI extraction via Workers AI
Underwriting Workbench with real-time referral queue
Delegated authority limit enforcement (by state, class, aggregate)
Monthly premium and claims bordereaux to carriers and reinsurers
Producer commission accounting with earned/unearned split

Captive Insurance Programs

Captives have unique needs: member contribution tracking, cell isolation for Protected Cell Companies, and rigorous loss fund monitoring. OpenInsure supports single-parent captives, group captives, and PCCs with per-cell data isolation enforced at the application level via orgId scoping.

Key capabilities for captives:

Member organization management with annual contribution schedules
Protected cell and Series LLC structure support
Real-time funded ratio monitoring
Stop-loss layer erosion tracking (specific and aggregate)
Domicile-specific filing deadline automation (VT, DE, HI, NC, DC, MT)

Risk Retention Groups (RRGs)

RRGs are federally chartered under the Liability Risk Retention Act (LRRA) but domiciled and regulated in a single state. They must register as a “non-admitted” carrier in every state where they write coverage, file NAIC financial statements quarterly, and comply with complex Schedule F reinsurance reporting.

Key capabilities for RRGs:

Automated NAIC quarterly/annual statement preparation
Reciprocal state registration tracking
Schedule F cession reporting
Surplus lines tax calculation for non-domicile states

Core Modules

Package	Description
`@openinsure/policy`	Policy state machine, endorsements, cancellations, renewals
`@openinsure/underwriting`	Rating engine, rule execution, binding authority
`@openinsure/billing`	Installment plans, Stripe integration, commission accounting
`@openinsure/claims`	FNOL intake, reserves, settlement, subrogation
`@openinsure/auth`	Auth worker session bridge + OpenInsure JWT + SpiceDB ReBAC
`@openinsure/hipaa`	PHI field tagging, redaction, immutable audit log
`@openinsure/compliance`	Regulatory rule engine, filing reminders
`@openinsure/coi`	Certificate of Insurance generation (PDF + portal)
`@openinsure/documents`	ACORD extraction, PDF rendering, document management
`@openinsure/rating`	Actuarial factor tables and premium calculation
`@openinsure/producer`	Producer/agent management, appointment tracking
`@openinsure/reinsurance`	Treaty and facultative reinsurance management
`@openinsure/crypto`	AES-256-GCM field-level encryption for PII (Web Crypto API)
`@openinsure/flags`	KV-backed feature flags with per-org overrides
`@openinsure/agents`	AI agent orchestration (Cloudflare Durable Objects + Claude)

How It Differs from Legacy Systems

Legacy PAS

Old way: Monolithic on-premises Java applications, per-seat licensing, 6-month implementation timelines, expensive customization via professional services.

OpenInsure

New way: Edge-native microservice packages, open-source Apache 2.0 license, running locally in under 10 minutes, extensible via TypeScript.

Specific improvements over legacy systems:

Latency: API responses from Cloudflare edge nodes are measured in single-digit milliseconds, not hundreds.
Auditability: Every state transition, rating calculation, and data access is logged immutably. No more reconstructing what happened from DB backups.
Integrations: Native ACORD 125/130, X12 EDI, FHIR R4, and Stripe. No middleware required.
Developer experience: The entire platform runs locally with pnpm dev. Full type safety from database schema to API response.

Open-Source Philosophy

OpenInsure is licensed under Apache 2.0. The full actuarial logic, policy state machine, compliance rules, and HIPAA primitives are open source and community-reviewed. There are no proprietary “runtime fees” or data export restrictions.

We believe that the insurance industry’s infrastructure layer should be a public good — auditable, forkable, and improvable by the community of insurance technologists who build on it.

Next Steps

Quickstart

Get a local instance running in under 10 minutes.

Architecture

Understand the edge-native data flow and HIPAA isolation model.

API Reference

Explore the full interactive API documentation.