The problem
A major insurer receives a claim as a bundle of artefacts: forms, photographs, invoices, repair estimates, medical notes, incident reports. The handler's real work is rarely reading any single document. It is checking whether the documents agree with each other, with the policy, and with the loss event as described. That cross-checking is slow and uneven, and it is exactly where leakage lives: an invoice dated before the loss, damage inconsistent with the peril claimed, an exclusion nobody surfaced until the claim was already paid.
I designed the architecture for a claims evidence integrity layer: multi-agent verification of claim artefacts, consistency checking across claim, policy and loss event, and fraud signalling split into deterministic and model layers, all feeding a human case handlers who makes the decision. Teams I worked with took it through build and assurance.
Why it was hard
The artefacts are hostile to automation. Photographs of documents, scanned forms filled by hand, estimates in a hundred formats. Extraction alone was never the hard part; the hard part is that consistency judgments carry consequences in both directions. Miss a genuine inconsistency and the insurer pays a claim it should have queried. Assert an inconsistency that is not there and an honest customer is treated as a suspect, which is a conduct harm, not a quality defect.
That asymmetry shaped everything. A model that fluently narrates suspicion is the most dangerous component you can put in a claims pipeline, because its confidence does not correlate with its evidence. Fraud reasoning had to be explainable claim by claim, and the system had to know the difference between what it could prove and what it could only notice.
Key decisions
Every artefact is normalised into typed evidence objects by the platform's document intelligence services before any reasoning runs. Models reason over structure with provenance attached, never over raw scans.
Verification is a set of narrow agents, each owning one question: provenance, arithmetic, timeline, coverage. Narrow agents are individually testable against labelled cases, which a single broad reviewer never is.
Fraud signals live in two layers with different rights. The deterministic layer, dates, arithmetic, duplicate detection, policy terms, is the only layer allowed to assert, and every assertion carries a rule identifier. The model layer produces ranked, cited observations and is structurally incapable of issuing a verdict.
Every inconsistency must cite both sides: the claim artefact and the policy clause or loss fact it conflicts with. An uncited finding does not exist.
The disposition is never automated. The pipeline produces a verified dossier with open questions; the handler pays, queries or refers.
Architecture
The pipeline runs on the insurer's Azure estate. Artefacts land in a claim workspace, document intelligence services produce typed evidence objects, and an orchestration layer fans verification agents out across managed model endpoints. A consistency stage triangulates claim, policy and loss event. Deterministic fraud rules run first, the model signal layer ranks what remains, and everything composes into a cited dossier for the handler.
Low-confidence extractions never propagate. An evidence object below the confidence bar routes to an exception path for human correction rather than flowing onward as a guess, because a wrong date entering the timeline check poisons every downstream finding.
Trade-offs
Narrow verification agents multiply orchestration compared with one broad reviewer, and that cost is paid gladly: each agent has a labelled test set and a measurable error rate, which is what assurance actually consumes. Keeping the model layer verdict-free leaves some genuine fraud ranked rather than flagged, and that is the right side of the asymmetry to err on. The human gate caps the throughput gain, deliberately; the system's job is to make the handler's hour count, not to remove the handler.
Governance
The two-layer split is the control. Anything that can affect a customer adversely traces to a deterministic rule with an identifier, a version and an owner; model output is advisory context around that spine. Every finding carries its citations, the exception path is a designed state rather than a failure, and the whole pattern shipped as a certified pattern with its evaluation pack and control mapping, built from historical claims with known outcomes.
Outcome
The programme took the design through build and assurance for a major insurer. Handlers receive a dossier in which the checking is already done and cited, with open questions surfaced instead of buried, and the fraud conversation moved from gut feel to evidence that survives challenge. The two-layer signalling pattern has since been reused for adjacent document-heavy verification work.
What I learned
The most important line in the design is the one between asserting and observing; once a model can accuse, you have built an unexplainable control and no amount of prompt discipline fixes that. Consistency, not extraction, is the product in claims work. And an exception queue designed on day one is governance; the same queue bolted on later is an apology.