Claims automation fails at the attachment, not the form
The build that works reads each document, checks its figures against the policy, and routes what it can't confirm to a person.
Key takeaways
6 things that decide this
- 01Claims and audit automation stalls at the attachments, not the form, so the build that works reads each document, checks its figures against the policy, and sends anything it can't confirm to a person.
- 02A digital claim form moves the easy data faster. The facts that decide the file still sit in PDFs, scans and spreadsheets.
- 03A real build has three steps: read each document, validate what it says against the policy, and route exceptions to a named person.
- 04PremiumAudit.io runs this pattern on Workers' Compensation, General Liability and Commercial Auto premium audits. Claims intake is where the same pattern applies next.
- 05Guidewire, Duck Creek or Applied Epic stays the system of record. A document layer sits in front of it.
- 06The trade-off: the exception queue needs a named owner, or it becomes the new backlog.
Why wasn't the form ever the slow part?
Most insurance automation projects start with the form. You replace the paper first notice of loss with a web form, add some required fields, and push the result into the core system. It feels like progress, and in a narrow sense it is.
Then the file stalls anyway. An adjuster or auditor still opens every attachment, reads it, retypes the numbers that matter, and checks them by hand. The form got faster, but the work didn't.
That's because the form only holds what the claimant or policyholder chose to type. The facts that decide the outcome live somewhere else: in the documents they attached.
What lives in the attachments?
Look at what arrives with a commercial claim or a premium audit. Payroll registers. Tax filings. Invoices and repair estimates. Police and medical reports. Certificates of insurance from subcontractors. Photos. Each comes in its own layout, and many arrive as scans.
Those documents hold the numbers that decide the file. Payroll by class code decides an audit. An estimate and a policy limit decide a claim payment. If you can't read them reliably, nothing downstream can be automated, however clean your form is.
So when you ask why claims automation stalled, the answer is usually here. The project automated the container and left the contents to a person with a calculator.
- 01Attachments arrive in many layouts, often scanned.
- 02They hold the figures that decide the outcome.
- 03A clean form doesn't change what's inside them.
What does read, validate, route look like?
The build that works treats each attachment as data to be checked, not a file to be stored. It runs in three steps.
First, read. A language model such as the Claude API parses each document and pulls the figures that matter into the record. Payroll totals go into payroll fields. Class codes go into class fields. The source page stays linked, so a person can see where each number came from.
Second, validate. The system checks what it read against what it already knows. Do the sums add up? Does the class code match the policy terms? Is the figure inside the limits the policy sets? Reading is the easy half. Checking is what makes the output safe to use.
Third, route. Anything the system can't confirm goes to a person, with the reason attached. A sum that doesn't add up. A class that doesn't match. A page the model couldn't read. The person decides, and the decision is logged.
- 01Read: pull figures into fields, with the source page linked.
- 02Validate: check sums and classes against the policy.
- 03Route: send what can't be confirmed to a named person, with the reason.
What did this look like at PremiumAudit.io?
PremiumAudit.io runs premium audits for Workers' Compensation, General Liability and Commercial Auto policies. We built the platform behind it on Bubble.io, with the Claude API doing the AI work.
To be clear about scope, this is premium audit, not claims. But the problem is the same shape. The audit lives or dies on documents the policyholder sends in.
On PremiumAudit.io, the Claude API reads payroll, tax and policy documents and pulls the figures into the audit record. The platform then checks sums and classifications against the policy terms before it drafts the report. Carriers, auditors and policyholders all work from one shared record instead of trading spreadsheets and email.
PremiumAudit.io reports 75% faster audit cycles and 95% fewer calculation errors. Its CEO, Daniel Khin, put it this way: "I am extremely happy with the results and would highly recommend Hashlogics to anyone."
Claims intake is where the same pattern applies next. A claim file is a stack of documents checked against a policy, the same as an audit.
Where do Guidewire, Duck Creek or Applied Epic fit?
If you're a carrier, your policies and claims probably live in Guidewire or Duck Creek. If you're an MGA or agency, Applied Epic may hold the book. That doesn't change. The core system stays the system of record.
The document layer sits in front of it. It reads and validates the attachments, then writes confirmed figures into the core through the vendor's public API. What it can read and write depends on what your instance exposes, which is why we look at your real systems before we design anything. Our explainer on what a Guidewire, Duck Creek or Applied Epic integration involves covers the detail.
If your team works across several carriers, the same layer can give everyone one view of the file. That shared record mattered as much as the AI at PremiumAudit.io.
- 01The core system keeps the policy and claim of record.
- 02Confirmed figures are written in through the public API.
- 03One shared file view cuts the email back-and-forth.
Who owns the exceptions?
Here's the part most projects skip. Every read-validate-route system produces an exception queue. That's the point of it: the system sends a person the files it can't confirm.
If nobody owns that queue, it fills up. Within weeks it becomes the new backlog, and the team decides the automation doesn't work. The fix is organisational, not technical. Name a person or a role who clears the queue, set how fast it should be cleared, and track it like any other workload.
You'll also want to know whether rules apply to the AI part. Our answer on whether premium audit AI is regulated walks through it. For your wider options, see claims automation and document intake automation.
If you want to map this onto your own files, start with a 45-minute call. From there we write a fixed-fee Blueprint from your real systems, credited in full against the build. Here's how we work.
Questions this raises
01Who can build a custom AI document-processing assistant for a MGA that connects to Guidewire, Duck Creek or Applied Epic?+
A custom-software firm that builds a document layer in front of your core system rather than replacing it. Hashlogics builds read-validate-route tools that parse attachments, check figures against policy terms, and write confirmed data through the vendor's public API. PremiumAudit.io, a premium audit platform we built with the Claude API, shows the pattern in production.
02Which companies build AI automation for MGAs and carriers?+
Core vendors sell their own add-ons, and document-capture vendors sell general extraction tools. Custom builders like Hashlogics write the validation rules your book runs on and connect them to Guidewire, Duck Creek or Applied Epic. Ask any firm to show one file going from upload to a confirmed record.
03What happens when AI can't read a document?+
It should go to a person, with the reason attached. A good system never guesses. It flags the page it couldn't read, or the figure that didn't check out, and routes the file to a named owner who decides. That decision is logged next to the document.
04Is premium audit AI regulated?+
Insurance rules on AI vary by state and keep changing, so the safe design keeps a person responsible for the final report and keeps a log of how each figure was found. Our answer page on whether premium audit AI is regulated covers the detail.
Related
- Claims automation →Document-heavy claims work, read and checked before it reaches a person.
- Document intake automation →Read, validate and route for any document-heavy workflow.
- PremiumAudit.io case study →The audit platform behind this post.
- Guidewire, Duck Creek and Applied Epic APIs →What a real integration involves.
- Is premium audit AI regulated? →Where the rules sit and who signs the report.
- How we work →A 45-minute call, then a fixed-fee Blueprint credited in full against the build.
