Claim Intake Agent
First Touch
Receives initial accident reports across WhatsApp, SMS, and email. Collects required fields and initializes the structured claim record.
- whatsapp_parser
- sms_inbound
- form_validator
Case Study / 02 — AutoClaim
5 stages, 4 external parties, automated reminders — and one rule: every unclear case goes back to a human.
AutoClaim is the operations layer Profitec built for an insurance agency that handles vehicle insurance claims. It automates the operational flow from first accident report to final claim closure: intake, documents, signatures, insurer emails, appraiser and garage follow-up, reminders, dashboard tracking, and human escalation.
5
Stages
4
External parties
7d
Follow-up cadence
HITL
Human-in-the-loop
The system in motion
Five stages. Every claim, end-to-end.
Intake, customer follow-up, insurer coordination, appraiser handoff, closure. Every cycle ends either auto-closed or escalated to a human — never silently stuck.
The bottleneck
The bottleneck was not one task. It was the constant switching.
The agency worked across WhatsApp, SMS, email, forms, documents, insurers, garages, appraisers, and internal follow-up lists. One missing signature or one unanswered insurer email could quietly delay an entire claim. The cost wasn’t any single step — it was the agent’s mental load of holding 30 open claims in their head simultaneously, with no system telling them what was waiting on what.
The system
One AI process that manages the claim from opening to closure.
The system follows the same five-stage operating logic the agency already uses: opening and intake, customer follow-up, insurer coordination, appraiser and garage coordination, and final closure. Each stage emits structured events that update the dashboard and decide what runs next.
autoclaim.flow · live
● running01 · OPEN
├── Intake (claim open)
└── Documents (signatures)
02 · CUSTOMER
└── Follow-Up (customer reminders)
03 · INSURER
├── Insurer Coord (two-way email)
└── Classifier (email intent)
┄┄→ HITL · escalation
04 · APPRAISER
└── Appraiser (+ garage)
05 · CLOSE
└── Closure (verify · CRM)Every arrow is a handoff with rules. Solid lines are the main flow; the dashed line out of the Classifier is the HITL gate — whenever an insurer email lands in the “ambiguous” bucket, the process stops and a human takes over.
The agents
Not a chatbot. An operations agent with a dashboard.
Seven specialized agents, each owning a specific operational handoff. Narrow responsibility, clear inputs, structured outputs, and explicit handoff rules — so failure is observable and recoverable.
Document & Signature Agent
Package Owner
Requests licenses, bank approvals, and signatures. Tracks completion against the required package and emits a completion event when ready.
- e_signature_api
- document_parser
- checklist_state
Customer Follow-Up Agent
Reminder Engine
Sends reminders to the customer for missing documents and status updates. Timing adapts to prior responsiveness; office is alerted on repeated non-response.
- email_outbound
- sms_outbound
- smart_timing
Insurer Coordination Agent
Two-Way Channel
Manages two-way communication with the insurance company. Tracks escalation timelines, decisions, and the state of every open thread.
- email_imap
- calendar_api
- escalation_timer
Email Intent Classifier
Routing Brain
Parses inbound insurer emails. Classifies each as clear request, ambiguous, or decision — with a confidence score. Ambiguous cases route to the HITL gate.
- llm_classifier
- intent_schema
- confidence_threshold
Appraiser & Garage Agent
Vendor Liaison
Schedules appraisals, coordinates garage work, tracks invoices and turnaround times against the active claim.
- calendar_api
- vendor_email
- invoice_tracker
Closure Agent
Final Verification
Verifies completion of every required document, finalizes the claim, and writes the closure event back to the CRM.
- document_checklist
- crm_api
- closure_event
The control layer
Built for automation, but not blind automation.
“Policy: automation handles the predictable; people handle judgment.”
The system automates predictable steps and escalates anything that may require judgment. Scenario mapping is a development prerequisite: each party, each possible reply, each automated response and each human-handoff condition was defined before a single agent was built.
Handoff rules & required package
Two pieces of configuration the system reads at runtime. The rules dictate when a human is called; the package dictates when a claim is closed.
cfgView handoff_rules.json
{
"missing_documents": "alert_office_after_failed_customer_followup",
"unclear_email": "escalate_to_human",
"non_standard_request": "escalate_to_human",
"decision_required": "notify_dashboard_and_email",
"external_party_delay": "send_reminder_after_waiting_period"
}cfgView claim_package.txt
Required package: · claim notification form · owner + driver consents · vehicle license · driver license · bank approval / check copy · appraiser report · appraiser invoice · garage invoice · payment approval
The dashboard
Every claim has a visible status, stage, and next action.
Every claim is visible: who’s blocked, on what, for how long. Status is computed from the events emitted by each agent, not entered manually. The agency sees the whole portfolio at a glance and can drill into any specific claim to see exactly where it sits in the five-stage flow.
autoclaim · dashboard
| Claim | Stage | Next action | Days open |
|---|---|---|---|
| CL-3847 | Customer | Doc reminder · 2nd attempt | 5d |
| CL-3851 | Insurer | Awaiting decision | 12d |
| CL-3852 | Appraiser | Appraisal scheduled | 7d |
| CL-3858 | Close | Final invoice + sign-off | 18d |
| CL-3863 | Customer | Signature pending | 3d |
5 of 47 open · live
Manual baseline · cycle
34d
Post-AutoClaim · cycle
20d
Cycle compression
−41%
Average claim lifecycle · by stage
Days spent in each of the five operating stages — before vs after launch
- Open
- Customer
- Insurer
- Appraiser
- Closure
Before · manual
34 days total
4d
8d
12d
7d
3d
After · AutoClaim
20 days total
4d
8d
5d
Per-stage compression
| Stage | Before | After | Δ |
|---|---|---|---|
| Opening & intake | 4d | 1d | −3d |
| Customer follow-up | 8d | 4d | −4d |
| Insurer coordination | 12d | 8d | −4d |
| Appraiser & garage | 7d | 5d | −2d |
| Closure | 3d | 2d | −1d |
| Total | 34d | 20d | −14d |
The result
Faster follow-up, fewer forgotten tasks, cleaner handoffs.
AutoClaim reduces the administrative load by moving repetitive follow-up work from people to an AI-controlled process. Human attention is focused where it matters: exceptions, judgment, and relationship management.
Pre-launch baseline
31/wk
Post-launch peak
73/wk
Throughput lift
2.4×
Claims processed · weekly
16-week window · 8 weeks before launch + 8 weeks after
- Processed
- Forgotten
Endpoints
- Pre-launch avg31/wk
- W16 peak73/wk
- Forgotten~3/wk → 0
Throughput ramp · W9–W12
First weeks post-launch agents shadowed the system; AutoClaim handled intake and follow-up. Throughput climbed from ~30/wk to ~60/wk within a month.
Forgotten claims · W11 onwards
Reminder cadence + dashboard visibility hit zero forgotten claims by W11 and stayed there. Before the system, agents were dropping 2–4 claims per week through inbox triage.
Throughput per agent went up. Forgotten claims went to zero. The work that’s left is the work that needs a human.
The build
Small enough to pilot. Structured enough to scale.
Nine to ten weeks of build, 207 hours of total engineering effort, close support across the first 30 days post-launch. The architecture is designed to scale: each agent is independent, handoff rules are configuration not code, and new agents can be added without touching the existing flow.
W 1–2
Discovery + scenario mapping
Every party, every reply, every escalation condition defined before code.
W 3–5
Agent development + integration
Seven agents built and wired to WhatsApp, SMS, e-signature, and CRM.
W 6–7
Dashboard + observability
Status engine derives stage and next-action from emitted events.
W 8–9
Testing + pilot launch
Live claims run in parallel with manual fallback. Edge cases hardened.
W 10
Production cutover
Full handover with close support across the first 30 days post-launch.
The pattern
Insurance claims are the case study. The architecture is broader.
The same architecture transplants anywhere a business has document-heavy, follow-up-heavy processes with multiple external parties and a small number of decision points that genuinely need a human.
- Health insurance claims processing
- Legal case intake and document chase — different pattern, same architectural idea
- Loan origination and underwriting
- Real estate transaction coordination
- Construction permit and inspection processes
- Any process with four-plus external parties, repeated follow-up, and document gathering
Next step
Want an AI operations layer for your insurance agency?
15-minute fit call. We map the stages, the parties, the handoffs, and the HITL gates around your existing operating flow.