A 40-person claims operation at a mid-market property and casualty insurer came to us drowning in paper. Average first notice of loss to first decision ran 9.2 business days. Customers were churning at renewal. Adjusters were burning out. Within 12 weeks, we built an AI claims processing system that cut cycle time by 68%, reduced claims leakage by 14%, and gave the team back roughly 9,000 hours a year. Here is exactly how we scoped it, built it, and rolled it out.

The problem: a claims team buried in manual intake

When the VP of Claims first called, her team was handling about 2,400 claims a month across auto, property, and small commercial lines. The bottleneck was not the decision. It was everything around the decision.

Every claim arrived differently. Some came through a web form. Some through email with PDF attachments. Some through a third-party administrator portal. Adjusters spent the first 40 minutes of every claim just assembling the file: pulling the policy, reading the loss description, sorting photos, and re-keying data into the core claims system.

The math was punishing. With an average of 38 minutes of pure administrative handling per claim, the team was burning roughly 15,200 hours a year on work that required no adjudication judgment at all.

Three symptoms the business felt:

• Slow cycle time. 9.2 days from first notice of loss to first decision, against a market benchmark closer to 4 days.
• Inconsistent triage. Simple claims and complex claims hit the same queue, so a $900 windshield claim waited behind a $40,000 fire loss.
• Leakage. Rushed adjusters were missing subrogation opportunities and overpaying on claims that should have been flagged for review.

The VP did not want to hire eight more adjusters. She wanted a system that could do the mechanical 70% so her team could own the judgment-heavy 30%.

How we scoped the project

Before writing a single prompt, we ran our standard AI project scoping process. Three conditions had to be true before we would build.

First, the workflow had to be high volume and repetitive. At 2,400 claims a month, intake cleared that bar easily. Second, the company needed a documented set of rules, in this case their claims handling guidelines and authority matrix. Without a source of truth, AI has nothing to adjudicate against. Third, outputs had to land in a tool the team already used. If adoption requires a new login, adoption dies.

The insurer ran Guidewire ClaimCenter as their system of record. Adjusters lived in ClaimCenter and Outlook all day. Those constraints shaped everything we built next.

What we built

The system runs in four stages. Each stage has a clear handoff and a human checkpoint.

Stage 1: Omnichannel intake and document extraction

Every inbound channel, web form, email, and TPA portal, feeds into a single ingestion layer. An AI extraction model reads each document, whether it is a typed claim form, a photographed receipt, or a handwritten police report, and pulls the structured fields: policy number, date of loss, loss type, claimant, estimated severity, and supporting evidence.

This replaced the manual re-keying that ate the first 40 minutes of every claim. Intake handling time dropped from 38 minutes to under 6.

Stage 2: Coverage check and severity triage

The system matches the extracted claim against the policy in ClaimCenter and runs an automated coverage check. Is the policy active? Is the loss type covered? Are there exclusions or sublimits that apply?

It then scores severity and complexity to route the claim. A clean, low-severity, single-coverage claim goes to the fast track. A claim with injuries, multiple coverages, or fraud signals routes straight to a senior adjuster with the risk factors flagged. This triage alone unblocked the simple claims that used to wait days behind complex ones.

Stage 3: Adjuster decision support

For every claim, the system compiles a structured summary the adjuster opens inside ClaimCenter. Not a wall of text. A clean panel with the coverage determination, a recommended reserve range based on similar historical claims, flagged subrogation and fraud indicators, and a one-click path to approve, request more information, or escalate.

Adjusters told us this was the single biggest time saver. Not the AI reading the claim. The AI doing the clerical work around the decision so the adjuster could focus on judgment.

The fraud and subrogation flags mattered most for the bottom line. The model surfaces patterns a rushed human misses at 4 PM, prior claims from the same claimant, inconsistent loss descriptions, and recovery opportunities against third parties. This is where the leakage reduction came from.

Stage 4: Learning loop

Every adjuster override becomes training data. When an adjuster sets a reserve outside the recommended range, or dismisses a fraud flag, that decision feeds a weekly review. The claims lead reviews the deltas and decides whether the handling guidelines need updating or the system needs a tuning pass.

After 10 weeks of live use, the guidelines had been updated 17 times based on patterns the system surfaced. The AI was sharpening the playbook, not just enforcing it.

The results after 90 days

We measured against a 90-day baseline collected before launch. The numbers:

• Cycle time: 9.2 days to 2.9 days. A 68% reduction in time from first notice of loss to first decision.
• Intake handling time: down 84%. Redeployed to investigation, customer communication, and complex adjudication.
• Claims leakage: down 14%. Driven by better fraud detection and more consistent subrogation capture.
• Adjuster hours on administrative work: down roughly 9,000 hours annualized. That is the equivalent of four and a half full-time adjusters the company did not have to hire.
• Customer satisfaction on claims: up 22 points. Faster decisions were the single biggest driver in their post-claim survey.

The VP of Claims summed it up at the 90-day review: "My adjusters used to spend their mornings doing data entry. Now they spend them actually adjusting claims. We did not replace anyone. We finally let the adjusters adjust."

What made this work, and what usually kills projects like this

We have seen insurance AI projects fail more often than they succeed. Four things made this one different.

We started with the rules, not the model. The AI is only as good as the handling guidelines and authority matrix it adjudicates against. Teams that skip that cleanup get inconsistent output and blame the model.

We kept humans in the loop on every decision. The system never auto-approves a payment. It drafts the analysis. Adjusters decide. That is the only architecture that survives regulatory scrutiny and real financial risk.

We integrated where the work already lived. ClaimCenter and Outlook. Zero new interfaces. Adoption hit 100% in week two because nobody had to learn a new tool.

We measured the right things. Cycle time, leakage, hours redeployed, customer satisfaction. Not "model accuracy" in a vacuum. The business cared about speed and loss ratio, so those were the metrics we optimized.

Takeaways for any claims or operations leader

A few things to steal, whether you work with us or not.

Audit your repetitive intake work first. If your skilled people spend more than half their time assembling files and re-keying data, AI claims processing, or its equivalent in your function, will almost certainly pay back inside a year.

Clean up your handling guidelines before you buy any tool. A current set of rules with clear authority levels is worth more than any vendor demo.

Budget for integration, not just the model. In our experience the AI itself is 30% of the build. The other 70% is getting the outputs into the system of record your team already uses.

Pick a workflow with a clear metric. If you cannot say exactly what "good" looks like in numbers, the project will drift.

If you run a claims, underwriting, or operations team where skilled people spend half their week on intake and data entry, the automation economics in 2026 are no longer a close call. The tooling is real. The workflows are mapped. The ROI shows up inside a quarter.

We have now built systems like this across insurance, finance, legal, and operations teams over more than 1,000 projects. If you want to see what it would look like for your team, get started here and we will map it on a 15-minute call.