AgentHack submission type
Enterprise Agents
Name
Gopinath Selvarajan
Team name
TFO Automation [Tech Masters]
Team members
gopinath.selvarajan@accenture.com,
suresh.jayaprakash@accenture.com,
r.t.srinivasan@accenture.com,
p.boominathan@accenture.com
How many agents do you use
Multiple agents
Industry category in which use case would best fit in (Select up to 2 industries)
Insurance
Complexity level
Advanced
Summary (abstract)
This automation streamlines insurance claim processing by using UiPath Agentic Automation to intelligently retrieve claim requests from emails, verify policy coverage, validate uploaded documents, detect potential fraud, calculate eligible claim amounts, and present actionable insights in a dashboard for user approvals. It reduces manual workload, improves accuracy, and accelerates claim settlement decisions for insurers.
Detailed problem statement
1. Slow Processing & High Turnaround Time
- Current manual verification takes 7-15 days per claim, leading to customer dissatisfaction.
- 30% of claims require back-and-forth communication due to missing/incomplete documents.
2. Rising Fraudulent Claims
- 12-15% of claims involve fraud (inflated bills, duplicate charges, or non-covered treatments).
- Insurers lose â‚ą8,000+ crores annually (India) due to undetected fraud.
- Manual reviews miss subtle patterns (e.g., same doctor billing suspiciously high consultations).
3. Human Errors & Policy Misinterpretation
20-25% of claims are incorrectly processed due to:
- Data entry mistakes (wrong policy numbers, incorrect bill amounts).
- Misalignment with policy terms (e.g., approving non-covered OTC medicines).
- Adjusters struggle to track 50+ dynamic coverage rules across plans.
4. Disconnected Systems & Poor Audit Trails
Claims data is scattered across:
- Emails (customer submissions).
- ERPs (policy details).
- Spreadsheets (approval logs).
- No real-time sync leads to version conflicts and compliance risks.
5. Lack of Real-Time Fraud Detection
Existing tools flag only obvious fraud (e.g., duplicate claims).
Miss emerging patterns like:
- “Doctor shopping” (patients visiting multiple providers for the same issue).
- “Upcoding” (billing for a higher-cost procedure than performed).
6. Scalability Challenges
- Manual processes fail during peak seasons (e.g., post-monsoon health claims).
- Insurers face high operational costs (₹300–500 per claim) for human verification.
Detailed solution
We built a UiPath Agentic Automation pipeline to automate end-to-end insurance claim processing, ensuring consistency, speed, and accuracy.
1. Trigger - Claim Initiation via Email
- Automation is triggered upon receiving a claim request email.
- Reads email content, extracts claim details, and initiates the RPA workflow.
2. Email Processing & Classification
- An agent bot classifies whether it is a valid claim request.
- Extracts relevant claim data from the email body for further processing.
3. Claim Data Extraction from Insurance System
The bot logs into the Google Apps-based insurance ERP system to retrieve:
- Policy coverage and details
- Customer details
- Claimed items under the policy
- Validates claim details from the email against policy data.
- If funds are unavailable, sends an email notifying the claimant that the claim is invalid.
4. Document Download & Validation
- Downloads attachments from the insurance system and stores them in a structured folder.
- Validates the presence of mandatory documents and marks them as Valid/Invalid in the ERP system.
- Sends emails requesting additional documents if needed.
5. Fraud Detection Agent
An agent reviews medical bills and discharge summaries using pre-defined rules to detect:
- Overbilling
- Unnecessary billed items
- Overcharging or suspicious entries
- Flags discrepancies and provides recommendations for further review.
6. Claim Calculation (Claim Processor Agent)
The Claim Processor Agent reviews flagged items and recommendations.
Cross-checks final medical bills with policy coverage rules, considering:
- Already claimed amounts
- Eligible claimable items
- Policy norms and guidelines
Calculates the final claimable amount accurately.
7. Result Update & Dashboard Reporting
- Pushes the final output (Summary, Recommendations, Discrepancies, Flagged Items, Claimable/Non-Claimable Items, and Claimable Amount) to a Google Sheet integrated into the Insurance Dashboard.
- Users can review the Action Queue in the dashboard and take action (approve/reject) based on the automated analysis.
Demo Video
Expected impact of this automation
1. Faster Claims Processing
Current Process: Manual verification takes 5-10 working days due to document checks, approvals, and human errors.
With Automation: Straightforward claims processed in under 30 minutes; complex cases within 24 hours.
Time Saved: 90% reduction in processing time, enabling insurers to handle 3X more claims with the same staff.
2. Cost Savings & Efficiency
Manual Cost per Claim: ₹300–500 (staff time, follow-ups, corrections).
Automated Cost per Claim: ₹50–100 (system processing + minimal oversight).
Annual Savings: For an insurer processing 1 lakh claims/year, savings exceed ₹2.5–4 crores annually.
3. Fraud Reduction & Financial Protection
Current Fraud Detection: Only 10–15% caught manually; ₹8,000+ crores lost annually in India.
Automated Detection: Flags suspicious claims (duplicates, inflated bills, non-network markups) with 85–90% accuracy.
Potential Savings: 30–50% reduction in fraudulent payouts, saving crores yearly.
4. Fewer Errors & Rejections
Manual Errors: 20–30% of claims delayed/rejected due to incorrect data or missing documents.
Automated Checks: Validates policy numbers, treatment codes, and documents in real-time.
Impact: 70% fewer rejections, reducing customer complaints.
5. Scalability & Workforce Optimization
Peak Season Handling: Manual systems struggle during high claim volumes (e.g., monsoon illnesses).
Automation Benefit: Processes 10,000+ claims/day without delays or extra hires.
Staff Productivity: Frees up employees from repetitive tasks to focus on complex cases & customer service.
6. Improved Customer Experience
Transparency: Customers receive real-time SMS/email updates (e.g., “Claim received → Under review → Approved”).
Faster Payouts: 80% of claims settled within 1 day vs. industry average of 7+ days.
Higher Satisfaction: 20–25% improvement in CSAT scores due to speed and clarity.
UiPath products used (select up to 4 items)
UiPath Agent Builder
UiPath Maestro
UiPath Orchestrator
UiPath Studio Web
Automation Applications
Insurance Claim Portal (Client Specific)
Integration with external technologies
Google Workspace, Drive, Gmail, Sheets, Docs
Agentic solution architecture (file size up to 4 MB)
Sample inputs and outputs for solution execution
Sample Inputs (High-Level)
- Incoming Email: Claim request with patient details and attached medical documents.
- Insurance System Data: Policy coverage, available funds, prior claims.
- Uploaded Documents: Discharge summary, final bill, prescription.
- Fraud Detection Rules: Coverage limits for room rent, consultation, medicines.
Sample Outputs (High-Level)
- Classifies email as valid claim request and extracts details
- Validates policy funds (alerts if insufficient balance)
- Checks uploaded documents (alerts for missing, marks valid/invalid)
- Fraud Agent flags excess billing items
- Calculates eligible claimable amount considering flagged discrepancies
- Updates dashboard with summary, flagged items, recommendations, claimable amount for user approval