An AI deal room that turns a data-room dump into exhibit-ready analysis

Insurance M&A diligence is one of the most data-intensive workflows in professional services. When a regional actuarial firm evaluates an acquisition target, its team receives hundreds of documents from a virtual data room: reserve reports, claims triangles, statutory filings, experience study data, reinsurance treaties. Each arrives in a different format, from a different source, at a different level of completeness.

The team's job is to turn that pile into defensible analysis: experience studies with credibility-weighted A/E ratios, data quality findings that trace to specific source documents, risk assessments with quantified financial impact, and exhibits a client can act on. The methodology itself is rigorous and well-established. The bottleneck is everything around it: classifying documents, extracting structured data, cross-referencing figures across reports, flagging inconsistencies, assembling workpapers. On a typical deal, weeks of calendar time go to data preparation before the actuarial judgment work even begins.

This firm does not lack technology. It has built a portfolio of proprietary analytics and modeling platforms used across the insurance industry. So anything we proposed had to complement that stack, not compete with it.

We started by studying how the diligence practice actually works, step by step, not the idealized version. How documents arrive in batches, how teams classify them under deadline pressure, how experience studies get built from incomplete data, how quality issues surface midstream and cascade downstream, how assumptions get set and contested, how exhibits get revised as new information lands. That study produced a seven-stage workflow model, from document triage through to the assumption audit trail, specific to insurance M&A diligence rather than a generic analytics pipeline.

The core of the system is a context graph, a formal ontology built for this one workflow: eleven entity types in four layers, connected by fourteen defined relationships. The four layers map to how a deal actually progresses. Deal Core holds the transaction, the target, and the acquirer. Insurance Data holds every data-room document, the portfolios extracted from them, and the experience studies built on that portfolio data. Analysis holds data quality findings and actuarial assumptions, where validation happens and where human judgment enters. Outputs holds deal risks, valuation inputs, and the exhibits delivered to the client.

Enlarge

Close

The relationships are the point. When the system ingests a reserve report and an actuarial opinion that state different reserve figures for the same portfolio, the graph's structure is what lets it surface that discrepancy automatically, link it to the affected experience study, flag the downstream risk, and note the impact in the relevant exhibit. No one programmed that specific chain of inference. The ontology makes it structurally possible. From the eleven entity types, the system generates a defined set of tools that agents use to interact with the data, so every operation goes through a known interface and every data point traces back to a source document, page, and table. It is auditable by design, not as an afterthought.

We built a working prototype and ran it against a simulated deal: the acquisition of a multi-line life and disability insurer with four portfolios, over 193,000 in-force lives, and $4.3 billion in combined reserves.

The system processed 142 data-room documents. It classified 128 of them automatically, flagged 14 for human review where confidence was low, and identified 4 document categories it expected for a deal of this type but had not received. Documents it could not classify were blocked, not guessed at. From those documents it extracted 89 structured data entities across 67 source files, all linked to their source pages, and generated six experience studies with A/E ratios, credibility weights, and benchmark comparisons.

Then the findings cascaded, which is the part that shows the ontology working. It caught a $47 million reserve discrepancy between the statutory statement and the actuarial report the moment both were ingested. Missing claims data for one block reduced the credibility of that block's experience study; the incidence study ran adverse at an A/E of 1.18 and the termination study showed claims lasting longer than expected. The system connected those findings to the $284 million in booked reserves for that block and surfaced a reserve adequacy risk of $18 to $32 million. That connection happened through the graph's relationships, not through a prompt telling it what to look for. In total it produced seven draft exhibits and a risk register with an aggregate estimated adjustment of $90 to $139 million, every risk linked to the evidence chain that produced it, every assumption recording who set it, what supported it, what alternatives were considered, and why they were rejected.

One principle governed the whole system: AI accelerates everything around the judgment call and does not make the judgment call. Assumptions are set by actuaries. The system assembles the evidence, flags the gaps, and documents the rationale. When evidence is incomplete, it blocks the assumption from being finalized and generates a specific question for the management interview. It will not let analysis proceed past an unresolved data gap.

The obvious value is capacity: compress the weeks a team spends on data preparation and you free principals to spend more time on interpretation and client advice, handle more deals, and surface risks earlier. The more durable value is what the graph holds. The firm's actuarial methods, its proprietary benchmarks, its approach to credibility and assumption development get encoded into the ontology itself. The AI handles ingestion and computation. The graph enforces consistency and traceability. The actuaries own the judgment. That is what makes this a platform the firm keeps, rather than a prototype it outgrows.